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