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