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 "winreg.h"
  37 #include "gdi_private.h"
  38 #include "wine/exception.h"
  39 #include "wine/unicode.h"
  40 #include "wine/debug.h"
  41
  42 WINE_DEFAULT_DEBUG_CHANNEL(font);
  43
  44   /* Device -> World size conversion */
  45
  46 /* Performs a device to world transformation on the specified width (which
  47  * is in integer format).
  48  */
  49 static inline INT INTERNAL_XDSTOWS(DC *dc, INT width)
  50 {
  51     double floatWidth;
  52
  53     /* Perform operation with floating point */
  54     floatWidth = (double)width * dc->xformVport2World.eM11;
  55     /* Round to integers */
  56     return GDI_ROUND(floatWidth);
  57 }
  58
  59 /* Performs a device to world transformation on the specified size (which
  60  * is in integer format).
  61  */
  62 static inline INT INTERNAL_YDSTOWS(DC *dc, INT height)
  63 {
  64     double floatHeight;
  65
  66     /* Perform operation with floating point */
  67     floatHeight = (double)height * dc->xformVport2World.eM22;
  68     /* Round to integers */
  69     return GDI_ROUND(floatHeight);
  70 }
  71
  72 static inline INT INTERNAL_XWSTODS(DC *dc, INT width)
  73 {
  74     POINT pt[2];
  75     pt[0].x = pt[0].y = 0;
  76     pt[1].x = width;
  77     pt[1].y = 0;
  78     LPtoDP(dc->hSelf, pt, 2);
  79     return pt[1].x - pt[0].x;
  80 }
  81
  82 static inline INT INTERNAL_YWSTODS(DC *dc, INT height)
  83 {
  84     POINT pt[2];
  85     pt[0].x = pt[0].y = 0;
  86     pt[1].x = 0;
  87     pt[1].y = height;
  88     LPtoDP(dc->hSelf, pt, 2);
  89     return pt[1].y - pt[0].y;
  90 }
  91
  92 static HGDIOBJ FONT_SelectObject( HGDIOBJ handle, HDC hdc );
  93 static INT FONT_GetObjectA( HGDIOBJ handle, INT count, LPVOID buffer );
  94 static INT FONT_GetObjectW( HGDIOBJ handle, INT count, LPVOID buffer );
  95 static BOOL FONT_DeleteObject( HGDIOBJ handle );
  96
  97 static const struct gdi_obj_funcs font_funcs =
  98 {
  99     FONT_SelectObject,  /* pSelectObject */
 100     FONT_GetObjectA,    /* pGetObjectA */
 101     FONT_GetObjectW,    /* pGetObjectW */
 102     NULL,               /* pUnrealizeObject */
 103     FONT_DeleteObject   /* pDeleteObject */
 104 };
 105
 106 typedef struct
 107 {
 108     LOGFONTW    logfont;
 109 } FONTOBJ;
 110
 111 struct font_enum
 112 {
 113   LPLOGFONTW          lpLogFontParam;
 114   FONTENUMPROCW       lpEnumFunc;
 115   LPARAM              lpData;
 116   BOOL                unicode;
 117   HDC                 hdc;
 118   INT                 retval;
 119 };
 120
 121 /*
 122  *  For TranslateCharsetInfo
 123  */
 124 #define MAXTCIINDEX 32
 125 static const CHARSETINFO FONT_tci[MAXTCIINDEX] = {
 126   /* ANSI */
 127   { ANSI_CHARSET, 1252, {{0,0,0,0},{FS_LATIN1,0}} },
 128   { EASTEUROPE_CHARSET, 1250, {{0,0,0,0},{FS_LATIN2,0}} },
 129   { RUSSIAN_CHARSET, 1251, {{0,0,0,0},{FS_CYRILLIC,0}} },
 130   { GREEK_CHARSET, 1253, {{0,0,0,0},{FS_GREEK,0}} },
 131   { TURKISH_CHARSET, 1254, {{0,0,0,0},{FS_TURKISH,0}} },
 132   { HEBREW_CHARSET, 1255, {{0,0,0,0},{FS_HEBREW,0}} },
 133   { ARABIC_CHARSET, 1256, {{0,0,0,0},{FS_ARABIC,0}} },
 134   { BALTIC_CHARSET, 1257, {{0,0,0,0},{FS_BALTIC,0}} },
 135   { VIETNAMESE_CHARSET, 1258, {{0,0,0,0},{FS_VIETNAMESE,0}} },
 136   /* reserved by ANSI */
 137   { DEFAULT_CHARSET, 0, {{0,0,0,0},{FS_LATIN1,0}} },
 138   { DEFAULT_CHARSET, 0, {{0,0,0,0},{FS_LATIN1,0}} },
 139   { DEFAULT_CHARSET, 0, {{0,0,0,0},{FS_LATIN1,0}} },
 140   { DEFAULT_CHARSET, 0, {{0,0,0,0},{FS_LATIN1,0}} },
 141   { DEFAULT_CHARSET, 0, {{0,0,0,0},{FS_LATIN1,0}} },
 142   { DEFAULT_CHARSET, 0, {{0,0,0,0},{FS_LATIN1,0}} },
 143   { DEFAULT_CHARSET, 0, {{0,0,0,0},{FS_LATIN1,0}} },
 144   /* ANSI and OEM */
 145   { THAI_CHARSET, 874, {{0,0,0,0},{FS_THAI,0}} },
 146   { SHIFTJIS_CHARSET, 932, {{0,0,0,0},{FS_JISJAPAN,0}} },
 147   { GB2312_CHARSET, 936, {{0,0,0,0},{FS_CHINESESIMP,0}} },
 148   { HANGEUL_CHARSET, 949, {{0,0,0,0},{FS_WANSUNG,0}} },
 149   { CHINESEBIG5_CHARSET, 950, {{0,0,0,0},{FS_CHINESETRAD,0}} },
 150   { JOHAB_CHARSET, 1361, {{0,0,0,0},{FS_JOHAB,0}} },
 151   /* reserved for alternate ANSI and OEM */
 152   { DEFAULT_CHARSET, 0, {{0,0,0,0},{FS_LATIN1,0}} },
 153   { DEFAULT_CHARSET, 0, {{0,0,0,0},{FS_LATIN1,0}} },
 154   { DEFAULT_CHARSET, 0, {{0,0,0,0},{FS_LATIN1,0}} },
 155   { DEFAULT_CHARSET, 0, {{0,0,0,0},{FS_LATIN1,0}} },
 156   { DEFAULT_CHARSET, 0, {{0,0,0,0},{FS_LATIN1,0}} },
 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   /* reserved for system */
 161   { DEFAULT_CHARSET, 0, {{0,0,0,0},{FS_LATIN1,0}} },
 162   { SYMBOL_CHARSET, CP_SYMBOL, {{0,0,0,0},{FS_SYMBOL,0}} }
 163 };
 164
 165 static void FONT_LogFontAToW( const LOGFONTA *fontA, LPLOGFONTW fontW )
 166 {
 167     memcpy(fontW, fontA, sizeof(LOGFONTA) - LF_FACESIZE);
 168     MultiByteToWideChar(CP_ACP, 0, fontA->lfFaceName, -1, fontW->lfFaceName,
 169                         LF_FACESIZE);
 170     fontW->lfFaceName[LF_FACESIZE-1] = 0;
 171 }
 172
 173 static void FONT_LogFontWToA( const LOGFONTW *fontW, LPLOGFONTA fontA )
 174 {
 175     memcpy(fontA, fontW, sizeof(LOGFONTA) - LF_FACESIZE);
 176     WideCharToMultiByte(CP_ACP, 0, fontW->lfFaceName, -1, fontA->lfFaceName,
 177                         LF_FACESIZE, NULL, NULL);
 178     fontA->lfFaceName[LF_FACESIZE-1] = 0;
 179 }
 180
 181 static void FONT_EnumLogFontExWToA( const ENUMLOGFONTEXW *fontW, LPENUMLOGFONTEXA fontA )
 182 {
 183     FONT_LogFontWToA( &fontW->elfLogFont, &fontA->elfLogFont );
 184
 185     WideCharToMultiByte( CP_ACP, 0, fontW->elfFullName, -1,
 186                          (LPSTR) fontA->elfFullName, LF_FULLFACESIZE, NULL, NULL );
 187     fontA->elfFullName[LF_FULLFACESIZE-1] = '\0';
 188     WideCharToMultiByte( CP_ACP, 0, fontW->elfStyle, -1,
 189                          (LPSTR) fontA->elfStyle, LF_FACESIZE, NULL, NULL );
 190     fontA->elfStyle[LF_FACESIZE-1] = '\0';
 191     WideCharToMultiByte( CP_ACP, 0, fontW->elfScript, -1,
 192                          (LPSTR) fontA->elfScript, LF_FACESIZE, NULL, NULL );
 193     fontA->elfScript[LF_FACESIZE-1] = '\0';
 194 }
 195
 196 static void FONT_EnumLogFontExAToW( const ENUMLOGFONTEXA *fontA, LPENUMLOGFONTEXW fontW )
 197 {
 198     FONT_LogFontAToW( &fontA->elfLogFont, &fontW->elfLogFont );
 199
 200     MultiByteToWideChar( CP_ACP, 0, (LPCSTR)fontA->elfFullName, -1,
 201                          fontW->elfFullName, LF_FULLFACESIZE );
 202     fontW->elfFullName[LF_FULLFACESIZE-1] = '\0';
 203     MultiByteToWideChar( CP_ACP, 0, (LPCSTR)fontA->elfStyle, -1,
 204                          fontW->elfStyle, LF_FACESIZE );
 205     fontW->elfStyle[LF_FACESIZE-1] = '\0';
 206     MultiByteToWideChar( CP_ACP, 0, (LPCSTR)fontA->elfScript, -1,
 207                          fontW->elfScript, LF_FACESIZE );
 208     fontW->elfScript[LF_FACESIZE-1] = '\0';
 209 }
 210
 211 /***********************************************************************
 212  *              TEXTMETRIC conversion functions.
 213  */
 214 static void FONT_TextMetricWToA(const TEXTMETRICW *ptmW, LPTEXTMETRICA ptmA )
 215 {
 216     ptmA->tmHeight = ptmW->tmHeight;
 217     ptmA->tmAscent = ptmW->tmAscent;
 218     ptmA->tmDescent = ptmW->tmDescent;
 219     ptmA->tmInternalLeading = ptmW->tmInternalLeading;
 220     ptmA->tmExternalLeading = ptmW->tmExternalLeading;
 221     ptmA->tmAveCharWidth = ptmW->tmAveCharWidth;
 222     ptmA->tmMaxCharWidth = ptmW->tmMaxCharWidth;
 223     ptmA->tmWeight = ptmW->tmWeight;
 224     ptmA->tmOverhang = ptmW->tmOverhang;
 225     ptmA->tmDigitizedAspectX = ptmW->tmDigitizedAspectX;
 226     ptmA->tmDigitizedAspectY = ptmW->tmDigitizedAspectY;
 227     ptmA->tmFirstChar = min(ptmW->tmFirstChar, 255);
 228     if (ptmW->tmCharSet == SYMBOL_CHARSET)
 229     {
 230         ptmA->tmFirstChar = 0x1e;
 231         ptmA->tmLastChar = 0xff;  /* win9x behaviour - we need the OS2 table data to calculate correctly */
 232     }
 233     else if (ptmW->tmPitchAndFamily & TMPF_TRUETYPE)
 234     {
 235         ptmA->tmFirstChar = ptmW->tmDefaultChar - 1;
 236         ptmA->tmLastChar = min(ptmW->tmLastChar, 0xff);
 237     }
 238     else
 239     {
 240         ptmA->tmFirstChar = min(ptmW->tmFirstChar, 0xff);
 241         ptmA->tmLastChar  = min(ptmW->tmLastChar,  0xff);
 242     }
 243     ptmA->tmDefaultChar = ptmW->tmDefaultChar;
 244     ptmA->tmBreakChar = ptmW->tmBreakChar;
 245     ptmA->tmItalic = ptmW->tmItalic;
 246     ptmA->tmUnderlined = ptmW->tmUnderlined;
 247     ptmA->tmStruckOut = ptmW->tmStruckOut;
 248     ptmA->tmPitchAndFamily = ptmW->tmPitchAndFamily;
 249     ptmA->tmCharSet = ptmW->tmCharSet;
 250 }
 251
 252
 253 static void FONT_NewTextMetricExWToA(const NEWTEXTMETRICEXW *ptmW, NEWTEXTMETRICEXA *ptmA )
 254 {
 255     FONT_TextMetricWToA((const TEXTMETRICW *)ptmW, (LPTEXTMETRICA)ptmA);
 256     ptmA->ntmTm.ntmFlags = ptmW->ntmTm.ntmFlags;
 257     ptmA->ntmTm.ntmSizeEM = ptmW->ntmTm.ntmSizeEM;
 258     ptmA->ntmTm.ntmCellHeight = ptmW->ntmTm.ntmCellHeight;
 259     ptmA->ntmTm.ntmAvgWidth = ptmW->ntmTm.ntmAvgWidth;
 260     memcpy(&ptmA->ntmFontSig, &ptmW->ntmFontSig, sizeof(FONTSIGNATURE));
 261 }
 262
 263 static DWORD get_key_value( HKEY key, const WCHAR *name, DWORD *value )
 264 {
 265     WCHAR buf[12];
 266     DWORD count = sizeof(buf), type, err;
 267
 268     err = RegQueryValueExW( key, name, NULL, &type, (BYTE *)buf, &count );
 269     if (!err)
 270     {
 271         if (type == REG_DWORD) memcpy( value, buf, sizeof(*value) );
 272         else *value = atoiW( buf );
 273     }
 274     return err;
 275 }
 276
 277 static UINT get_subpixel_orientation( HKEY key )
 278 {
 279     static const WCHAR smoothing_orientation[] = {'F','o','n','t','S','m','o','o','t','h','i','n','g',
 280                                                   'O','r','i','e','n','t','a','t','i','o','n',0};
 281     DWORD orient;
 282
 283     /* FIXME: handle vertical orientations even though Windows doesn't */
 284     if (get_key_value( key, smoothing_orientation, &orient )) return GGO_GRAY4_BITMAP;
 285
 286     switch (orient)
 287     {
 288     case 0: /* FE_FONTSMOOTHINGORIENTATIONBGR */
 289         return WINE_GGO_HBGR_BITMAP;
 290     case 1: /* FE_FONTSMOOTHINGORIENTATIONRGB */
 291         return WINE_GGO_HRGB_BITMAP;
 292     }
 293     return GGO_GRAY4_BITMAP;
 294 }
 295
 296 static UINT get_default_smoothing( HKEY key )
 297 {
 298     static const WCHAR smoothing[] = {'F','o','n','t','S','m','o','o','t','h','i','n','g',0};
 299     static const WCHAR smoothing_type[] = {'F','o','n','t','S','m','o','o','t','h','i','n','g','T','y','p','e',0};
 300     DWORD enabled, type;
 301
 302     if (get_key_value( key, smoothing, &enabled )) return 0;
 303     if (!enabled) return GGO_BITMAP;
 304
 305     if (!get_key_value( key, smoothing_type, &type ) && type == 2 /* FE_FONTSMOOTHINGCLEARTYPE */)
 306         return get_subpixel_orientation( key );
 307
 308     return GGO_GRAY4_BITMAP;
 309 }
 310
 311
 312 /***********************************************************************
 313  *           GdiGetCodePage   (GDI32.@)
 314  */
 315 DWORD WINAPI GdiGetCodePage( HDC hdc )
 316 {
 317     UINT cp = CP_ACP;
 318     DC *dc = get_dc_ptr( hdc );
 319
 320     if (dc)
 321     {
 322         cp = dc->font_code_page;
 323         release_dc_ptr( dc );
 324     }
 325     return cp;
 326 }
 327
 328 /***********************************************************************
 329  *           FONT_mbtowc
 330  *
 331  * Returns a Unicode translation of str using the charset of the
 332  * currently selected font in hdc.  If count is -1 then str is assumed
 333  * to be '\0' terminated, otherwise it contains the number of bytes to
 334  * convert.  If plenW is non-NULL, on return it will point to the
 335  * number of WCHARs that have been written.  If pCP is non-NULL, on
 336  * return it will point to the codepage used in the conversion.  The
 337  * caller should free the returned LPWSTR from the process heap
 338  * itself.
 339  */
 340 static LPWSTR FONT_mbtowc(HDC hdc, LPCSTR str, INT count, INT *plenW, UINT *pCP)
 341 {
 342     UINT cp;
 343     INT lenW;
 344     LPWSTR strW;
 345
 346     cp = GdiGetCodePage( hdc );
 347
 348     if(count == -1) count = strlen(str);
 349     lenW = MultiByteToWideChar(cp, 0, str, count, NULL, 0);
 350     strW = HeapAlloc(GetProcessHeap(), 0, lenW*sizeof(WCHAR));
 351     MultiByteToWideChar(cp, 0, str, count, strW, lenW);
 352     TRACE("mapped %s -> %s\n", debugstr_an(str, count), debugstr_wn(strW, lenW));
 353     if(plenW) *plenW = lenW;
 354     if(pCP) *pCP = cp;
 355     return strW;
 356 }
 357
 358 /***********************************************************************
 359  *           CreateFontIndirectExA   (GDI32.@)
 360  */
 361 HFONT WINAPI CreateFontIndirectExA( const ENUMLOGFONTEXDVA *penumexA )
 362 {
 363     ENUMLOGFONTEXDVW enumexW;
 364
 365     if (!penumexA) return 0;
 366
 367     FONT_EnumLogFontExAToW( &penumexA->elfEnumLogfontEx, &enumexW.elfEnumLogfontEx );
 368     enumexW.elfDesignVector = penumexA->elfDesignVector;
 369     return CreateFontIndirectExW( &enumexW );
 370 }
 371
 372 /***********************************************************************
 373  *           CreateFontIndirectExW   (GDI32.@)
 374  */
 375 HFONT WINAPI CreateFontIndirectExW( const ENUMLOGFONTEXDVW *penumex )
 376 {
 377     HFONT hFont;
 378     FONTOBJ *fontPtr;
 379     const LOGFONTW *plf;
 380
 381     if (!penumex) return 0;
 382
 383     if (penumex->elfEnumLogfontEx.elfFullName[0] ||
 384         penumex->elfEnumLogfontEx.elfStyle[0] ||
 385         penumex->elfEnumLogfontEx.elfScript[0])
 386     {
 387         FIXME("some fields ignored. fullname=%s, style=%s, script=%s\n",
 388             debugstr_w(penumex->elfEnumLogfontEx.elfFullName),
 389             debugstr_w(penumex->elfEnumLogfontEx.elfStyle),
 390             debugstr_w(penumex->elfEnumLogfontEx.elfScript));
 391     }
 392
 393     plf = &penumex->elfEnumLogfontEx.elfLogFont;
 394     if (!(fontPtr = HeapAlloc( GetProcessHeap(), 0, sizeof(*fontPtr) ))) return 0;
 395
 396     fontPtr->logfont = *plf;
 397
 398     if (plf->lfEscapement != plf->lfOrientation)
 399     {
 400         /* this should really depend on whether GM_ADVANCED is set */
 401         fontPtr->logfont.lfOrientation = fontPtr->logfont.lfEscapement;
 402         WARN("orientation angle %f set to "
 403              "escapement angle %f for new font %p\n",
 404              plf->lfOrientation/10., plf->lfEscapement/10., fontPtr);
 405     }
 406
 407     if (!(hFont = alloc_gdi_handle( fontPtr, OBJ_FONT, &font_funcs )))
 408     {
 409         HeapFree( GetProcessHeap(), 0, fontPtr );
 410         return 0;
 411     }
 412
 413     TRACE("(%d %d %d %d %x %d %x %d %d) %s %s %s %s => %p\n",
 414           plf->lfHeight, plf->lfWidth,
 415           plf->lfEscapement, plf->lfOrientation,
 416           plf->lfPitchAndFamily,
 417           plf->lfOutPrecision, plf->lfClipPrecision,
 418           plf->lfQuality, plf->lfCharSet,
 419           debugstr_w(plf->lfFaceName),
 420           plf->lfWeight > 400 ? "Bold" : "",
 421           plf->lfItalic ? "Italic" : "",
 422           plf->lfUnderline ? "Underline" : "", hFont);
 423
 424     return hFont;
 425 }
 426
 427 /***********************************************************************
 428  *           CreateFontIndirectA   (GDI32.@)
 429  */
 430 HFONT WINAPI CreateFontIndirectA( const LOGFONTA *plfA )
 431 {
 432     LOGFONTW lfW;
 433
 434     if (!plfA) return 0;
 435
 436     FONT_LogFontAToW( plfA, &lfW );
 437     return CreateFontIndirectW( &lfW );
 438 }
 439
 440 /***********************************************************************
 441  *           CreateFontIndirectW   (GDI32.@)
 442  */
 443 HFONT WINAPI CreateFontIndirectW( const LOGFONTW *plf )
 444 {
 445     ENUMLOGFONTEXDVW exdv;
 446
 447     if (!plf) return 0;
 448
 449     exdv.elfEnumLogfontEx.elfLogFont = *plf;
 450     exdv.elfEnumLogfontEx.elfFullName[0] = 0;
 451     exdv.elfEnumLogfontEx.elfStyle[0] = 0;
 452     exdv.elfEnumLogfontEx.elfScript[0] = 0;
 453     return CreateFontIndirectExW( &exdv );
 454 }
 455
 456 /*************************************************************************
 457  *           CreateFontA    (GDI32.@)
 458  */
 459 HFONT WINAPI CreateFontA( INT height, INT width, INT esc,
 460                               INT orient, INT weight, DWORD italic,
 461                               DWORD underline, DWORD strikeout, DWORD charset,
 462                               DWORD outpres, DWORD clippres, DWORD quality,
 463                               DWORD pitch, LPCSTR name )
 464 {
 465     LOGFONTA logfont;
 466
 467     logfont.lfHeight = height;
 468     logfont.lfWidth = width;
 469     logfont.lfEscapement = esc;
 470     logfont.lfOrientation = orient;
 471     logfont.lfWeight = weight;
 472     logfont.lfItalic = italic;
 473     logfont.lfUnderline = underline;
 474     logfont.lfStrikeOut = strikeout;
 475     logfont.lfCharSet = charset;
 476     logfont.lfOutPrecision = outpres;
 477     logfont.lfClipPrecision = clippres;
 478     logfont.lfQuality = quality;
 479     logfont.lfPitchAndFamily = pitch;
 480
 481     if (name)
 482         lstrcpynA(logfont.lfFaceName,name,sizeof(logfont.lfFaceName));
 483     else
 484         logfont.lfFaceName[0] = '\0';
 485
 486     return CreateFontIndirectA( &logfont );
 487 }
 488
 489 /*************************************************************************
 490  *           CreateFontW    (GDI32.@)
 491  */
 492 HFONT WINAPI CreateFontW( INT height, INT width, INT esc,
 493                               INT orient, INT weight, DWORD italic,
 494                               DWORD underline, DWORD strikeout, DWORD charset,
 495                               DWORD outpres, DWORD clippres, DWORD quality,
 496                               DWORD pitch, LPCWSTR name )
 497 {
 498     LOGFONTW logfont;
 499
 500     logfont.lfHeight = height;
 501     logfont.lfWidth = width;
 502     logfont.lfEscapement = esc;
 503     logfont.lfOrientation = orient;
 504     logfont.lfWeight = weight;
 505     logfont.lfItalic = italic;
 506     logfont.lfUnderline = underline;
 507     logfont.lfStrikeOut = strikeout;
 508     logfont.lfCharSet = charset;
 509     logfont.lfOutPrecision = outpres;
 510     logfont.lfClipPrecision = clippres;
 511     logfont.lfQuality = quality;
 512     logfont.lfPitchAndFamily = pitch;
 513
 514     if (name)
 515         lstrcpynW(logfont.lfFaceName, name,
 516                   sizeof(logfont.lfFaceName) / sizeof(WCHAR));
 517     else
 518         logfont.lfFaceName[0] = '\0';
 519
 520     return CreateFontIndirectW( &logfont );
 521 }
 522
 523 static void update_font_code_page( DC *dc )
 524 {
 525     CHARSETINFO csi;
 526     int charset = GetTextCharsetInfo( dc->hSelf, NULL, 0 );
 527
 528     /* Hmm, nicely designed api this one! */
 529     if (TranslateCharsetInfo( ULongToPtr(charset), &csi, TCI_SRCCHARSET) )
 530         dc->font_code_page = csi.ciACP;
 531     else {
 532         switch(charset) {
 533         case OEM_CHARSET:
 534             dc->font_code_page = GetOEMCP();
 535             break;
 536         case DEFAULT_CHARSET:
 537             dc->font_code_page = GetACP();
 538             break;
 539
 540         case VISCII_CHARSET:
 541         case TCVN_CHARSET:
 542         case KOI8_CHARSET:
 543         case ISO3_CHARSET:
 544         case ISO4_CHARSET:
 545         case ISO10_CHARSET:
 546         case CELTIC_CHARSET:
 547             /* FIXME: These have no place here, but because x11drv
 548                enumerates fonts with these (made up) charsets some apps
 549                might use them and then the FIXME below would become
 550                annoying.  Now we could pick the intended codepage for
 551                each of these, but since it's broken anyway we'll just
 552                use CP_ACP and hope it'll go away...
 553             */
 554             dc->font_code_page = CP_ACP;
 555             break;
 556
 557         default:
 558             FIXME("Can't find codepage for charset %d\n", charset);
 559             dc->font_code_page = CP_ACP;
 560             break;
 561         }
 562     }
 563
 564     TRACE("charset %d => cp %d\n", charset, dc->font_code_page);
 565 }
 566
 567 /***********************************************************************
 568  *           FONT_SelectObject
 569  */
 570 static HGDIOBJ FONT_SelectObject( HGDIOBJ handle, HDC hdc )
 571 {
 572     HGDIOBJ ret = 0;
 573     DC *dc = get_dc_ptr( hdc );
 574     PHYSDEV physdev;
 575     UINT aa_flags = 0;
 576
 577     if (!dc) return 0;
 578
 579     if (!GDI_inc_ref_count( handle ))
 580     {
 581         release_dc_ptr( dc );
 582         return 0;
 583     }
 584
 585     physdev = GET_DC_PHYSDEV( dc, pSelectFont );
 586     if (physdev->funcs->pSelectFont( physdev, handle, &aa_flags ))
 587     {
 588         ret = dc->hFont;
 589         dc->hFont = handle;
 590         dc->aa_flags = aa_flags ? aa_flags : GGO_BITMAP;
 591         update_font_code_page( dc );
 592         GDI_dec_ref_count( ret );
 593     }
 594     else GDI_dec_ref_count( handle );
 595
 596     release_dc_ptr( dc );
 597     return ret;
 598 }
 599
 600
 601 /***********************************************************************
 602  *           FONT_GetObjectA
 603  */
 604 static INT FONT_GetObjectA( HGDIOBJ handle, INT count, LPVOID buffer )
 605 {
 606     FONTOBJ *font = GDI_GetObjPtr( handle, OBJ_FONT );
 607     LOGFONTA lfA;
 608
 609     if (!font) return 0;
 610     if (buffer)
 611     {
 612         FONT_LogFontWToA( &font->logfont, &lfA );
 613         if (count > sizeof(lfA)) count = sizeof(lfA);
 614         memcpy( buffer, &lfA, count );
 615     }
 616     else count = sizeof(lfA);
 617     GDI_ReleaseObj( handle );
 618     return count;
 619 }
 620
 621 /***********************************************************************
 622  *           FONT_GetObjectW
 623  */
 624 static INT FONT_GetObjectW( HGDIOBJ handle, INT count, LPVOID buffer )
 625 {
 626     FONTOBJ *font = GDI_GetObjPtr( handle, OBJ_FONT );
 627
 628     if (!font) return 0;
 629     if (buffer)
 630     {
 631         if (count > sizeof(LOGFONTW)) count = sizeof(LOGFONTW);
 632         memcpy( buffer, &font->logfont, count );
 633     }
 634     else count = sizeof(LOGFONTW);
 635     GDI_ReleaseObj( handle );
 636     return count;
 637 }
 638
 639
 640 /***********************************************************************
 641  *           FONT_DeleteObject
 642  */
 643 static BOOL FONT_DeleteObject( HGDIOBJ handle )
 644 {
 645     FONTOBJ *obj;
 646
 647     WineEngDestroyFontInstance( handle );
 648
 649     if (!(obj = free_gdi_handle( handle ))) return FALSE;
 650     return HeapFree( GetProcessHeap(), 0, obj );
 651 }
 652
 653
 654 /***********************************************************************
 655  *           nulldrv_SelectFont
 656  */
 657 HFONT nulldrv_SelectFont( PHYSDEV dev, HFONT font, UINT *aa_flags )
 658 {
 659     static const WCHAR desktopW[] = { 'C','o','n','t','r','o','l',' ','P','a','n','e','l','\\',
 660                                       'D','e','s','k','t','o','p',0 };
 661     LOGFONTW lf;
 662     HKEY key;
 663
 664     if (*aa_flags) return 0;
 665
 666     GetObjectW( font, sizeof(lf), &lf );
 667     switch (lf.lfQuality)
 668     {
 669     case NONANTIALIASED_QUALITY:
 670         *aa_flags = GGO_BITMAP;
 671         break;
 672     case ANTIALIASED_QUALITY:
 673         *aa_flags = GGO_GRAY4_BITMAP;
 674         break;
 675     case CLEARTYPE_QUALITY:
 676     case CLEARTYPE_NATURAL_QUALITY:
 677         if (RegOpenKeyW( HKEY_CURRENT_USER, desktopW, &key )) break;
 678         *aa_flags = get_subpixel_orientation( key );
 679         RegCloseKey( key );
 680         break;
 681     default:
 682         if (RegOpenKeyW( HKEY_CURRENT_USER, desktopW, &key )) break;
 683         *aa_flags = get_default_smoothing( key );
 684         RegCloseKey( key );
 685         break;
 686     }
 687     return 0;
 688 }
 689
 690
 691 /***********************************************************************
 692  *              FONT_EnumInstance
 693  *
 694  * Note: plf is really an ENUMLOGFONTEXW, and ptm is a NEWTEXTMETRICEXW.
 695  *       We have to use other types because of the FONTENUMPROCW definition.
 696  */
 697 static INT CALLBACK FONT_EnumInstance( const LOGFONTW *plf, const TEXTMETRICW *ptm,
 698                                        DWORD fType, LPARAM lp )
 699 {
 700     struct font_enum *pfe = (struct font_enum *)lp;
 701     INT ret = 1;
 702
 703     /* lfCharSet is at the same offset in both LOGFONTA and LOGFONTW */
 704     if ((!pfe->lpLogFontParam ||
 705         pfe->lpLogFontParam->lfCharSet == DEFAULT_CHARSET ||
 706         pfe->lpLogFontParam->lfCharSet == plf->lfCharSet) &&
 707        (!(fType & RASTER_FONTTYPE) || GetDeviceCaps(pfe->hdc, TEXTCAPS) & TC_RA_ABLE) )
 708     {
 709         /* convert font metrics */
 710         ENUMLOGFONTEXA logfont;
 711         NEWTEXTMETRICEXA tmA;
 712
 713         if (!pfe->unicode)
 714         {
 715             FONT_EnumLogFontExWToA( (const ENUMLOGFONTEXW *)plf, &logfont);
 716             FONT_NewTextMetricExWToA( (const NEWTEXTMETRICEXW *)ptm, &tmA );
 717             plf = (LOGFONTW *)&logfont.elfLogFont;
 718             ptm = (TEXTMETRICW *)&tmA;
 719         }
 720         ret = pfe->lpEnumFunc( plf, ptm, fType, pfe->lpData );
 721         pfe->retval = ret;
 722     }
 723     return ret;
 724 }
 725
 726 /***********************************************************************
 727  *              FONT_EnumFontFamiliesEx
 728  */
 729 static INT FONT_EnumFontFamiliesEx( HDC hDC, LPLOGFONTW plf, FONTENUMPROCW efproc,
 730                                     LPARAM lParam, BOOL unicode )
 731 {
 732     INT ret = 0;
 733     DC *dc = get_dc_ptr( hDC );
 734     struct font_enum fe;
 735
 736     if (dc)
 737     {
 738         PHYSDEV physdev = GET_DC_PHYSDEV( dc, pEnumFonts );
 739
 740         if (plf) TRACE("lfFaceName = %s lfCharset = %d\n", debugstr_w(plf->lfFaceName), plf->lfCharSet);
 741         fe.lpLogFontParam = plf;
 742         fe.lpEnumFunc = efproc;
 743         fe.lpData = lParam;
 744         fe.unicode = unicode;
 745         fe.hdc = hDC;
 746         fe.retval = 1;
 747         ret = physdev->funcs->pEnumFonts( physdev, plf, FONT_EnumInstance, (LPARAM)&fe );
 748         release_dc_ptr( dc );
 749     }
 750     return ret ? fe.retval : 0;
 751 }
 752
 753 /***********************************************************************
 754  *              EnumFontFamiliesExW     (GDI32.@)
 755  */
 756 INT WINAPI EnumFontFamiliesExW( HDC hDC, LPLOGFONTW plf,
 757                                     FONTENUMPROCW efproc,
 758                                     LPARAM lParam, DWORD dwFlags )
 759 {
 760     return FONT_EnumFontFamiliesEx( hDC, plf, efproc, lParam, TRUE );
 761 }
 762
 763 /***********************************************************************
 764  *              EnumFontFamiliesExA     (GDI32.@)
 765  */
 766 INT WINAPI EnumFontFamiliesExA( HDC hDC, LPLOGFONTA plf,
 767                                     FONTENUMPROCA efproc,
 768                                     LPARAM lParam, DWORD dwFlags)
 769 {
 770     LOGFONTW lfW, *plfW;
 771
 772     if (plf)
 773     {
 774         FONT_LogFontAToW( plf, &lfW );
 775         plfW = &lfW;
 776     }
 777     else plfW = NULL;
 778
 779     return FONT_EnumFontFamiliesEx( hDC, plfW, (FONTENUMPROCW)efproc, lParam, FALSE );
 780 }
 781
 782 /***********************************************************************
 783  *              EnumFontFamiliesA       (GDI32.@)
 784  */
 785 INT WINAPI EnumFontFamiliesA( HDC hDC, LPCSTR lpFamily,
 786                                   FONTENUMPROCA efproc, LPARAM lpData )
 787 {
 788     LOGFONTA lf, *plf;
 789
 790     if (lpFamily)
 791     {
 792         if (!*lpFamily) return 1;
 793         lstrcpynA( lf.lfFaceName, lpFamily, LF_FACESIZE );
 794         lf.lfCharSet = DEFAULT_CHARSET;
 795         lf.lfPitchAndFamily = 0;
 796         plf = &lf;
 797     }
 798     else plf = NULL;
 799
 800     return EnumFontFamiliesExA( hDC, plf, efproc, lpData, 0 );
 801 }
 802
 803 /***********************************************************************
 804  *              EnumFontFamiliesW       (GDI32.@)
 805  */
 806 INT WINAPI EnumFontFamiliesW( HDC hDC, LPCWSTR lpFamily,
 807                                   FONTENUMPROCW efproc, LPARAM lpData )
 808 {
 809     LOGFONTW lf, *plf;
 810
 811     if (lpFamily)
 812     {
 813         if (!*lpFamily) return 1;
 814         lstrcpynW( lf.lfFaceName, lpFamily, LF_FACESIZE );
 815         lf.lfCharSet = DEFAULT_CHARSET;
 816         lf.lfPitchAndFamily = 0;
 817         plf = &lf;
 818     }
 819     else plf = NULL;
 820
 821     return EnumFontFamiliesExW( hDC, plf, efproc, lpData, 0 );
 822 }
 823
 824 /***********************************************************************
 825  *              EnumFontsA              (GDI32.@)
 826  */
 827 INT WINAPI EnumFontsA( HDC hDC, LPCSTR lpName, FONTENUMPROCA efproc,
 828                            LPARAM lpData )
 829 {
 830     return EnumFontFamiliesA( hDC, lpName, efproc, lpData );
 831 }
 832
 833 /***********************************************************************
 834  *              EnumFontsW              (GDI32.@)
 835  */
 836 INT WINAPI EnumFontsW( HDC hDC, LPCWSTR lpName, FONTENUMPROCW efproc,
 837                            LPARAM lpData )
 838 {
 839     return EnumFontFamiliesW( hDC, lpName, efproc, lpData );
 840 }
 841
 842
 843 /***********************************************************************
 844  *           GetTextCharacterExtra    (GDI32.@)
 845  */
 846 INT WINAPI GetTextCharacterExtra( HDC hdc )
 847 {
 848     INT ret;
 849     DC *dc = get_dc_ptr( hdc );
 850     if (!dc) return 0x80000000;
 851     ret = dc->charExtra;
 852     release_dc_ptr( dc );
 853     return ret;
 854 }
 855
 856
 857 /***********************************************************************
 858  *           SetTextCharacterExtra    (GDI32.@)
 859  */
 860 INT WINAPI SetTextCharacterExtra( HDC hdc, INT extra )
 861 {
 862     INT ret = 0x80000000;
 863     DC * dc = get_dc_ptr( hdc );
 864
 865     if (dc)
 866     {
 867         PHYSDEV physdev = GET_DC_PHYSDEV( dc, pSetTextCharacterExtra );
 868         extra = physdev->funcs->pSetTextCharacterExtra( physdev, extra );
 869         if (extra != 0x80000000)
 870         {
 871             ret = dc->charExtra;
 872             dc->charExtra = extra;
 873         }
 874         release_dc_ptr( dc );
 875     }
 876     return ret;
 877 }
 878
 879
 880 /***********************************************************************
 881  *           SetTextJustification    (GDI32.@)
 882  */
 883 BOOL WINAPI SetTextJustification( HDC hdc, INT extra, INT breaks )
 884 {
 885     BOOL ret;
 886     PHYSDEV physdev;
 887     DC * dc = get_dc_ptr( hdc );
 888
 889     if (!dc) return FALSE;
 890
 891     physdev = GET_DC_PHYSDEV( dc, pSetTextJustification );
 892     ret = physdev->funcs->pSetTextJustification( physdev, extra, breaks );
 893     if (ret)
 894     {
 895         extra = abs((extra * dc->vportExtX + dc->wndExtX / 2) / dc->wndExtX);
 896         if (!extra) breaks = 0;
 897         if (breaks)
 898         {
 899             dc->breakExtra = extra / breaks;
 900             dc->breakRem   = extra - (breaks * dc->breakExtra);
 901         }
 902         else
 903         {
 904             dc->breakExtra = 0;
 905             dc->breakRem   = 0;
 906         }
 907     }
 908     release_dc_ptr( dc );
 909     return ret;
 910 }
 911
 912
 913 /***********************************************************************
 914  *           GetTextFaceA    (GDI32.@)
 915  */
 916 INT WINAPI GetTextFaceA( HDC hdc, INT count, LPSTR name )
 917 {
 918     INT res = GetTextFaceW(hdc, 0, NULL);
 919     LPWSTR nameW = HeapAlloc( GetProcessHeap(), 0, res * 2 );
 920     GetTextFaceW( hdc, res, nameW );
 921
 922     if (name)
 923     {
 924         if (count)
 925         {
 926             res = WideCharToMultiByte(CP_ACP, 0, nameW, -1, name, count, NULL, NULL);
 927             if (res == 0)
 928                 res = count;
 929             name[count-1] = 0;
 930             /* GetTextFaceA does NOT include the nul byte in the return count.  */
 931             res--;
 932         }
 933         else
 934             res = 0;
 935     }
 936     else
 937         res = WideCharToMultiByte( CP_ACP, 0, nameW, -1, NULL, 0, NULL, NULL);
 938     HeapFree( GetProcessHeap(), 0, nameW );
 939     return res;
 940 }
 941
 942 /***********************************************************************
 943  *           GetTextFaceW    (GDI32.@)
 944  */
 945 INT WINAPI GetTextFaceW( HDC hdc, INT count, LPWSTR name )
 946 {
 947     PHYSDEV dev;
 948     INT ret;
 949
 950     DC * dc = get_dc_ptr( hdc );
 951     if (!dc) return 0;
 952
 953     dev = GET_DC_PHYSDEV( dc, pGetTextFace );
 954     ret = dev->funcs->pGetTextFace( dev, count, name );
 955     release_dc_ptr( dc );
 956     return ret;
 957 }
 958
 959
 960 /***********************************************************************
 961  *           GetTextExtentPoint32A    (GDI32.@)
 962  *
 963  * See GetTextExtentPoint32W.
 964  */
 965 BOOL WINAPI GetTextExtentPoint32A( HDC hdc, LPCSTR str, INT count,
 966                                      LPSIZE size )
 967 {
 968     BOOL ret = FALSE;
 969     INT wlen;
 970     LPWSTR p;
 971
 972     if (count < 0) return FALSE;
 973
 974     p = FONT_mbtowc(hdc, str, count, &wlen, NULL);
 975
 976     if (p)
 977     {
 978         ret = GetTextExtentPoint32W( hdc, p, wlen, size );
 979         HeapFree( GetProcessHeap(), 0, p );
 980     }
 981
 982     TRACE("(%p %s %d %p): returning %d x %d\n",
 983           hdc, debugstr_an (str, count), count, size, size->cx, size->cy );
 984     return ret;
 985 }
 986
 987
 988 /***********************************************************************
 989  * GetTextExtentPoint32W [GDI32.@]
 990  *
 991  * Computes width/height for a string.
 992  *
 993  * Computes width and height of the specified string.
 994  *
 995  * RETURNS
 996  *    Success: TRUE
 997  *    Failure: FALSE
 998  */
 999 BOOL WINAPI GetTextExtentPoint32W(
1000     HDC hdc,     /* [in]  Handle of device context */
1001     LPCWSTR str,   /* [in]  Address of text string */
1002     INT count,   /* [in]  Number of characters in string */
1003     LPSIZE size) /* [out] Address of structure for string size */
1004 {
1005     return GetTextExtentExPointW(hdc, str, count, 0, NULL, NULL, size);
1006 }
1007
1008 /***********************************************************************
1009  * GetTextExtentExPointI [GDI32.@]
1010  *
1011  * Computes width and height of the array of glyph indices.
1012  *
1013  * PARAMS
1014  *    hdc     [I] Handle of device context.
1015  *    indices [I] Glyph index array.
1016  *    count   [I] Number of glyphs in array.
1017  *    max_ext [I] Maximum width in glyphs.
1018  *    nfit    [O] Maximum number of characters.
1019  *    dxs     [O] Partial string widths.
1020  *    size    [O] Returned string size.
1021  *
1022  * RETURNS
1023  *    Success: TRUE
1024  *    Failure: FALSE
1025  */
1026 BOOL WINAPI GetTextExtentExPointI( HDC hdc, const WORD *indices, INT count, INT max_ext,
1027                                    LPINT nfit, LPINT dxs, LPSIZE size )
1028 {
1029     PHYSDEV dev;
1030     BOOL ret;
1031     DC *dc;
1032
1033     if (count < 0) return FALSE;
1034
1035     dc = get_dc_ptr( hdc );
1036     if (!dc) return FALSE;
1037
1038     dev = GET_DC_PHYSDEV( dc, pGetTextExtentExPointI );
1039     ret = dev->funcs->pGetTextExtentExPointI( dev, indices, count, max_ext, nfit, dxs, size );
1040     size->cx = abs(INTERNAL_XDSTOWS(dc, size->cx));
1041     size->cy = abs(INTERNAL_YDSTOWS(dc, size->cy));
1042     size->cx += count * dc->charExtra;
1043     release_dc_ptr( dc );
1044
1045     TRACE("(%p %p %d %p): returning %d x %d\n",
1046           hdc, indices, count, size, size->cx, size->cy );
1047     return ret;
1048 }
1049
1050 /***********************************************************************
1051  * GetTextExtentPointI [GDI32.@]
1052  *
1053  * Computes width and height of the array of glyph indices.
1054  *
1055  * PARAMS
1056  *    hdc     [I] Handle of device context.
1057  *    indices [I] Glyph index array.
1058  *    count   [I] Number of glyphs in array.
1059  *    size    [O] Returned string size.
1060  *
1061  * RETURNS
1062  *    Success: TRUE
1063  *    Failure: FALSE
1064  */
1065 BOOL WINAPI GetTextExtentPointI( HDC hdc, const WORD *indices, INT count, LPSIZE size )
1066 {
1067     return GetTextExtentExPointI( hdc, indices, count, 0, NULL, NULL, size );
1068 }
1069
1070
1071 /***********************************************************************
1072  *           GetTextExtentPointA    (GDI32.@)
1073  */
1074 BOOL WINAPI GetTextExtentPointA( HDC hdc, LPCSTR str, INT count,
1075                                           LPSIZE size )
1076 {
1077     TRACE("not bug compatible.\n");
1078     return GetTextExtentPoint32A( hdc, str, count, size );
1079 }
1080
1081 /***********************************************************************
1082  *           GetTextExtentPointW   (GDI32.@)
1083  */
1084 BOOL WINAPI GetTextExtentPointW( HDC hdc, LPCWSTR str, INT count,
1085                                           LPSIZE size )
1086 {
1087     TRACE("not bug compatible.\n");
1088     return GetTextExtentPoint32W( hdc, str, count, size );
1089 }
1090
1091
1092 /***********************************************************************
1093  *           GetTextExtentExPointA    (GDI32.@)
1094  */
1095 BOOL WINAPI GetTextExtentExPointA( HDC hdc, LPCSTR str, INT count,
1096                                    INT maxExt, LPINT lpnFit,
1097                                    LPINT alpDx, LPSIZE size )
1098 {
1099     BOOL ret;
1100     INT wlen;
1101     INT *walpDx = NULL;
1102     LPWSTR p = NULL;
1103
1104     if (count < 0) return FALSE;
1105
1106     if (alpDx)
1107     {
1108         walpDx = HeapAlloc( GetProcessHeap(), 0, count * sizeof(INT) );
1109         if (!walpDx) return FALSE;
1110     }
1111
1112     p = FONT_mbtowc(hdc, str, count, &wlen, NULL);
1113     ret = GetTextExtentExPointW( hdc, p, wlen, maxExt, lpnFit, walpDx, size);
1114     if (walpDx)
1115     {
1116         INT n = lpnFit ? *lpnFit : wlen;
1117         INT i, j;
1118         for(i = 0, j = 0; i < n; i++, j++)
1119         {
1120             alpDx[j] = walpDx[i];
1121             if (IsDBCSLeadByte(str[j])) alpDx[++j] = walpDx[i];
1122         }
1123     }
1124     if (lpnFit) *lpnFit = WideCharToMultiByte(CP_ACP,0,p,*lpnFit,NULL,0,NULL,NULL);
1125     HeapFree( GetProcessHeap(), 0, p );
1126     HeapFree( GetProcessHeap(), 0, walpDx );
1127     return ret;
1128 }
1129
1130
1131 /***********************************************************************
1132  *           GetTextExtentExPointW    (GDI32.@)
1133  *
1134  * Return the size of the string as it would be if it was output properly by
1135  * e.g. TextOut.
1136  *
1137  * This should include
1138  * - Intercharacter spacing
1139  * - justification spacing (not yet done)
1140  * - kerning? see below
1141  *
1142  * Kerning.  Since kerning would be carried out by the rendering code it should
1143  * be done by the driver.  However they don't support it yet.  Also I am not
1144  * yet persuaded that (certainly under Win95) any kerning is actually done.
1145  *
1146  * str: According to MSDN this should be null-terminated.  That is not true; a
1147  *      null will not terminate it early.
1148  * size: Certainly under Win95 this appears buggy or weird if *lpnFit is less
1149  *       than count.  I have seen it be either the size of the full string or
1150  *       1 less than the size of the full string.  I have not seen it bear any
1151  *       resemblance to the portion that would fit.
1152  * lpnFit: What exactly is fitting?  Stupidly, in my opinion, it includes the
1153  *         trailing intercharacter spacing and any trailing justification.
1154  *
1155  * FIXME
1156  * Currently we do this by measuring each character etc.  We should do it by
1157  * passing the request to the driver, perhaps by extending the
1158  * pGetTextExtentPoint function to take the alpDx argument.  That would avoid
1159  * thinking about kerning issues and rounding issues in the justification.
1160  */
1161
1162 BOOL WINAPI GetTextExtentExPointW( HDC hdc, LPCWSTR str, INT count,
1163                                    INT maxExt, LPINT lpnFit,
1164                                    LPINT alpDx, LPSIZE size )
1165 {
1166     INT nFit = 0;
1167     LPINT dxs = NULL;
1168     DC *dc;
1169     BOOL ret = FALSE;
1170     TEXTMETRICW tm;
1171     PHYSDEV dev;
1172
1173     TRACE("(%p, %s, %d)\n",hdc,debugstr_wn(str,count),maxExt);
1174
1175     if (count < 0) return FALSE;
1176
1177     dc = get_dc_ptr(hdc);
1178     if (!dc) return FALSE;
1179
1180     GetTextMetricsW(hdc, &tm);
1181
1182     /* If we need to calculate nFit, then we need the partial extents even if
1183        the user hasn't provided us with an array.  */
1184     if (lpnFit)
1185     {
1186         dxs = alpDx ? alpDx : HeapAlloc(GetProcessHeap(), 0, count * sizeof alpDx[0]);
1187         if (! dxs)
1188         {
1189             release_dc_ptr(dc);
1190             SetLastError(ERROR_OUTOFMEMORY);
1191             return FALSE;
1192         }
1193     }
1194     else
1195         dxs = alpDx;
1196
1197     dev = GET_DC_PHYSDEV( dc, pGetTextExtentExPoint );
1198     ret = dev->funcs->pGetTextExtentExPoint(dev, str, count, 0, NULL, dxs, size);
1199
1200     /* Perform device size to world size transformations.  */
1201     if (ret)
1202     {
1203         INT extra      = dc->charExtra,
1204         breakExtra = dc->breakExtra,
1205         breakRem   = dc->breakRem,
1206         i;
1207
1208         if (dxs)
1209         {
1210             for (i = 0; i < count; ++i)
1211             {
1212                 dxs[i] = abs(INTERNAL_XDSTOWS(dc, dxs[i]));
1213                 dxs[i] += (i+1) * extra;
1214                 if (count > 1 && (breakExtra || breakRem) && str[i] == tm.tmBreakChar)
1215                 {
1216                     dxs[i] += breakExtra;
1217                     if (breakRem > 0)
1218                     {
1219                         breakRem--;
1220                         dxs[i]++;
1221                     }
1222                 }
1223                 if (dxs[i] <= maxExt)
1224                     ++nFit;
1225             }
1226             breakRem = dc->breakRem;
1227         }
1228         size->cx = abs(INTERNAL_XDSTOWS(dc, size->cx));
1229         size->cy = abs(INTERNAL_YDSTOWS(dc, size->cy));
1230
1231         if (!dxs && count > 1 && (breakExtra || breakRem))
1232         {
1233             for (i = 0; i < count; i++)
1234             {
1235                 if (str[i] == tm.tmBreakChar)
1236                 {
1237                     size->cx += breakExtra;
1238                     if (breakRem > 0)
1239                     {
1240                         breakRem--;
1241                         (size->cx)++;
1242                     }
1243                 }
1244             }
1245         }
1246     }
1247
1248     if (lpnFit)
1249         *lpnFit = nFit;
1250
1251     if (! alpDx)
1252         HeapFree(GetProcessHeap(), 0, dxs);
1253
1254     release_dc_ptr( dc );
1255
1256     TRACE("returning %d %d x %d\n",nFit,size->cx,size->cy);
1257     return ret;
1258 }
1259
1260 /***********************************************************************
1261  *           GetTextMetricsA    (GDI32.@)
1262  */
1263 BOOL WINAPI GetTextMetricsA( HDC hdc, TEXTMETRICA *metrics )
1264 {
1265     TEXTMETRICW tm32;
1266
1267     if (!GetTextMetricsW( hdc, &tm32 )) return FALSE;
1268     FONT_TextMetricWToA( &tm32, metrics );
1269     return TRUE;
1270 }
1271
1272 /***********************************************************************
1273  *           GetTextMetricsW    (GDI32.@)
1274  */
1275 BOOL WINAPI GetTextMetricsW( HDC hdc, TEXTMETRICW *metrics )
1276 {
1277     PHYSDEV physdev;
1278     BOOL ret = FALSE;
1279     DC * dc = get_dc_ptr( hdc );
1280     if (!dc) return FALSE;
1281
1282     physdev = GET_DC_PHYSDEV( dc, pGetTextMetrics );
1283     ret = physdev->funcs->pGetTextMetrics( physdev, metrics );
1284
1285     if (ret)
1286     {
1287     /* device layer returns values in device units
1288      * therefore we have to convert them to logical */
1289
1290         metrics->tmDigitizedAspectX = GetDeviceCaps(hdc, LOGPIXELSX);
1291         metrics->tmDigitizedAspectY = GetDeviceCaps(hdc, LOGPIXELSY);
1292
1293 #define WDPTOLP(x) ((x<0)?                                      \
1294                 (-abs(INTERNAL_XDSTOWS(dc, (x)))):              \
1295                 (abs(INTERNAL_XDSTOWS(dc, (x)))))
1296 #define HDPTOLP(y) ((y<0)?                                      \
1297                 (-abs(INTERNAL_YDSTOWS(dc, (y)))):              \
1298                 (abs(INTERNAL_YDSTOWS(dc, (y)))))
1299
1300         metrics->tmHeight           = HDPTOLP(metrics->tmHeight);
1301         metrics->tmAscent           = HDPTOLP(metrics->tmAscent);
1302         metrics->tmDescent          = HDPTOLP(metrics->tmDescent);
1303         metrics->tmInternalLeading  = HDPTOLP(metrics->tmInternalLeading);
1304         metrics->tmExternalLeading  = HDPTOLP(metrics->tmExternalLeading);
1305         metrics->tmAveCharWidth     = WDPTOLP(metrics->tmAveCharWidth);
1306         metrics->tmMaxCharWidth     = WDPTOLP(metrics->tmMaxCharWidth);
1307         metrics->tmOverhang         = WDPTOLP(metrics->tmOverhang);
1308         ret = TRUE;
1309 #undef WDPTOLP
1310 #undef HDPTOLP
1311     TRACE("text metrics:\n"
1312           "    Weight = %03i\t FirstChar = %i\t AveCharWidth = %i\n"
1313           "    Italic = % 3i\t LastChar = %i\t\t MaxCharWidth = %i\n"
1314           "    UnderLined = %01i\t DefaultChar = %i\t Overhang = %i\n"
1315           "    StruckOut = %01i\t BreakChar = %i\t CharSet = %i\n"
1316           "    PitchAndFamily = %02x\n"
1317           "    --------------------\n"
1318           "    InternalLeading = %i\n"
1319           "    Ascent = %i\n"
1320           "    Descent = %i\n"
1321           "    Height = %i\n",
1322           metrics->tmWeight, metrics->tmFirstChar, metrics->tmAveCharWidth,
1323           metrics->tmItalic, metrics->tmLastChar, metrics->tmMaxCharWidth,
1324           metrics->tmUnderlined, metrics->tmDefaultChar, metrics->tmOverhang,
1325           metrics->tmStruckOut, metrics->tmBreakChar, metrics->tmCharSet,
1326           metrics->tmPitchAndFamily,
1327           metrics->tmInternalLeading,
1328           metrics->tmAscent,
1329           metrics->tmDescent,
1330           metrics->tmHeight );
1331     }
1332     release_dc_ptr( dc );
1333     return ret;
1334 }
1335
1336
1337 /***********************************************************************
1338  *              GetOutlineTextMetricsA (GDI32.@)
1339  * Gets metrics for TrueType fonts.
1340  *
1341  * NOTES
1342  *    If the supplied buffer isn't big enough Windows partially fills it up to
1343  *    its given length and returns that length.
1344  *
1345  * RETURNS
1346  *    Success: Non-zero or size of required buffer
1347  *    Failure: 0
1348  */
1349 UINT WINAPI GetOutlineTextMetricsA(
1350     HDC hdc,    /* [in]  Handle of device context */
1351     UINT cbData, /* [in]  Size of metric data array */
1352     LPOUTLINETEXTMETRICA lpOTM)  /* [out] Address of metric data array */
1353 {
1354     char buf[512], *ptr;
1355     UINT ret, needed;
1356     OUTLINETEXTMETRICW *lpOTMW = (OUTLINETEXTMETRICW *)buf;
1357     OUTLINETEXTMETRICA *output = lpOTM;
1358     INT left, len;
1359
1360     if((ret = GetOutlineTextMetricsW(hdc, 0, NULL)) == 0)
1361         return 0;
1362     if(ret > sizeof(buf))
1363         lpOTMW = HeapAlloc(GetProcessHeap(), 0, ret);
1364     GetOutlineTextMetricsW(hdc, ret, lpOTMW);
1365
1366     needed = sizeof(OUTLINETEXTMETRICA);
1367     if(lpOTMW->otmpFamilyName)
1368         needed += WideCharToMultiByte(CP_ACP, 0,
1369            (WCHAR*)((char*)lpOTMW + (ptrdiff_t)lpOTMW->otmpFamilyName), -1,
1370                                       NULL, 0, NULL, NULL);
1371     if(lpOTMW->otmpFaceName)
1372         needed += WideCharToMultiByte(CP_ACP, 0,
1373            (WCHAR*)((char*)lpOTMW + (ptrdiff_t)lpOTMW->otmpFaceName), -1,
1374                                       NULL, 0, NULL, NULL);
1375     if(lpOTMW->otmpStyleName)
1376         needed += WideCharToMultiByte(CP_ACP, 0,
1377            (WCHAR*)((char*)lpOTMW + (ptrdiff_t)lpOTMW->otmpStyleName), -1,
1378                                       NULL, 0, NULL, NULL);
1379     if(lpOTMW->otmpFullName)
1380         needed += WideCharToMultiByte(CP_ACP, 0,
1381            (WCHAR*)((char*)lpOTMW + (ptrdiff_t)lpOTMW->otmpFullName), -1,
1382                                       NULL, 0, NULL, NULL);
1383
1384     if(!lpOTM) {
1385         ret = needed;
1386         goto end;
1387     }
1388
1389     TRACE("needed = %d\n", needed);
1390     if(needed > cbData)
1391         /* Since the supplied buffer isn't big enough, we'll alloc one
1392            that is and memcpy the first cbData bytes into the lpOTM at
1393            the end. */
1394         output = HeapAlloc(GetProcessHeap(), 0, needed);
1395
1396     ret = output->otmSize = min(needed, cbData);
1397     FONT_TextMetricWToA( &lpOTMW->otmTextMetrics, &output->otmTextMetrics );
1398     output->otmFiller = 0;
1399     output->otmPanoseNumber = lpOTMW->otmPanoseNumber;
1400     output->otmfsSelection = lpOTMW->otmfsSelection;
1401     output->otmfsType = lpOTMW->otmfsType;
1402     output->otmsCharSlopeRise = lpOTMW->otmsCharSlopeRise;
1403     output->otmsCharSlopeRun = lpOTMW->otmsCharSlopeRun;
1404     output->otmItalicAngle = lpOTMW->otmItalicAngle;
1405     output->otmEMSquare = lpOTMW->otmEMSquare;
1406     output->otmAscent = lpOTMW->otmAscent;
1407     output->otmDescent = lpOTMW->otmDescent;
1408     output->otmLineGap = lpOTMW->otmLineGap;
1409     output->otmsCapEmHeight = lpOTMW->otmsCapEmHeight;
1410     output->otmsXHeight = lpOTMW->otmsXHeight;
1411     output->otmrcFontBox = lpOTMW->otmrcFontBox;
1412     output->otmMacAscent = lpOTMW->otmMacAscent;
1413     output->otmMacDescent = lpOTMW->otmMacDescent;
1414     output->otmMacLineGap = lpOTMW->otmMacLineGap;
1415     output->otmusMinimumPPEM = lpOTMW->otmusMinimumPPEM;
1416     output->otmptSubscriptSize = lpOTMW->otmptSubscriptSize;
1417     output->otmptSubscriptOffset = lpOTMW->otmptSubscriptOffset;
1418     output->otmptSuperscriptSize = lpOTMW->otmptSuperscriptSize;
1419     output->otmptSuperscriptOffset = lpOTMW->otmptSuperscriptOffset;
1420     output->otmsStrikeoutSize = lpOTMW->otmsStrikeoutSize;
1421     output->otmsStrikeoutPosition = lpOTMW->otmsStrikeoutPosition;
1422     output->otmsUnderscoreSize = lpOTMW->otmsUnderscoreSize;
1423     output->otmsUnderscorePosition = lpOTMW->otmsUnderscorePosition;
1424
1425
1426     ptr = (char*)(output + 1);
1427     left = needed - sizeof(*output);
1428
1429     if(lpOTMW->otmpFamilyName) {
1430         output->otmpFamilyName = (LPSTR)(ptr - (char*)output);
1431         len = WideCharToMultiByte(CP_ACP, 0,
1432              (WCHAR*)((char*)lpOTMW + (ptrdiff_t)lpOTMW->otmpFamilyName), -1,
1433                                   ptr, left, NULL, NULL);
1434         left -= len;
1435         ptr += len;
1436     } else
1437         output->otmpFamilyName = 0;
1438
1439     if(lpOTMW->otmpFaceName) {
1440         output->otmpFaceName = (LPSTR)(ptr - (char*)output);
1441         len = WideCharToMultiByte(CP_ACP, 0,
1442              (WCHAR*)((char*)lpOTMW + (ptrdiff_t)lpOTMW->otmpFaceName), -1,
1443                                   ptr, left, NULL, NULL);
1444         left -= len;
1445         ptr += len;
1446     } else
1447         output->otmpFaceName = 0;
1448
1449     if(lpOTMW->otmpStyleName) {
1450         output->otmpStyleName = (LPSTR)(ptr - (char*)output);
1451         len = WideCharToMultiByte(CP_ACP, 0,
1452              (WCHAR*)((char*)lpOTMW + (ptrdiff_t)lpOTMW->otmpStyleName), -1,
1453                                   ptr, left, NULL, NULL);
1454         left -= len;
1455         ptr += len;
1456     } else
1457         output->otmpStyleName = 0;
1458
1459     if(lpOTMW->otmpFullName) {
1460         output->otmpFullName = (LPSTR)(ptr - (char*)output);
1461         len = WideCharToMultiByte(CP_ACP, 0,
1462              (WCHAR*)((char*)lpOTMW + (ptrdiff_t)lpOTMW->otmpFullName), -1,
1463                                   ptr, left, NULL, NULL);
1464         left -= len;
1465     } else
1466         output->otmpFullName = 0;
1467
1468     assert(left == 0);
1469
1470     if(output != lpOTM) {
1471         memcpy(lpOTM, output, cbData);
1472         HeapFree(GetProcessHeap(), 0, output);
1473
1474         /* check if the string offsets really fit into the provided size */
1475         /* FIXME: should we check string length as well? */
1476         /* make sure that we don't read/write beyond the provided buffer */
1477         if (lpOTM->otmSize >= FIELD_OFFSET(OUTLINETEXTMETRICA, otmpFamilyName) + sizeof(LPSTR))
1478         {
1479             if ((UINT_PTR)lpOTM->otmpFamilyName >= lpOTM->otmSize)
1480                 lpOTM->otmpFamilyName = 0; /* doesn't fit */
1481         }
1482
1483         /* make sure that we don't read/write beyond the provided buffer */
1484         if (lpOTM->otmSize >= FIELD_OFFSET(OUTLINETEXTMETRICA, otmpFaceName) + sizeof(LPSTR))
1485         {
1486             if ((UINT_PTR)lpOTM->otmpFaceName >= lpOTM->otmSize)
1487                 lpOTM->otmpFaceName = 0; /* doesn't fit */
1488         }
1489
1490             /* make sure that we don't read/write beyond the provided buffer */
1491         if (lpOTM->otmSize >= FIELD_OFFSET(OUTLINETEXTMETRICA, otmpStyleName) + sizeof(LPSTR))
1492         {
1493             if ((UINT_PTR)lpOTM->otmpStyleName >= lpOTM->otmSize)
1494                 lpOTM->otmpStyleName = 0; /* doesn't fit */
1495         }
1496
1497         /* make sure that we don't read/write beyond the provided buffer */
1498         if (lpOTM->otmSize >= FIELD_OFFSET(OUTLINETEXTMETRICA, otmpFullName) + sizeof(LPSTR))
1499         {
1500             if ((UINT_PTR)lpOTM->otmpFullName >= lpOTM->otmSize)
1501                 lpOTM->otmpFullName = 0; /* doesn't fit */
1502         }
1503     }
1504
1505 end:
1506     if(lpOTMW != (OUTLINETEXTMETRICW *)buf)
1507         HeapFree(GetProcessHeap(), 0, lpOTMW);
1508
1509     return ret;
1510 }
1511
1512
1513 /***********************************************************************
1514  *           GetOutlineTextMetricsW [GDI32.@]
1515  */
1516 UINT WINAPI GetOutlineTextMetricsW(
1517     HDC hdc,    /* [in]  Handle of device context */
1518     UINT cbData, /* [in]  Size of metric data array */
1519     LPOUTLINETEXTMETRICW lpOTM)  /* [out] Address of metric data array */
1520 {
1521     DC *dc = get_dc_ptr( hdc );
1522     OUTLINETEXTMETRICW *output = lpOTM;
1523     PHYSDEV dev;
1524     UINT ret;
1525
1526     TRACE("(%p,%d,%p)\n", hdc, cbData, lpOTM);
1527     if(!dc) return 0;
1528
1529     dev = GET_DC_PHYSDEV( dc, pGetOutlineTextMetrics );
1530     ret = dev->funcs->pGetOutlineTextMetrics( dev, cbData, output );
1531
1532     if (lpOTM && ret > cbData)
1533     {
1534         output = HeapAlloc(GetProcessHeap(), 0, ret);
1535         ret = dev->funcs->pGetOutlineTextMetrics( dev, ret, output );
1536     }
1537
1538     if (lpOTM && ret)
1539     {
1540         output->otmTextMetrics.tmDigitizedAspectX = GetDeviceCaps(hdc, LOGPIXELSX);
1541         output->otmTextMetrics.tmDigitizedAspectY = GetDeviceCaps(hdc, LOGPIXELSY);
1542
1543 #define WDPTOLP(x) ((x<0)?                                      \
1544                 (-abs(INTERNAL_XDSTOWS(dc, (x)))):              \
1545                 (abs(INTERNAL_XDSTOWS(dc, (x)))))
1546 #define HDPTOLP(y) ((y<0)?                                      \
1547                 (-abs(INTERNAL_YDSTOWS(dc, (y)))):              \
1548                 (abs(INTERNAL_YDSTOWS(dc, (y)))))
1549
1550         output->otmTextMetrics.tmHeight           = HDPTOLP(output->otmTextMetrics.tmHeight);
1551         output->otmTextMetrics.tmAscent           = HDPTOLP(output->otmTextMetrics.tmAscent);
1552         output->otmTextMetrics.tmDescent          = HDPTOLP(output->otmTextMetrics.tmDescent);
1553         output->otmTextMetrics.tmInternalLeading  = HDPTOLP(output->otmTextMetrics.tmInternalLeading);
1554         output->otmTextMetrics.tmExternalLeading  = HDPTOLP(output->otmTextMetrics.tmExternalLeading);
1555         output->otmTextMetrics.tmAveCharWidth     = WDPTOLP(output->otmTextMetrics.tmAveCharWidth);
1556         output->otmTextMetrics.tmMaxCharWidth     = WDPTOLP(output->otmTextMetrics.tmMaxCharWidth);
1557         output->otmTextMetrics.tmOverhang         = WDPTOLP(output->otmTextMetrics.tmOverhang);
1558         output->otmAscent = HDPTOLP(output->otmAscent);
1559         output->otmDescent = HDPTOLP(output->otmDescent);
1560         output->otmLineGap = abs(INTERNAL_YDSTOWS(dc,output->otmLineGap));
1561         output->otmsCapEmHeight = abs(INTERNAL_YDSTOWS(dc,output->otmsCapEmHeight));
1562         output->otmsXHeight = abs(INTERNAL_YDSTOWS(dc,output->otmsXHeight));
1563         output->otmrcFontBox.top = HDPTOLP(output->otmrcFontBox.top);
1564         output->otmrcFontBox.bottom = HDPTOLP(output->otmrcFontBox.bottom);
1565         output->otmrcFontBox.left = WDPTOLP(output->otmrcFontBox.left);
1566         output->otmrcFontBox.right = WDPTOLP(output->otmrcFontBox.right);
1567         output->otmMacAscent = HDPTOLP(output->otmMacAscent);
1568         output->otmMacDescent = HDPTOLP(output->otmMacDescent);
1569         output->otmMacLineGap = abs(INTERNAL_YDSTOWS(dc,output->otmMacLineGap));
1570         output->otmptSubscriptSize.x = WDPTOLP(output->otmptSubscriptSize.x);
1571         output->otmptSubscriptSize.y = HDPTOLP(output->otmptSubscriptSize.y);
1572         output->otmptSubscriptOffset.x = WDPTOLP(output->otmptSubscriptOffset.x);
1573         output->otmptSubscriptOffset.y = HDPTOLP(output->otmptSubscriptOffset.y);
1574         output->otmptSuperscriptSize.x = WDPTOLP(output->otmptSuperscriptSize.x);
1575         output->otmptSuperscriptSize.y = HDPTOLP(output->otmptSuperscriptSize.y);
1576         output->otmptSuperscriptOffset.x = WDPTOLP(output->otmptSuperscriptOffset.x);
1577         output->otmptSuperscriptOffset.y = HDPTOLP(output->otmptSuperscriptOffset.y);
1578         output->otmsStrikeoutSize = abs(INTERNAL_YDSTOWS(dc,output->otmsStrikeoutSize));
1579         output->otmsStrikeoutPosition = HDPTOLP(output->otmsStrikeoutPosition);
1580         output->otmsUnderscoreSize = HDPTOLP(output->otmsUnderscoreSize);
1581         output->otmsUnderscorePosition = HDPTOLP(output->otmsUnderscorePosition);
1582 #undef WDPTOLP
1583 #undef HDPTOLP
1584         if(output != lpOTM)
1585         {
1586             memcpy(lpOTM, output, cbData);
1587             HeapFree(GetProcessHeap(), 0, output);
1588             ret = cbData;
1589         }
1590     }
1591     release_dc_ptr(dc);
1592     return ret;
1593 }
1594
1595 static LPSTR FONT_GetCharsByRangeA(HDC hdc, UINT firstChar, UINT lastChar, PINT pByteLen)
1596 {
1597     INT i, count = lastChar - firstChar + 1;
1598     UINT mbcp;
1599     UINT c;
1600     LPSTR str;
1601
1602     if (count <= 0)
1603         return NULL;
1604
1605     mbcp = GdiGetCodePage(hdc);
1606     switch (mbcp)
1607     {
1608     case 932:
1609     case 936:
1610     case 949:
1611     case 950:
1612     case 1361:
1613         if (lastChar > 0xffff)
1614             return NULL;
1615         if ((firstChar ^ lastChar) > 0xff)
1616             return NULL;
1617         break;
1618     default:
1619         if (lastChar > 0xff)
1620             return NULL;
1621         mbcp = 0;
1622         break;
1623     }
1624
1625     str = HeapAlloc(GetProcessHeap(), 0, count * 2 + 1);
1626     if (str == NULL)
1627         return NULL;
1628
1629     for(i = 0, c = firstChar; c <= lastChar; i++, c++)
1630     {
1631         if (mbcp) {
1632             if (c > 0xff)
1633                 str[i++] = (BYTE)(c >> 8);
1634             if (c <= 0xff && IsDBCSLeadByteEx(mbcp, c))
1635                 str[i] = 0x1f; /* FIXME: use default character */
1636             else
1637                 str[i] = (BYTE)c;
1638         }
1639         else
1640             str[i] = (BYTE)c;
1641     }
1642     str[i] = '\0';
1643
1644     *pByteLen = i;
1645
1646     return str;
1647 }
1648
1649 /***********************************************************************
1650  *           GetCharWidthW      (GDI32.@)
1651  *           GetCharWidth32W    (GDI32.@)
1652  */
1653 BOOL WINAPI GetCharWidth32W( HDC hdc, UINT firstChar, UINT lastChar,
1654                                LPINT buffer )
1655 {
1656     UINT i;
1657     BOOL ret;
1658     PHYSDEV dev;
1659     DC * dc = get_dc_ptr( hdc );
1660
1661     if (!dc) return FALSE;
1662
1663     dev = GET_DC_PHYSDEV( dc, pGetCharWidth );
1664     ret = dev->funcs->pGetCharWidth( dev, firstChar, lastChar, buffer );
1665
1666     if (ret)
1667     {
1668         /* convert device units to logical */
1669         for( i = firstChar; i <= lastChar; i++, buffer++ )
1670             *buffer = INTERNAL_XDSTOWS(dc, *buffer);
1671     }
1672     release_dc_ptr( dc );
1673     return ret;
1674 }
1675
1676
1677 /***********************************************************************
1678  *           GetCharWidthA      (GDI32.@)
1679  *           GetCharWidth32A    (GDI32.@)
1680  */
1681 BOOL WINAPI GetCharWidth32A( HDC hdc, UINT firstChar, UINT lastChar,
1682                                LPINT buffer )
1683 {
1684     INT i, wlen;
1685     LPSTR str;
1686     LPWSTR wstr;
1687     BOOL ret = TRUE;
1688
1689     str = FONT_GetCharsByRangeA(hdc, firstChar, lastChar, &i);
1690     if(str == NULL)
1691         return FALSE;
1692
1693     wstr = FONT_mbtowc(hdc, str, i, &wlen, NULL);
1694
1695     for(i = 0; i < wlen; i++)
1696     {
1697         if(!GetCharWidth32W(hdc, wstr[i], wstr[i], buffer))
1698         {
1699             ret = FALSE;
1700             break;
1701         }
1702         buffer++;
1703     }
1704
1705     HeapFree(GetProcessHeap(), 0, str);
1706     HeapFree(GetProcessHeap(), 0, wstr);
1707
1708     return ret;
1709 }
1710
1711
1712 /* helper for nulldrv_ExtTextOut */
1713 static DWORD get_glyph_bitmap( HDC hdc, UINT index, UINT aa_flags,
1714                                GLYPHMETRICS *metrics, struct gdi_image_bits *image )
1715 {
1716     UINT ggo_flags = aa_flags | GGO_GLYPH_INDEX;
1717     static const MAT2 identity = { {0,1}, {0,0}, {0,0}, {0,1} };
1718     UINT indices[3] = {0, 0, 0x20};
1719     int i;
1720     DWORD ret, size;
1721     int stride;
1722
1723     indices[0] = index;
1724
1725     for (i = 0; i < sizeof(indices) / sizeof(indices[0]); i++)
1726     {
1727         index = indices[i];
1728         ret = GetGlyphOutlineW( hdc, index, ggo_flags, metrics, 0, NULL, &identity );
1729         if (ret != GDI_ERROR) break;
1730     }
1731
1732     if (ret == GDI_ERROR) return ERROR_NOT_FOUND;
1733     if (!image) return ERROR_SUCCESS;
1734
1735     image->ptr = NULL;
1736     image->free = NULL;
1737     if (!ret) return ERROR_SUCCESS; /* empty glyph */
1738
1739     stride = get_dib_stride( metrics->gmBlackBoxX, 1 );
1740     size = metrics->gmBlackBoxY * stride;
1741
1742     if (!(image->ptr = HeapAlloc( GetProcessHeap(), 0, size ))) return ERROR_OUTOFMEMORY;
1743     image->is_copy = TRUE;
1744     image->free = free_heap_bits;
1745
1746     ret = GetGlyphOutlineW( hdc, index, ggo_flags, metrics, size, image->ptr, &identity );
1747     if (ret == GDI_ERROR)
1748     {
1749         HeapFree( GetProcessHeap(), 0, image->ptr );
1750         return ERROR_NOT_FOUND;
1751     }
1752     return ERROR_SUCCESS;
1753 }
1754
1755 /* helper for nulldrv_ExtTextOut */
1756 static RECT get_total_extents( HDC hdc, INT x, INT y, UINT flags, UINT aa_flags,
1757                                LPCWSTR str, UINT count, const INT *dx )
1758 {
1759     int i;
1760     RECT rect, bounds;
1761
1762     reset_bounds( &bounds );
1763     for (i = 0; i < count; i++)
1764     {
1765         GLYPHMETRICS metrics;
1766
1767         if (get_glyph_bitmap( hdc, (UINT)str[i], aa_flags, &metrics, NULL )) continue;
1768
1769         rect.left   = x + metrics.gmptGlyphOrigin.x;
1770         rect.top    = y - metrics.gmptGlyphOrigin.y;
1771         rect.right  = rect.left + metrics.gmBlackBoxX;
1772         rect.bottom = rect.top  + metrics.gmBlackBoxY;
1773         add_bounds_rect( &bounds, &rect );
1774
1775         if (dx)
1776         {
1777             if (flags & ETO_PDY)
1778             {
1779                 x += dx[ i * 2 ];
1780                 y += dx[ i * 2 + 1];
1781             }
1782             else x += dx[ i ];
1783         }
1784         else
1785         {
1786             x += metrics.gmCellIncX;
1787             y += metrics.gmCellIncY;
1788         }
1789     }
1790     return bounds;
1791 }
1792
1793 /* helper for nulldrv_ExtTextOut */
1794 static void draw_glyph( HDC hdc, INT origin_x, INT origin_y, const GLYPHMETRICS *metrics,
1795                         const struct gdi_image_bits *image, const RECT *clip )
1796 {
1797     static const BYTE masks[8] = {0x80, 0x40, 0x20, 0x10, 0x08, 0x04, 0x02, 0x01};
1798     UINT x, y, i, count, max_count;
1799     BYTE *ptr = image->ptr;
1800     int stride = get_dib_stride( metrics->gmBlackBoxX, 1 );
1801     POINT *pts;
1802     RECT rect, clipped_rect;
1803
1804     rect.left   = origin_x  + metrics->gmptGlyphOrigin.x;
1805     rect.top    = origin_y  - metrics->gmptGlyphOrigin.y;
1806     rect.right  = rect.left + metrics->gmBlackBoxX;
1807     rect.bottom = rect.top  + metrics->gmBlackBoxY;
1808     if (!clip) clipped_rect = rect;
1809     else if (!intersect_rect( &clipped_rect, &rect, clip )) return;
1810
1811     max_count = (metrics->gmBlackBoxX + 1) * metrics->gmBlackBoxY;
1812     pts = HeapAlloc( GetProcessHeap(), 0, max_count * sizeof(*pts) );
1813     if (!pts) return;
1814
1815     count = 0;
1816     ptr += (clipped_rect.top - rect.top) * stride;
1817     for (y = clipped_rect.top; y < clipped_rect.bottom; y++, ptr += stride)
1818     {
1819         for (x = clipped_rect.left - rect.left; x < clipped_rect.right - rect.left; x++)
1820         {
1821             while (x < clipped_rect.right - rect.left && !(ptr[x / 8] & masks[x % 8])) x++;
1822             pts[count].x = rect.left + x;
1823             while (x < clipped_rect.right - rect.left && (ptr[x / 8] & masks[x % 8])) x++;
1824             pts[count + 1].x = rect.left + x;
1825             if (pts[count + 1].x > pts[count].x)
1826             {
1827                 pts[count].y = pts[count + 1].y = y;
1828                 count += 2;
1829             }
1830         }
1831     }
1832     assert( count <= max_count );
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 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     if (dc->aa_flags != GGO_BITMAP)
1868     {
1869         char buffer[FIELD_OFFSET( BITMAPINFO, bmiColors[256] )];
1870         BITMAPINFO *info = (BITMAPINFO *)buffer;
1871         struct gdi_image_bits bits;
1872         struct bitblt_coords src, dst;
1873         PHYSDEV dst_dev;
1874         /* FIXME Subpixel modes */
1875         UINT aa_flags = GGO_GRAY4_BITMAP;
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, 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, 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, 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-scalable fonts */
2692     dev = GET_DC_PHYSDEV( dc, pGetTextMetrics );
2693     if (!dev->funcs->pGetTextMetrics( dev, &tm ) || !(tm.tmPitchAndFamily & TMPF_VECTOR))
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 hidden, LPCWSTR resource_file,
2874                                          LPCWSTR font_file, LPCWSTR font_path )
2875 {
2876     TRACE("(%d, %s, %s, %s)\n", hidden, debugstr_w(resource_file),
2877           debugstr_w(font_file), debugstr_w(font_path) );
2878
2879     return WineEngCreateScalableFontResource( hidden, resource_file,
2880                                               font_file, font_path );
2881 }
2882
2883 /*************************************************************************
2884  *             GetKerningPairsA   (GDI32.@)
2885  */
2886 DWORD WINAPI GetKerningPairsA( HDC hDC, DWORD cPairs,
2887                                LPKERNINGPAIR kern_pairA )
2888 {
2889     UINT cp;
2890     CPINFO cpi;
2891     DWORD i, total_kern_pairs, kern_pairs_copied = 0;
2892     KERNINGPAIR *kern_pairW;
2893
2894     if (!cPairs && kern_pairA)
2895     {
2896         SetLastError(ERROR_INVALID_PARAMETER);
2897         return 0;
2898     }
2899
2900     cp = GdiGetCodePage(hDC);
2901
2902     /* GetCPInfo() will fail on CP_SYMBOL, and WideCharToMultiByte is supposed
2903      * to fail on an invalid character for CP_SYMBOL.
2904      */
2905     cpi.DefaultChar[0] = 0;
2906     if (cp != CP_SYMBOL && !GetCPInfo(cp, &cpi))
2907     {
2908         FIXME("Can't find codepage %u info\n", cp);
2909         return 0;
2910     }
2911
2912     total_kern_pairs = GetKerningPairsW(hDC, 0, NULL);
2913     if (!total_kern_pairs) return 0;
2914
2915     kern_pairW = HeapAlloc(GetProcessHeap(), 0, total_kern_pairs * sizeof(*kern_pairW));
2916     GetKerningPairsW(hDC, total_kern_pairs, kern_pairW);
2917
2918     for (i = 0; i < total_kern_pairs; i++)
2919     {
2920         char first, second;
2921
2922         if (!WideCharToMultiByte(cp, 0, &kern_pairW[i].wFirst, 1, &first, 1, NULL, NULL))
2923             continue;
2924
2925         if (!WideCharToMultiByte(cp, 0, &kern_pairW[i].wSecond, 1, &second, 1, NULL, NULL))
2926             continue;
2927
2928         if (first == cpi.DefaultChar[0] || second == cpi.DefaultChar[0])
2929             continue;
2930
2931         if (kern_pairA)
2932         {
2933             if (kern_pairs_copied >= cPairs) break;
2934
2935             kern_pairA->wFirst = (BYTE)first;
2936             kern_pairA->wSecond = (BYTE)second;
2937             kern_pairA->iKernAmount = kern_pairW[i].iKernAmount;
2938             kern_pairA++;
2939         }
2940         kern_pairs_copied++;
2941     }
2942
2943     HeapFree(GetProcessHeap(), 0, kern_pairW);
2944
2945     return kern_pairs_copied;
2946 }
2947
2948 /*************************************************************************
2949  *             GetKerningPairsW   (GDI32.@)
2950  */
2951 DWORD WINAPI GetKerningPairsW( HDC hDC, DWORD cPairs,
2952                                  LPKERNINGPAIR lpKerningPairs )
2953 {
2954     DC *dc;
2955     DWORD ret;
2956     PHYSDEV dev;
2957
2958     TRACE("(%p,%d,%p)\n", hDC, cPairs, lpKerningPairs);
2959
2960     if (!cPairs && lpKerningPairs)
2961     {
2962         SetLastError(ERROR_INVALID_PARAMETER);
2963         return 0;
2964     }
2965
2966     dc = get_dc_ptr(hDC);
2967     if (!dc) return 0;
2968
2969     dev = GET_DC_PHYSDEV( dc, pGetKerningPairs );
2970     ret = dev->funcs->pGetKerningPairs( dev, cPairs, lpKerningPairs );
2971     release_dc_ptr( dc );
2972     return ret;
2973 }
2974
2975 /*************************************************************************
2976  * TranslateCharsetInfo [GDI32.@]
2977  *
2978  * Fills a CHARSETINFO structure for a character set, code page, or
2979  * font. This allows making the correspondence between different labels
2980  * (character set, Windows, ANSI, and OEM codepages, and Unicode ranges)
2981  * of the same encoding.
2982  *
2983  * Only one codepage will be set in lpCs->fs. If TCI_SRCFONTSIG is used,
2984  * only one codepage should be set in *lpSrc.
2985  *
2986  * RETURNS
2987  *   TRUE on success, FALSE on failure.
2988  *
2989  */
2990 BOOL WINAPI TranslateCharsetInfo(
2991   LPDWORD lpSrc, /* [in]
2992        if flags == TCI_SRCFONTSIG: pointer to fsCsb of a FONTSIGNATURE
2993        if flags == TCI_SRCCHARSET: a character set value
2994        if flags == TCI_SRCCODEPAGE: a code page value
2995                  */
2996   LPCHARSETINFO lpCs, /* [out] structure to receive charset information */
2997   DWORD flags /* [in] determines interpretation of lpSrc */)
2998 {
2999     int index = 0;
3000     switch (flags) {
3001     case TCI_SRCFONTSIG:
3002       while (index < MAXTCIINDEX && !(*lpSrc>>index & 0x0001)) index++;
3003       break;
3004     case TCI_SRCCODEPAGE:
3005       while (index < MAXTCIINDEX && PtrToUlong(lpSrc) != FONT_tci[index].ciACP) index++;
3006       break;
3007     case TCI_SRCCHARSET:
3008       while (index < MAXTCIINDEX && PtrToUlong(lpSrc) != FONT_tci[index].ciCharset) index++;
3009       break;
3010     default:
3011       return FALSE;
3012     }
3013     if (index >= MAXTCIINDEX || FONT_tci[index].ciCharset == DEFAULT_CHARSET) return FALSE;
3014     *lpCs = FONT_tci[index];
3015     return TRUE;
3016 }
3017
3018 /*************************************************************************
3019  *             GetFontLanguageInfo   (GDI32.@)
3020  */
3021 DWORD WINAPI GetFontLanguageInfo(HDC hdc)
3022 {
3023         FONTSIGNATURE fontsig;
3024         static const DWORD GCP_DBCS_MASK=0x003F0000,
3025                 GCP_DIACRITIC_MASK=0x00000000,
3026                 FLI_GLYPHS_MASK=0x00000000,
3027                 GCP_GLYPHSHAPE_MASK=0x00000040,
3028                 GCP_KASHIDA_MASK=0x00000000,
3029                 GCP_LIGATE_MASK=0x00000000,
3030                 GCP_USEKERNING_MASK=0x00000000,
3031                 GCP_REORDER_MASK=0x00000060;
3032
3033         DWORD result=0;
3034
3035         GetTextCharsetInfo( hdc, &fontsig, 0 );
3036         /* We detect each flag we return using a bitmask on the Codepage Bitfields */
3037
3038         if( (fontsig.fsCsb[0]&GCP_DBCS_MASK)!=0 )
3039                 result|=GCP_DBCS;
3040
3041         if( (fontsig.fsCsb[0]&GCP_DIACRITIC_MASK)!=0 )
3042                 result|=GCP_DIACRITIC;
3043
3044         if( (fontsig.fsCsb[0]&FLI_GLYPHS_MASK)!=0 )
3045                 result|=FLI_GLYPHS;
3046
3047         if( (fontsig.fsCsb[0]&GCP_GLYPHSHAPE_MASK)!=0 )
3048                 result|=GCP_GLYPHSHAPE;
3049
3050         if( (fontsig.fsCsb[0]&GCP_KASHIDA_MASK)!=0 )
3051                 result|=GCP_KASHIDA;
3052
3053         if( (fontsig.fsCsb[0]&GCP_LIGATE_MASK)!=0 )
3054                 result|=GCP_LIGATE;
3055
3056         if( (fontsig.fsCsb[0]&GCP_USEKERNING_MASK)!=0 )
3057                 result|=GCP_USEKERNING;
3058
3059         /* this might need a test for a HEBREW- or ARABIC_CHARSET as well */
3060         if( GetTextAlign( hdc) & TA_RTLREADING )
3061             if( (fontsig.fsCsb[0]&GCP_REORDER_MASK)!=0 )
3062                     result|=GCP_REORDER;
3063
3064         return result;
3065 }
3066
3067
3068 /*************************************************************************
3069  * GetFontData [GDI32.@]
3070  *
3071  * Retrieve data for TrueType font.
3072  *
3073  * RETURNS
3074  *
3075  * success: Number of bytes returned
3076  * failure: GDI_ERROR
3077  *
3078  * NOTES
3079  *
3080  * Calls SetLastError()
3081  *
3082  */
3083 DWORD WINAPI GetFontData(HDC hdc, DWORD table, DWORD offset,
3084     LPVOID buffer, DWORD length)
3085 {
3086     DC *dc = get_dc_ptr(hdc);
3087     PHYSDEV dev;
3088     DWORD ret;
3089
3090     if(!dc) return GDI_ERROR;
3091
3092     dev = GET_DC_PHYSDEV( dc, pGetFontData );
3093     ret = dev->funcs->pGetFontData( dev, table, offset, buffer, length );
3094     release_dc_ptr( dc );
3095     return ret;
3096 }
3097
3098 /*************************************************************************
3099  * GetGlyphIndicesA [GDI32.@]
3100  */
3101 DWORD WINAPI GetGlyphIndicesA(HDC hdc, LPCSTR lpstr, INT count,
3102                               LPWORD pgi, DWORD flags)
3103 {
3104     DWORD ret;
3105     WCHAR *lpstrW;
3106     INT countW;
3107
3108     TRACE("(%p, %s, %d, %p, 0x%x)\n",
3109           hdc, debugstr_an(lpstr, count), count, pgi, flags);
3110
3111     lpstrW = FONT_mbtowc(hdc, lpstr, count, &countW, NULL);
3112     ret = GetGlyphIndicesW(hdc, lpstrW, countW, pgi, flags);
3113     HeapFree(GetProcessHeap(), 0, lpstrW);
3114
3115     return ret;
3116 }
3117
3118 /*************************************************************************
3119  * GetGlyphIndicesW [GDI32.@]
3120  */
3121 DWORD WINAPI GetGlyphIndicesW(HDC hdc, LPCWSTR lpstr, INT count,
3122                               LPWORD pgi, DWORD flags)
3123 {
3124     DC *dc = get_dc_ptr(hdc);
3125     PHYSDEV dev;
3126     DWORD ret;
3127
3128     TRACE("(%p, %s, %d, %p, 0x%x)\n",
3129           hdc, debugstr_wn(lpstr, count), count, pgi, flags);
3130
3131     if(!dc) return GDI_ERROR;
3132
3133     dev = GET_DC_PHYSDEV( dc, pGetGlyphIndices );
3134     ret = dev->funcs->pGetGlyphIndices( dev, lpstr, count, pgi, flags );
3135     release_dc_ptr( dc );
3136     return ret;
3137 }
3138
3139 /*************************************************************************
3140  * GetCharacterPlacementA [GDI32.@]
3141  *
3142  * See GetCharacterPlacementW.
3143  *
3144  * NOTES:
3145  *  the web browser control of ie4 calls this with dwFlags=0
3146  */
3147 DWORD WINAPI
3148 GetCharacterPlacementA(HDC hdc, LPCSTR lpString, INT uCount,
3149                          INT nMaxExtent, GCP_RESULTSA *lpResults,
3150                          DWORD dwFlags)
3151 {
3152     WCHAR *lpStringW;
3153     INT uCountW;
3154     GCP_RESULTSW resultsW;
3155     DWORD ret;
3156     UINT font_cp;
3157
3158     TRACE("%s, %d, %d, 0x%08x\n",
3159           debugstr_an(lpString, uCount), uCount, nMaxExtent, dwFlags);
3160
3161     /* both structs are equal in size */
3162     memcpy(&resultsW, lpResults, sizeof(resultsW));
3163
3164     lpStringW = FONT_mbtowc(hdc, lpString, uCount, &uCountW, &font_cp);
3165     if(lpResults->lpOutString)
3166         resultsW.lpOutString = HeapAlloc(GetProcessHeap(), 0, sizeof(WCHAR)*uCountW);
3167
3168     ret = GetCharacterPlacementW(hdc, lpStringW, uCountW, nMaxExtent, &resultsW, dwFlags);
3169
3170     lpResults->nGlyphs = resultsW.nGlyphs;
3171     lpResults->nMaxFit = resultsW.nMaxFit;
3172
3173     if(lpResults->lpOutString) {
3174         WideCharToMultiByte(font_cp, 0, resultsW.lpOutString, uCountW,
3175                             lpResults->lpOutString, uCount, NULL, NULL );
3176     }
3177
3178     HeapFree(GetProcessHeap(), 0, lpStringW);
3179     HeapFree(GetProcessHeap(), 0, resultsW.lpOutString);
3180
3181     return ret;
3182 }
3183
3184 /*************************************************************************
3185  * GetCharacterPlacementW [GDI32.@]
3186  *
3187  *   Retrieve information about a string. This includes the width, reordering,
3188  *   Glyphing and so on.
3189  *
3190  * RETURNS
3191  *
3192  *   The width and height of the string if successful, 0 if failed.
3193  *
3194  * BUGS
3195  *
3196  *   All flags except GCP_REORDER are not yet implemented.
3197  *   Reordering is not 100% compliant to the Windows BiDi method.
3198  *   Caret positioning is not yet implemented for BiDi.
3199  *   Classes are not yet implemented.
3200  *
3201  */
3202 DWORD WINAPI
3203 GetCharacterPlacementW(
3204                 HDC hdc,                /* [in] Device context for which the rendering is to be done */
3205                 LPCWSTR lpString,       /* [in] The string for which information is to be returned */
3206                 INT uCount,             /* [in] Number of WORDS in string. */
3207                 INT nMaxExtent,         /* [in] Maximum extent the string is to take (in HDC logical units) */
3208                 GCP_RESULTSW *lpResults,/* [in/out] A pointer to a GCP_RESULTSW struct */
3209                 DWORD dwFlags           /* [in] Flags specifying how to process the string */
3210                 )
3211 {
3212     DWORD ret=0;
3213     SIZE size;
3214     UINT i, nSet;
3215
3216     TRACE("%s, %d, %d, 0x%08x\n",
3217           debugstr_wn(lpString, uCount), uCount, nMaxExtent, dwFlags);
3218
3219     TRACE("lStructSize=%d, lpOutString=%p, lpOrder=%p, lpDx=%p, lpCaretPos=%p\n"
3220           "lpClass=%p, lpGlyphs=%p, nGlyphs=%u, nMaxFit=%d\n",
3221             lpResults->lStructSize, lpResults->lpOutString, lpResults->lpOrder,
3222             lpResults->lpDx, lpResults->lpCaretPos, lpResults->lpClass,
3223             lpResults->lpGlyphs, lpResults->nGlyphs, lpResults->nMaxFit);
3224
3225     if(dwFlags&(~GCP_REORDER))                  FIXME("flags 0x%08x ignored\n", dwFlags);
3226     if(lpResults->lpClass)      FIXME("classes not implemented\n");
3227     if (lpResults->lpCaretPos && (dwFlags & GCP_REORDER))
3228         FIXME("Caret positions for complex scripts not implemented\n");
3229
3230         nSet = (UINT)uCount;
3231         if(nSet > lpResults->nGlyphs)
3232                 nSet = lpResults->nGlyphs;
3233
3234         /* return number of initialized fields */
3235         lpResults->nGlyphs = nSet;
3236
3237         if((dwFlags&GCP_REORDER)==0 )
3238         {
3239                 /* Treat the case where no special handling was requested in a fastpath way */
3240                 /* copy will do if the GCP_REORDER flag is not set */
3241                 if(lpResults->lpOutString)
3242                     memcpy( lpResults->lpOutString, lpString, nSet * sizeof(WCHAR));
3243
3244                 if(lpResults->lpOrder)
3245                 {
3246                         for(i = 0; i < nSet; i++)
3247                                 lpResults->lpOrder[i] = i;
3248                 }
3249         } else
3250         {
3251             BIDI_Reorder(NULL, lpString, uCount, dwFlags, WINE_GCPW_FORCE_LTR, lpResults->lpOutString,
3252                           nSet, lpResults->lpOrder, NULL, NULL );
3253         }
3254
3255         /* FIXME: Will use the placement chars */
3256         if (lpResults->lpDx)
3257         {
3258                 int c;
3259                 for (i = 0; i < nSet; i++)
3260                 {
3261                         if (GetCharWidth32W(hdc, lpString[i], lpString[i], &c))
3262                                 lpResults->lpDx[i]= c;
3263                 }
3264         }
3265
3266     if (lpResults->lpCaretPos && !(dwFlags & GCP_REORDER))
3267     {
3268         int pos = 0;
3269
3270         lpResults->lpCaretPos[0] = 0;
3271         for (i = 1; i < nSet; i++)
3272             if (GetTextExtentPoint32W(hdc, &(lpString[i - 1]), 1, &size))
3273                 lpResults->lpCaretPos[i] = (pos += size.cx);
3274     }
3275
3276     if(lpResults->lpGlyphs)
3277         GetGlyphIndicesW(hdc, lpString, nSet, lpResults->lpGlyphs, 0);
3278
3279     if (GetTextExtentPoint32W(hdc, lpString, uCount, &size))
3280       ret = MAKELONG(size.cx, size.cy);
3281
3282     return ret;
3283 }
3284
3285 /*************************************************************************
3286  *      GetCharABCWidthsFloatA [GDI32.@]
3287  *
3288  * See GetCharABCWidthsFloatW.
3289  */
3290 BOOL WINAPI GetCharABCWidthsFloatA( HDC hdc, UINT first, UINT last, LPABCFLOAT abcf )
3291 {
3292     INT i, wlen;
3293     LPSTR str;
3294     LPWSTR wstr;
3295     BOOL ret = TRUE;
3296
3297     str = FONT_GetCharsByRangeA(hdc, first, last, &i);
3298     if (str == NULL)
3299         return FALSE;
3300
3301     wstr = FONT_mbtowc( hdc, str, i, &wlen, NULL );
3302
3303     for (i = 0; i < wlen; i++)
3304     {
3305         if (!GetCharABCWidthsFloatW( hdc, wstr[i], wstr[i], abcf ))
3306         {
3307             ret = FALSE;
3308             break;
3309         }
3310         abcf++;
3311     }
3312
3313     HeapFree( GetProcessHeap(), 0, str );
3314     HeapFree( GetProcessHeap(), 0, wstr );
3315
3316     return ret;
3317 }
3318
3319 /*************************************************************************
3320  *      GetCharABCWidthsFloatW [GDI32.@]
3321  *
3322  * Retrieves widths of a range of characters.
3323  *
3324  * PARAMS
3325  *    hdc   [I] Handle to device context.
3326  *    first [I] First character in range to query.
3327  *    last  [I] Last character in range to query.
3328  *    abcf  [O] Array of LPABCFLOAT structures.
3329  *
3330  * RETURNS
3331  *    Success: TRUE
3332  *    Failure: FALSE
3333  */
3334 BOOL WINAPI GetCharABCWidthsFloatW( HDC hdc, UINT first, UINT last, LPABCFLOAT abcf )
3335 {
3336     UINT i;
3337     ABC *abc;
3338     PHYSDEV dev;
3339     BOOL ret = FALSE;
3340     DC *dc = get_dc_ptr( hdc );
3341
3342     TRACE("%p, %d, %d, %p\n", hdc, first, last, abcf);
3343
3344     if (!dc) return FALSE;
3345
3346     if (!abcf) goto done;
3347     if (!(abc = HeapAlloc( GetProcessHeap(), 0, (last - first + 1) * sizeof(*abc) ))) goto done;
3348
3349     dev = GET_DC_PHYSDEV( dc, pGetCharABCWidths );
3350     ret = dev->funcs->pGetCharABCWidths( dev, first, last, abc );
3351     if (ret)
3352     {
3353         /* convert device units to logical */
3354         for (i = first; i <= last; i++, abcf++)
3355         {
3356             abcf->abcfA = abc[i - first].abcA * dc->xformVport2World.eM11;
3357             abcf->abcfB = abc[i - first].abcB * dc->xformVport2World.eM11;
3358             abcf->abcfC = abc[i - first].abcC * dc->xformVport2World.eM11;
3359         }
3360     }
3361     HeapFree( GetProcessHeap(), 0, abc );
3362
3363 done:
3364     release_dc_ptr( dc );
3365     return ret;
3366 }
3367
3368 /*************************************************************************
3369  *      GetCharWidthFloatA [GDI32.@]
3370  */
3371 BOOL WINAPI GetCharWidthFloatA(HDC hdc, UINT iFirstChar,
3372                                     UINT iLastChar, PFLOAT pxBuffer)
3373 {
3374     FIXME("%p, %u, %u, %p: stub!\n", hdc, iFirstChar, iLastChar, pxBuffer);
3375     return 0;
3376 }
3377
3378 /*************************************************************************
3379  *      GetCharWidthFloatW [GDI32.@]
3380  */
3381 BOOL WINAPI GetCharWidthFloatW(HDC hdc, UINT iFirstChar,
3382                                     UINT iLastChar, PFLOAT pxBuffer)
3383 {
3384     FIXME("%p, %u, %u, %p: stub!\n", hdc, iFirstChar, iLastChar, pxBuffer);
3385     return 0;
3386 }
3387
3388
3389 /***********************************************************************
3390  *                                                                     *
3391  *           Font Resource API                                         *
3392  *                                                                     *
3393  ***********************************************************************/
3394
3395 /***********************************************************************
3396  *           AddFontResourceA    (GDI32.@)
3397  */
3398 INT WINAPI AddFontResourceA( LPCSTR str )
3399 {
3400     return AddFontResourceExA( str, 0, NULL);
3401 }
3402
3403 /***********************************************************************
3404  *           AddFontResourceW    (GDI32.@)
3405  */
3406 INT WINAPI AddFontResourceW( LPCWSTR str )
3407 {
3408     return AddFontResourceExW(str, 0, NULL);
3409 }
3410
3411
3412 /***********************************************************************
3413  *           AddFontResourceExA    (GDI32.@)
3414  */
3415 INT WINAPI AddFontResourceExA( LPCSTR str, DWORD fl, PVOID pdv )
3416 {
3417     DWORD len = MultiByteToWideChar(CP_ACP, 0, str, -1, NULL, 0);
3418     LPWSTR strW = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
3419     INT ret;
3420
3421     MultiByteToWideChar(CP_ACP, 0, str, -1, strW, len);
3422     ret = AddFontResourceExW(strW, fl, pdv);
3423     HeapFree(GetProcessHeap(), 0, strW);
3424     return ret;
3425 }
3426
3427 static BOOL CALLBACK load_enumed_resource(HMODULE hModule, LPCWSTR type, LPWSTR name, LONG_PTR lParam)
3428 {
3429     HRSRC rsrc = FindResourceW(hModule, name, type);
3430     HGLOBAL hMem = LoadResource(hModule, rsrc);
3431     LPVOID *pMem = LockResource(hMem);
3432     int *num_total = (int *)lParam;
3433     DWORD num_in_res;
3434
3435     TRACE("Found resource %s - trying to load\n", wine_dbgstr_w(type));
3436     if (!AddFontMemResourceEx(pMem, SizeofResource(hModule, rsrc), NULL, &num_in_res))
3437     {
3438         ERR("Failed to load PE font resource mod=%p ptr=%p\n", hModule, hMem);
3439         return FALSE;
3440     }
3441
3442     *num_total += num_in_res;
3443     return TRUE;
3444 }
3445
3446 static void *map_file( const WCHAR *filename, LARGE_INTEGER *size )
3447 {
3448     HANDLE file, mapping;
3449     void *ptr;
3450
3451     file = CreateFileW( filename, GENERIC_READ, 0, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL );
3452     if (file == INVALID_HANDLE_VALUE) return NULL;
3453
3454     if (!GetFileSizeEx( file, size ) || size->u.HighPart)
3455     {
3456         CloseHandle( file );
3457         return NULL;
3458     }
3459
3460     mapping = CreateFileMappingW( file, NULL, PAGE_READONLY, 0, 0, NULL );
3461     CloseHandle( file );
3462     if (!mapping) return NULL;
3463
3464     ptr = MapViewOfFile( mapping, FILE_MAP_READ, 0, 0, 0 );
3465     CloseHandle( mapping );
3466
3467     return ptr;
3468 }
3469
3470 static WCHAR *get_scalable_filename( const WCHAR *res )
3471 {
3472     LARGE_INTEGER size;
3473     BYTE *ptr = map_file( res, &size );
3474     const IMAGE_DOS_HEADER *dos;
3475     const IMAGE_OS2_HEADER *ne;
3476     WCHAR *name = NULL;
3477     WORD rsrc_off, align, type_id, count;
3478     DWORD res_off, res_len, i;
3479     int len;
3480
3481     if (!ptr) return NULL;
3482
3483     if (size.u.LowPart < sizeof( *dos )) goto fail;
3484     dos = (const IMAGE_DOS_HEADER *)ptr;
3485     if (dos->e_magic != IMAGE_DOS_SIGNATURE) goto fail;
3486     if (size.u.LowPart < dos->e_lfanew + sizeof( *ne )) goto fail;
3487     ne = (const IMAGE_OS2_HEADER *)(ptr + dos->e_lfanew);
3488     rsrc_off = dos->e_lfanew + ne->ne_rsrctab;
3489     if (size.u.LowPart < rsrc_off + 10) goto fail;
3490     align = *(WORD *)(ptr + rsrc_off);
3491     rsrc_off += 2;
3492     type_id = *(WORD *)(ptr + rsrc_off);
3493     while (type_id && type_id != 0x80cc)
3494     {
3495         count = *(WORD *)(ptr + rsrc_off + 2);
3496         rsrc_off += 8 + count * 12;
3497         if (size.u.LowPart < rsrc_off + 8) goto fail;
3498         type_id = *(WORD *)(ptr + rsrc_off);
3499     }
3500     if (!type_id) goto fail;
3501     count = *(WORD *)(ptr + rsrc_off + 2);
3502     if (size.u.LowPart < rsrc_off + 8 + count * 12) goto fail;
3503
3504     res_off = *(WORD *)(ptr + rsrc_off + 8) << align;
3505     res_len = *(WORD *)(ptr + rsrc_off + 10) << align;
3506     if (size.u.LowPart < res_off + res_len) goto fail;
3507
3508     for (i = 0; i < res_len; i++)
3509         if (ptr[ res_off + i ] == 0) break;
3510     if (i == res_len) goto fail;
3511
3512     len = MultiByteToWideChar( CP_ACP, 0, (char *)ptr + res_off, -1, NULL, 0 );
3513     name = HeapAlloc( GetProcessHeap(), 0, len * sizeof(WCHAR) );
3514     if (name) MultiByteToWideChar( CP_ACP, 0, (char *)ptr + res_off, -1, name, len );
3515
3516 fail:
3517     UnmapViewOfFile( ptr );
3518     return name;
3519 }
3520
3521 /***********************************************************************
3522  *           AddFontResourceExW    (GDI32.@)
3523  */
3524 INT WINAPI AddFontResourceExW( LPCWSTR str, DWORD fl, PVOID pdv )
3525 {
3526     int ret = WineEngAddFontResourceEx(str, fl, pdv);
3527     WCHAR *filename;
3528
3529     if (ret == 0)
3530     {
3531         /* FreeType <2.3.5 has problems reading resources wrapped in PE files. */
3532         HMODULE hModule = LoadLibraryExW(str, NULL, LOAD_LIBRARY_AS_DATAFILE);
3533         if (hModule != NULL)
3534         {
3535             int num_resources = 0;
3536             LPWSTR rt_font = (LPWSTR)((ULONG_PTR)8);  /* we don't want to include winuser.h */
3537
3538             TRACE("WineEngAddFontResourceEx failed on PE file %s - trying to load resources manually\n",
3539                 wine_dbgstr_w(str));
3540             if (EnumResourceNamesW(hModule, rt_font, load_enumed_resource, (LONG_PTR)&num_resources))
3541                 ret = num_resources;
3542             FreeLibrary(hModule);
3543         }
3544         else if ((filename = get_scalable_filename( str )) != NULL)
3545         {
3546             ret = WineEngAddFontResourceEx( filename, fl, pdv );
3547             HeapFree( GetProcessHeap(), 0, filename );
3548         }
3549     }
3550     return ret;
3551 }
3552
3553 /***********************************************************************
3554  *           RemoveFontResourceA    (GDI32.@)
3555  */
3556 BOOL WINAPI RemoveFontResourceA( LPCSTR str )
3557 {
3558     return RemoveFontResourceExA(str, 0, 0);
3559 }
3560
3561 /***********************************************************************
3562  *           RemoveFontResourceW    (GDI32.@)
3563  */
3564 BOOL WINAPI RemoveFontResourceW( LPCWSTR str )
3565 {
3566     return RemoveFontResourceExW(str, 0, 0);
3567 }
3568
3569 /***********************************************************************
3570  *           AddFontMemResourceEx    (GDI32.@)
3571  */
3572 HANDLE WINAPI AddFontMemResourceEx( PVOID pbFont, DWORD cbFont, PVOID pdv, DWORD *pcFonts)
3573 {
3574     HANDLE ret;
3575     DWORD num_fonts;
3576
3577     if (!pbFont || !cbFont || !pcFonts)
3578     {
3579         SetLastError(ERROR_INVALID_PARAMETER);
3580         return NULL;
3581     }
3582
3583     ret = WineEngAddFontMemResourceEx(pbFont, cbFont, pdv, &num_fonts);
3584     if (ret)
3585     {
3586         __TRY
3587         {
3588             *pcFonts = num_fonts;
3589         }
3590         __EXCEPT_PAGE_FAULT
3591         {
3592             WARN("page fault while writing to *pcFonts (%p)\n", pcFonts);
3593             RemoveFontMemResourceEx(ret);
3594             ret = 0;
3595         }
3596         __ENDTRY
3597     }
3598     return ret;
3599 }
3600
3601 /***********************************************************************
3602  *           RemoveFontMemResourceEx    (GDI32.@)
3603  */
3604 BOOL WINAPI RemoveFontMemResourceEx( HANDLE fh )
3605 {
3606     FIXME("(%p) stub\n", fh);
3607     return TRUE;
3608 }
3609
3610 /***********************************************************************
3611  *           RemoveFontResourceExA    (GDI32.@)
3612  */
3613 BOOL WINAPI RemoveFontResourceExA( LPCSTR str, DWORD fl, PVOID pdv )
3614 {
3615     DWORD len = MultiByteToWideChar(CP_ACP, 0, str, -1, NULL, 0);
3616     LPWSTR strW = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
3617     INT ret;
3618
3619     MultiByteToWideChar(CP_ACP, 0, str, -1, strW, len);
3620     ret = RemoveFontResourceExW(strW, fl, pdv);
3621     HeapFree(GetProcessHeap(), 0, strW);
3622     return ret;
3623 }
3624
3625 /***********************************************************************
3626  *           RemoveFontResourceExW    (GDI32.@)
3627  */
3628 BOOL WINAPI RemoveFontResourceExW( LPCWSTR str, DWORD fl, PVOID pdv )
3629 {
3630     return WineEngRemoveFontResourceEx(str, fl, pdv);
3631 }
3632
3633 /***********************************************************************
3634  *           GetTextCharset    (GDI32.@)
3635  */
3636 UINT WINAPI GetTextCharset(HDC hdc)
3637 {
3638     /* MSDN docs say this is equivalent */
3639     return GetTextCharsetInfo(hdc, NULL, 0);
3640 }
3641
3642 /***********************************************************************
3643  *           GetTextCharsetInfo    (GDI32.@)
3644  */
3645 UINT WINAPI GetTextCharsetInfo(HDC hdc, LPFONTSIGNATURE fs, DWORD flags)
3646 {
3647     UINT ret = DEFAULT_CHARSET;
3648     DC *dc = get_dc_ptr(hdc);
3649     PHYSDEV dev;
3650
3651     if (dc)
3652     {
3653         dev = GET_DC_PHYSDEV( dc, pGetTextCharsetInfo );
3654         ret = dev->funcs->pGetTextCharsetInfo( dev, fs, flags );
3655         release_dc_ptr( dc );
3656     }
3657
3658     if (ret == DEFAULT_CHARSET && fs)
3659         memset(fs, 0, sizeof(FONTSIGNATURE));
3660     return ret;
3661 }
3662
3663 /***********************************************************************
3664  *           GdiGetCharDimensions    (GDI32.@)
3665  *
3666  * Gets the average width of the characters in the English alphabet.
3667  *
3668  * PARAMS
3669  *  hdc    [I] Handle to the device context to measure on.
3670  *  lptm   [O] Pointer to memory to store the text metrics into.
3671  *  height [O] On exit, the maximum height of characters in the English alphabet.
3672  *
3673  * RETURNS
3674  *  The average width of characters in the English alphabet.
3675  *
3676  * NOTES
3677  *  This function is used by the dialog manager to get the size of a dialog
3678  *  unit. It should also be used by other pieces of code that need to know
3679  *  the size of a dialog unit in logical units without having access to the
3680  *  window handle of the dialog.
3681  *  Windows caches the font metrics from this function, but we don't and
3682  *  there doesn't appear to be an immediate advantage to do so.
3683  *
3684  * SEE ALSO
3685  *  GetTextExtentPointW, GetTextMetricsW, MapDialogRect.
3686  */
3687 LONG WINAPI GdiGetCharDimensions(HDC hdc, LPTEXTMETRICW lptm, LONG *height)
3688 {
3689     SIZE sz;
3690     static const WCHAR alphabet[] = {
3691         'a','b','c','d','e','f','g','h','i','j','k','l','m','n','o','p','q',
3692         'r','s','t','u','v','w','x','y','z','A','B','C','D','E','F','G','H',
3693         'I','J','K','L','M','N','O','P','Q','R','S','T','U','V','W','X','Y','Z',0};
3694
3695     if(lptm && !GetTextMetricsW(hdc, lptm)) return 0;
3696
3697     if(!GetTextExtentPointW(hdc, alphabet, 52, &sz)) return 0;
3698
3699     if (height) *height = sz.cy;
3700     return (sz.cx / 26 + 1) / 2;
3701 }
3702
3703 BOOL WINAPI EnableEUDC(BOOL fEnableEUDC)
3704 {
3705     FIXME("(%d): stub\n", fEnableEUDC);
3706     return FALSE;
3707 }
3708
3709 /***********************************************************************
3710  *           GetCharWidthI    (GDI32.@)
3711  *
3712  * Retrieve widths of characters.
3713  *
3714  * PARAMS
3715  *  hdc    [I] Handle to a device context.
3716  *  first  [I] First glyph in range to query.
3717  *  count  [I] Number of glyph indices to query.
3718  *  glyphs [I] Array of glyphs to query.
3719  *  buffer [O] Buffer to receive character widths.
3720  *
3721  * NOTES
3722  *  Only works with TrueType fonts.
3723  *
3724  * RETURNS
3725  *  Success: TRUE
3726  *  Failure: FALSE
3727  */
3728 BOOL WINAPI GetCharWidthI(HDC hdc, UINT first, UINT count, LPWORD glyphs, LPINT buffer)
3729 {
3730     ABC *abc;
3731     unsigned int i;
3732
3733     TRACE("(%p, %d, %d, %p, %p)\n", hdc, first, count, glyphs, buffer);
3734
3735     if (!(abc = HeapAlloc(GetProcessHeap(), 0, count * sizeof(ABC))))
3736         return FALSE;
3737
3738     if (!GetCharABCWidthsI(hdc, first, count, glyphs, abc))
3739     {
3740         HeapFree(GetProcessHeap(), 0, abc);
3741         return FALSE;
3742     }
3743
3744     for (i = 0; i < count; i++)
3745         buffer[i] = abc->abcA + abc->abcB + abc->abcC;
3746
3747     HeapFree(GetProcessHeap(), 0, abc);
3748     return TRUE;
3749 }
3750
3751 /***********************************************************************
3752  *           GetFontUnicodeRanges    (GDI32.@)
3753  *
3754  *  Retrieve a list of supported Unicode characters in a font.
3755  *
3756  *  PARAMS
3757  *   hdc  [I] Handle to a device context.
3758  *   lpgs [O] GLYPHSET structure specifying supported character ranges.
3759  *
3760  *  RETURNS
3761  *   Success: Number of bytes written to the buffer pointed to by lpgs.
3762  *   Failure: 0
3763  *
3764  */
3765 DWORD WINAPI GetFontUnicodeRanges(HDC hdc, LPGLYPHSET lpgs)
3766 {
3767     DWORD ret;
3768     PHYSDEV dev;
3769     DC *dc = get_dc_ptr(hdc);
3770
3771     TRACE("(%p, %p)\n", hdc, lpgs);
3772
3773     if (!dc) return 0;
3774
3775     dev = GET_DC_PHYSDEV( dc, pGetFontUnicodeRanges );
3776     ret = dev->funcs->pGetFontUnicodeRanges( dev, lpgs );
3777     release_dc_ptr(dc);
3778     return ret;
3779 }
3780
3781
3782 /*************************************************************
3783  *           FontIsLinked    (GDI32.@)
3784  */
3785 BOOL WINAPI FontIsLinked(HDC hdc)
3786 {
3787     DC *dc = get_dc_ptr(hdc);
3788     PHYSDEV dev;
3789     BOOL ret;
3790
3791     if (!dc) return FALSE;
3792     dev = GET_DC_PHYSDEV( dc, pFontIsLinked );
3793     ret = dev->funcs->pFontIsLinked( dev );
3794     release_dc_ptr(dc);
3795     TRACE("returning %d\n", ret);
3796     return ret;
3797 }
3798
3799 /*************************************************************
3800  *           GdiRealizationInfo    (GDI32.@)
3801  *
3802  * Returns a structure that contains some font information.
3803  */
3804 BOOL WINAPI GdiRealizationInfo(HDC hdc, realization_info_t *info)
3805 {
3806     DC *dc = get_dc_ptr(hdc);
3807     PHYSDEV dev;
3808     BOOL ret;
3809
3810     if (!dc) return FALSE;
3811     dev = GET_DC_PHYSDEV( dc, pGdiRealizationInfo );
3812     ret = dev->funcs->pGdiRealizationInfo( dev, info );
3813     release_dc_ptr(dc);
3814     return ret;
3815 }