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