git.oblomov.eu Git - wine/blob - dlls/gdi32/font.c

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