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

   1 /*
   2  * GDI font objects
   3  *
   4  * Copyright 1993 Alexandre Julliard
   5  *           1997 Alex Korobka
   6  * Copyright 2002,2003 Shachar Shemesh
   7  *
   8  * This library is free software; you can redistribute it and/or
   9  * modify it under the terms of the GNU Lesser General Public
  10  * License as published by the Free Software Foundation; either
  11  * version 2.1 of the License, or (at your option) any later version.
  12  *
  13  * This library is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16  * Lesser General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU Lesser General Public
  19  * License along with this library; if not, write to the Free Software
  20  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  21  */
  22
  23 #include "config.h"
  24 #include "wine/port.h"
  25
  26 #include <stdarg.h>
  27 #include <stdlib.h>
  28 #include <string.h>
  29 #include <assert.h>
  30 #include "winerror.h"
  31 #include "windef.h"
  32 #include "winbase.h"
  33 #include "winnls.h"
  34 #include "wownt32.h"
  35 #include "gdi.h"
  36 #include "gdi_private.h"
  37 #include "wine/unicode.h"
  38 #include "wine/debug.h"
  39
  40 WINE_DEFAULT_DEBUG_CHANNEL(font);
  41 WINE_DECLARE_DEBUG_CHANNEL(gdi);
  42
  43   /* Device -> World size conversion */
  44
  45 /* Performs a device to world transformation on the specified width (which
  46  * is in integer format).
  47  */
  48 static inline INT INTERNAL_XDSTOWS(DC *dc, INT width)
  49 {
  50     FLOAT floatWidth;
  51
  52     /* Perform operation with floating point */
  53     floatWidth = (FLOAT)width * dc->xformVport2World.eM11;
  54     /* Round to integers */
  55     return GDI_ROUND(floatWidth);
  56 }
  57
  58 /* Performs a device to world transformation on the specified size (which
  59  * is in integer format).
  60  */
  61 static inline INT INTERNAL_YDSTOWS(DC *dc, INT height)
  62 {
  63     FLOAT floatHeight;
  64
  65     /* Perform operation with floating point */
  66     floatHeight = (FLOAT)height * dc->xformVport2World.eM22;
  67     /* Round to integers */
  68     return GDI_ROUND(floatHeight);
  69 }
  70
  71
  72 static HGDIOBJ FONT_SelectObject( HGDIOBJ handle, void *obj, HDC hdc );
  73 static INT FONT_GetObject16( HGDIOBJ handle, void *obj, INT count, LPVOID buffer );
  74 static INT FONT_GetObjectA( HGDIOBJ handle, void *obj, INT count, LPVOID buffer );
  75 static INT FONT_GetObjectW( HGDIOBJ handle, void *obj, INT count, LPVOID buffer );
  76 static BOOL FONT_DeleteObject( HGDIOBJ handle, void *obj );
  77
  78 static const struct gdi_obj_funcs font_funcs =
  79 {
  80     FONT_SelectObject,  /* pSelectObject */
  81     FONT_GetObject16,   /* pGetObject16 */
  82     FONT_GetObjectA,    /* pGetObjectA */
  83     FONT_GetObjectW,    /* pGetObjectW */
  84     NULL,               /* pUnrealizeObject */
  85     FONT_DeleteObject   /* pDeleteObject */
  86 };
  87
  88 #define ENUM_UNICODE    0x00000001
  89 #define ENUM_CALLED     0x00000002
  90
  91 typedef struct
  92 {
  93     GDIOBJHDR   header;
  94     LOGFONTW    logfont;
  95 } FONTOBJ;
  96
  97 typedef struct
  98 {
  99   LPLOGFONT16           lpLogFontParam;
 100   FONTENUMPROC16        lpEnumFunc;
 101   LPARAM                lpData;
 102
 103   LPNEWTEXTMETRICEX16   lpTextMetric;
 104   LPENUMLOGFONTEX16     lpLogFont;
 105   SEGPTR                segTextMetric;
 106   SEGPTR                segLogFont;
 107   DWORD                 dwFlags;
 108   HDC                   hdc;
 109   DC                   *dc;
 110   PHYSDEV               physDev;
 111 } fontEnum16;
 112
 113 typedef struct
 114 {
 115   LPLOGFONTW          lpLogFontParam;
 116   FONTENUMPROCW       lpEnumFunc;
 117   LPARAM              lpData;
 118   DWORD               dwFlags;
 119   HDC                 hdc;
 120   DC                 *dc;
 121   PHYSDEV             physDev;
 122 } fontEnum32;
 123
 124 /*
 125  *  For TranslateCharsetInfo
 126  */
 127 #define FS(x) {{0,0,0,0},{0x1<<(x),0}}
 128 #define MAXTCIINDEX 32
 129 static CHARSETINFO FONT_tci[MAXTCIINDEX] = {
 130   /* ANSI */
 131   { ANSI_CHARSET, 1252, FS(0)},
 132   { EASTEUROPE_CHARSET, 1250, FS(1)},
 133   { RUSSIAN_CHARSET, 1251, FS(2)},
 134   { GREEK_CHARSET, 1253, FS(3)},
 135   { TURKISH_CHARSET, 1254, FS(4)},
 136   { HEBREW_CHARSET, 1255, FS(5)},
 137   { ARABIC_CHARSET, 1256, FS(6)},
 138   { BALTIC_CHARSET, 1257, FS(7)},
 139   { VIETNAMESE_CHARSET, 1258, FS(8)},
 140   /* reserved by ANSI */
 141   { DEFAULT_CHARSET, 0, FS(0)},
 142   { DEFAULT_CHARSET, 0, FS(0)},
 143   { DEFAULT_CHARSET, 0, FS(0)},
 144   { DEFAULT_CHARSET, 0, FS(0)},
 145   { DEFAULT_CHARSET, 0, FS(0)},
 146   { DEFAULT_CHARSET, 0, FS(0)},
 147   { DEFAULT_CHARSET, 0, FS(0)},
 148   /* ANSI and OEM */
 149   { THAI_CHARSET,  874,  FS(16)},
 150   { SHIFTJIS_CHARSET, 932, FS(17)},
 151   { GB2312_CHARSET, 936, FS(18)},
 152   { HANGEUL_CHARSET, 949, FS(19)},
 153   { CHINESEBIG5_CHARSET, 950, FS(20)},
 154   { JOHAB_CHARSET, 1361, FS(21)},
 155   /* reserved for alternate ANSI and OEM */
 156   { DEFAULT_CHARSET, 0, FS(0)},
 157   { DEFAULT_CHARSET, 0, FS(0)},
 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   /* reserved for system */
 165   { DEFAULT_CHARSET, 0, FS(0)},
 166   { SYMBOL_CHARSET, CP_SYMBOL, FS(31)},
 167 };
 168
 169 /***********************************************************************
 170  *              LOGFONT conversion functions.
 171  */
 172 static void FONT_LogFontWTo16( const LOGFONTW* font32, LPLOGFONT16 font16 )
 173 {
 174     font16->lfHeight = font32->lfHeight;
 175     font16->lfWidth = font32->lfWidth;
 176     font16->lfEscapement = font32->lfEscapement;
 177     font16->lfOrientation = font32->lfOrientation;
 178     font16->lfWeight = font32->lfWeight;
 179     font16->lfItalic = font32->lfItalic;
 180     font16->lfUnderline = font32->lfUnderline;
 181     font16->lfStrikeOut = font32->lfStrikeOut;
 182     font16->lfCharSet = font32->lfCharSet;
 183     font16->lfOutPrecision = font32->lfOutPrecision;
 184     font16->lfClipPrecision = font32->lfClipPrecision;
 185     font16->lfQuality = font32->lfQuality;
 186     font16->lfPitchAndFamily = font32->lfPitchAndFamily;
 187     WideCharToMultiByte( CP_ACP, 0, font32->lfFaceName, -1,
 188                          font16->lfFaceName, LF_FACESIZE, NULL, NULL );
 189     font16->lfFaceName[LF_FACESIZE-1] = 0;
 190 }
 191
 192 static void FONT_LogFont16ToW( const LOGFONT16 *font16, LPLOGFONTW font32 )
 193 {
 194     font32->lfHeight = font16->lfHeight;
 195     font32->lfWidth = font16->lfWidth;
 196     font32->lfEscapement = font16->lfEscapement;
 197     font32->lfOrientation = font16->lfOrientation;
 198     font32->lfWeight = font16->lfWeight;
 199     font32->lfItalic = font16->lfItalic;
 200     font32->lfUnderline = font16->lfUnderline;
 201     font32->lfStrikeOut = font16->lfStrikeOut;
 202     font32->lfCharSet = font16->lfCharSet;
 203     font32->lfOutPrecision = font16->lfOutPrecision;
 204     font32->lfClipPrecision = font16->lfClipPrecision;
 205     font32->lfQuality = font16->lfQuality;
 206     font32->lfPitchAndFamily = font16->lfPitchAndFamily;
 207     MultiByteToWideChar( CP_ACP, 0, font16->lfFaceName, -1, font32->lfFaceName, LF_FACESIZE );
 208     font32->lfFaceName[LF_FACESIZE-1] = 0;
 209 }
 210
 211 static void FONT_LogFontAToW( const LOGFONTA *fontA, LPLOGFONTW fontW )
 212 {
 213     memcpy(fontW, fontA, sizeof(LOGFONTA) - LF_FACESIZE);
 214     MultiByteToWideChar(CP_ACP, 0, fontA->lfFaceName, -1, fontW->lfFaceName,
 215                         LF_FACESIZE);
 216     fontW->lfFaceName[LF_FACESIZE-1] = 0;
 217 }
 218
 219 static void FONT_LogFontWToA( const LOGFONTW *fontW, LPLOGFONTA fontA )
 220 {
 221     memcpy(fontA, fontW, sizeof(LOGFONTA) - LF_FACESIZE);
 222     WideCharToMultiByte(CP_ACP, 0, fontW->lfFaceName, -1, fontA->lfFaceName,
 223                         LF_FACESIZE, NULL, NULL);
 224     fontA->lfFaceName[LF_FACESIZE-1] = 0;
 225 }
 226
 227 static void FONT_EnumLogFontExWTo16( const ENUMLOGFONTEXW *fontW, LPENUMLOGFONTEX16 font16 )
 228 {
 229     FONT_LogFontWTo16( (LPLOGFONTW)fontW, (LPLOGFONT16)font16);
 230
 231     WideCharToMultiByte( CP_ACP, 0, fontW->elfFullName, -1,
 232                          font16->elfFullName, LF_FULLFACESIZE, NULL, NULL );
 233     font16->elfFullName[LF_FULLFACESIZE-1] = '\0';
 234     WideCharToMultiByte( CP_ACP, 0, fontW->elfStyle, -1,
 235                          font16->elfStyle, LF_FACESIZE, NULL, NULL );
 236     font16->elfStyle[LF_FACESIZE-1] = '\0';
 237     WideCharToMultiByte( CP_ACP, 0, fontW->elfScript, -1,
 238                          font16->elfScript, LF_FACESIZE, NULL, NULL );
 239     font16->elfScript[LF_FACESIZE-1] = '\0';
 240 }
 241
 242 static void FONT_EnumLogFontExWToA( const ENUMLOGFONTEXW *fontW, LPENUMLOGFONTEXA fontA )
 243 {
 244     FONT_LogFontWToA( (LPLOGFONTW)fontW, (LPLOGFONTA)fontA);
 245
 246     WideCharToMultiByte( CP_ACP, 0, fontW->elfFullName, -1,
 247                          fontA->elfFullName, LF_FULLFACESIZE, NULL, NULL );
 248     fontA->elfFullName[LF_FULLFACESIZE-1] = '\0';
 249     WideCharToMultiByte( CP_ACP, 0, fontW->elfStyle, -1,
 250                          fontA->elfStyle, LF_FACESIZE, NULL, NULL );
 251     fontA->elfStyle[LF_FACESIZE-1] = '\0';
 252     WideCharToMultiByte( CP_ACP, 0, fontW->elfScript, -1,
 253                          fontA->elfScript, LF_FACESIZE, NULL, NULL );
 254     fontA->elfScript[LF_FACESIZE-1] = '\0';
 255 }
 256
 257 /***********************************************************************
 258  *              TEXTMETRIC conversion functions.
 259  */
 260 static void FONT_TextMetricWToA(const TEXTMETRICW *ptmW, LPTEXTMETRICA ptmA )
 261 {
 262     ptmA->tmHeight = ptmW->tmHeight;
 263     ptmA->tmAscent = ptmW->tmAscent;
 264     ptmA->tmDescent = ptmW->tmDescent;
 265     ptmA->tmInternalLeading = ptmW->tmInternalLeading;
 266     ptmA->tmExternalLeading = ptmW->tmExternalLeading;
 267     ptmA->tmAveCharWidth = ptmW->tmAveCharWidth;
 268     ptmA->tmMaxCharWidth = ptmW->tmMaxCharWidth;
 269     ptmA->tmWeight = ptmW->tmWeight;
 270     ptmA->tmOverhang = ptmW->tmOverhang;
 271     ptmA->tmDigitizedAspectX = ptmW->tmDigitizedAspectX;
 272     ptmA->tmDigitizedAspectY = ptmW->tmDigitizedAspectY;
 273     ptmA->tmFirstChar = ptmW->tmFirstChar > 255 ? 255 : ptmW->tmFirstChar;
 274     ptmA->tmLastChar = ptmW->tmLastChar > 255 ? 255 : ptmW->tmLastChar;
 275     ptmA->tmDefaultChar = ptmW->tmDefaultChar > 255 ? 255 : ptmW->tmDefaultChar;
 276     ptmA->tmBreakChar = ptmW->tmBreakChar > 255 ? 255 : ptmW->tmBreakChar;
 277     ptmA->tmItalic = ptmW->tmItalic;
 278     ptmA->tmUnderlined = ptmW->tmUnderlined;
 279     ptmA->tmStruckOut = ptmW->tmStruckOut;
 280     ptmA->tmPitchAndFamily = ptmW->tmPitchAndFamily;
 281     ptmA->tmCharSet = ptmW->tmCharSet;
 282 }
 283
 284
 285 static void FONT_NewTextMetricExWTo16(const NEWTEXTMETRICEXW *ptmW, LPNEWTEXTMETRICEX16 ptm16 )
 286 {
 287     ptm16->ntmTm.tmHeight = ptmW->ntmTm.tmHeight;
 288     ptm16->ntmTm.tmAscent = ptmW->ntmTm.tmAscent;
 289     ptm16->ntmTm.tmDescent = ptmW->ntmTm.tmDescent;
 290     ptm16->ntmTm.tmInternalLeading = ptmW->ntmTm.tmInternalLeading;
 291     ptm16->ntmTm.tmExternalLeading = ptmW->ntmTm.tmExternalLeading;
 292     ptm16->ntmTm.tmAveCharWidth = ptmW->ntmTm.tmAveCharWidth;
 293     ptm16->ntmTm.tmMaxCharWidth = ptmW->ntmTm.tmMaxCharWidth;
 294     ptm16->ntmTm.tmWeight = ptmW->ntmTm.tmWeight;
 295     ptm16->ntmTm.tmOverhang = ptmW->ntmTm.tmOverhang;
 296     ptm16->ntmTm.tmDigitizedAspectX = ptmW->ntmTm.tmDigitizedAspectX;
 297     ptm16->ntmTm.tmDigitizedAspectY = ptmW->ntmTm.tmDigitizedAspectY;
 298     ptm16->ntmTm.tmFirstChar = ptmW->ntmTm.tmFirstChar > 255 ? 255 : ptmW->ntmTm.tmFirstChar;
 299     ptm16->ntmTm.tmLastChar = ptmW->ntmTm.tmLastChar > 255 ? 255 : ptmW->ntmTm.tmLastChar;
 300     ptm16->ntmTm.tmDefaultChar = ptmW->ntmTm.tmDefaultChar > 255 ? 255 : ptmW->ntmTm.tmDefaultChar;
 301     ptm16->ntmTm.tmBreakChar = ptmW->ntmTm.tmBreakChar > 255 ? 255 : ptmW->ntmTm.tmBreakChar;
 302     ptm16->ntmTm.tmItalic = ptmW->ntmTm.tmItalic;
 303     ptm16->ntmTm.tmUnderlined = ptmW->ntmTm.tmUnderlined;
 304     ptm16->ntmTm.tmStruckOut = ptmW->ntmTm.tmStruckOut;
 305     ptm16->ntmTm.tmPitchAndFamily = ptmW->ntmTm.tmPitchAndFamily;
 306     ptm16->ntmTm.tmCharSet = ptmW->ntmTm.tmCharSet;
 307     ptm16->ntmTm.ntmFlags = ptmW->ntmTm.ntmFlags;
 308     ptm16->ntmTm.ntmSizeEM = ptmW->ntmTm.ntmSizeEM;
 309     ptm16->ntmTm.ntmCellHeight = ptmW->ntmTm.ntmCellHeight;
 310     ptm16->ntmTm.ntmAvgWidth = ptmW->ntmTm.ntmAvgWidth;
 311     memcpy(&ptm16->ntmFontSig, &ptmW->ntmFontSig, sizeof(FONTSIGNATURE));
 312 }
 313
 314 static void FONT_NewTextMetricExWToA(const NEWTEXTMETRICEXW *ptmW, NEWTEXTMETRICEXA *ptmA )
 315 {
 316     FONT_TextMetricWToA((LPTEXTMETRICW)ptmW, (LPTEXTMETRICA)ptmA);
 317     ptmA->ntmTm.ntmFlags = ptmW->ntmTm.ntmFlags;
 318     ptmA->ntmTm.ntmSizeEM = ptmW->ntmTm.ntmSizeEM;
 319     ptmA->ntmTm.ntmCellHeight = ptmW->ntmTm.ntmCellHeight;
 320     ptmA->ntmTm.ntmAvgWidth = ptmW->ntmTm.ntmAvgWidth;
 321     memcpy(&ptmA->ntmFontSig, &ptmW->ntmFontSig, sizeof(FONTSIGNATURE));
 322 }
 323
 324
 325 /***********************************************************************
 326  *           FONT_mbtowc
 327  *
 328  * Returns a '\0' terminated Unicode translation of str using the
 329  * charset of the currently selected font in hdc.  If count is -1 then
 330  * str is assumed to be '\0' terminated, otherwise it contains the
 331  * number of bytes to convert.  If plenW is non-NULL, on return it
 332  * will point to the number of WCHARs (excluding the '\0') that have
 333  * been written.  If pCP is non-NULL, on return it will point to the
 334  * codepage used in the conversion.
 335  * The caller should free the returned LPWSTR from the process
 336  * heap itself.
 337  */
 338 static LPWSTR FONT_mbtowc(HDC hdc, LPCSTR str, INT count, INT *plenW, UINT *pCP)
 339 {
 340     UINT cp = CP_ACP;
 341     INT lenW;
 342     LPWSTR strW;
 343     CHARSETINFO csi;
 344     int charset = GetTextCharset(hdc);
 345
 346     /* Hmm, nicely designed api this one! */
 347     if(TranslateCharsetInfo((DWORD*)charset, &csi, TCI_SRCCHARSET))
 348         cp = csi.ciACP;
 349     else {
 350         switch(charset) {
 351         case OEM_CHARSET:
 352             cp = GetOEMCP();
 353             break;
 354         case DEFAULT_CHARSET:
 355             cp = GetACP();
 356             break;
 357
 358         case VISCII_CHARSET:
 359         case TCVN_CHARSET:
 360         case KOI8_CHARSET:
 361         case ISO3_CHARSET:
 362         case ISO4_CHARSET:
 363         case ISO10_CHARSET:
 364         case CELTIC_CHARSET:
 365             /* FIXME: These have no place here, but because x11drv
 366                enumerates fonts with these (made up) charsets some apps
 367                might use them and then the FIXME below would become
 368                annoying.  Now we could pick the intended codepage for
 369                each of these, but since it's broken anyway we'll just
 370                use CP_ACP and hope it'll go away...
 371             */
 372             cp = CP_ACP;
 373             break;
 374
 375         default:
 376             FIXME("Can't find codepage for charset %d\n", charset);
 377             break;
 378         }
 379     }
 380
 381     TRACE("charset %d => cp %d\n", charset, cp);
 382
 383     if(count == -1) count = strlen(str);
 384     lenW = MultiByteToWideChar(cp, 0, str, count, NULL, 0);
 385     strW = HeapAlloc(GetProcessHeap(), 0, (lenW + 1) * sizeof(WCHAR));
 386     MultiByteToWideChar(cp, 0, str, count, strW, lenW);
 387     strW[lenW] = '\0';
 388     TRACE("mapped %s -> %s\n", debugstr_an(str, count), debugstr_wn(strW, lenW));
 389     if(plenW) *plenW = lenW;
 390     if(pCP) *pCP = cp;
 391     return strW;
 392 }
 393
 394
 395 /***********************************************************************
 396  *           CreateFontIndirectA   (GDI32.@)
 397  */
 398 HFONT WINAPI CreateFontIndirectA( const LOGFONTA *plfA )
 399 {
 400     LOGFONTW lfW;
 401
 402     if (plfA) {
 403         FONT_LogFontAToW( plfA, &lfW );
 404         return CreateFontIndirectW( &lfW );
 405      } else
 406         return CreateFontIndirectW( NULL );
 407
 408 }
 409
 410 /***********************************************************************
 411  *           CreateFontIndirectW   (GDI32.@)
 412  */
 413 HFONT WINAPI CreateFontIndirectW( const LOGFONTW *plf )
 414 {
 415     HFONT hFont = 0;
 416
 417     if (plf)
 418     {
 419         FONTOBJ* fontPtr;
 420         if ((fontPtr = GDI_AllocObject( sizeof(FONTOBJ), FONT_MAGIC,
 421                                         (HGDIOBJ *)&hFont, &font_funcs )))
 422         {
 423             static const WCHAR ItalicW[] = {' ','I','t','a','l','i','c','\0'};
 424             static const WCHAR BoldW[]   = {' ','B','o','l','d','\0'};
 425             WCHAR *pFaceNameItalicSuffix, *pFaceNameBoldSuffix;
 426             WCHAR* pFaceNameSuffix = NULL;
 427
 428             memcpy( &fontPtr->logfont, plf, sizeof(LOGFONTW) );
 429
 430             TRACE("(%ld %ld %ld %ld %x %d %x %d %d) %s %s %s %s => %p\n",
 431                   plf->lfHeight, plf->lfWidth,
 432                   plf->lfEscapement, plf->lfOrientation,
 433                   plf->lfPitchAndFamily,
 434                   plf->lfOutPrecision, plf->lfClipPrecision,
 435                   plf->lfQuality, plf->lfCharSet,
 436                   debugstr_w(plf->lfFaceName),
 437                   plf->lfWeight > 400 ? "Bold" : "",
 438                   plf->lfItalic ? "Italic" : "",
 439                   plf->lfUnderline ? "Underline" : "", hFont);
 440
 441             if (plf->lfEscapement != plf->lfOrientation) {
 442               /* this should really depend on whether GM_ADVANCED is set */
 443               fontPtr->logfont.lfOrientation = fontPtr->logfont.lfEscapement;
 444               WARN("orientation angle %f set to "
 445                    "escapement angle %f for new font %p\n",
 446                    plf->lfOrientation/10., plf->lfEscapement/10., hFont);
 447             }
 448
 449             pFaceNameItalicSuffix = strstrW(fontPtr->logfont.lfFaceName, ItalicW);
 450             if (pFaceNameItalicSuffix) {
 451                 fontPtr->logfont.lfItalic = TRUE;
 452                 pFaceNameSuffix = pFaceNameItalicSuffix;
 453             }
 454
 455             pFaceNameBoldSuffix = strstrW(fontPtr->logfont.lfFaceName, BoldW);
 456             if (pFaceNameBoldSuffix) {
 457                 if (fontPtr->logfont.lfWeight < FW_BOLD) {
 458                     fontPtr->logfont.lfWeight = FW_BOLD;
 459                 }
 460                 if (!pFaceNameSuffix ||
 461                     (pFaceNameBoldSuffix < pFaceNameSuffix)) {
 462                     pFaceNameSuffix = pFaceNameBoldSuffix;
 463                 }
 464             }
 465
 466             if (pFaceNameSuffix) *pFaceNameSuffix = 0;
 467
 468             GDI_ReleaseObj( hFont );
 469         }
 470     }
 471     else WARN("(NULL) => NULL\n");
 472
 473     return hFont;
 474 }
 475
 476 /*************************************************************************
 477  *           CreateFontA    (GDI32.@)
 478  */
 479 HFONT WINAPI CreateFontA( INT height, INT width, INT esc,
 480                               INT orient, INT weight, DWORD italic,
 481                               DWORD underline, DWORD strikeout, DWORD charset,
 482                               DWORD outpres, DWORD clippres, DWORD quality,
 483                               DWORD pitch, LPCSTR name )
 484 {
 485     LOGFONTA logfont;
 486
 487     logfont.lfHeight = height;
 488     logfont.lfWidth = width;
 489     logfont.lfEscapement = esc;
 490     logfont.lfOrientation = orient;
 491     logfont.lfWeight = weight;
 492     logfont.lfItalic = italic;
 493     logfont.lfUnderline = underline;
 494     logfont.lfStrikeOut = strikeout;
 495     logfont.lfCharSet = charset;
 496     logfont.lfOutPrecision = outpres;
 497     logfont.lfClipPrecision = clippres;
 498     logfont.lfQuality = quality;
 499     logfont.lfPitchAndFamily = pitch;
 500
 501     if (name)
 502         lstrcpynA(logfont.lfFaceName,name,sizeof(logfont.lfFaceName));
 503     else
 504         logfont.lfFaceName[0] = '\0';
 505
 506     return CreateFontIndirectA( &logfont );
 507 }
 508
 509 /*************************************************************************
 510  *           CreateFontW    (GDI32.@)
 511  */
 512 HFONT WINAPI CreateFontW( INT height, INT width, INT esc,
 513                               INT orient, INT weight, DWORD italic,
 514                               DWORD underline, DWORD strikeout, DWORD charset,
 515                               DWORD outpres, DWORD clippres, DWORD quality,
 516                               DWORD pitch, LPCWSTR name )
 517 {
 518     LOGFONTW logfont;
 519
 520     logfont.lfHeight = height;
 521     logfont.lfWidth = width;
 522     logfont.lfEscapement = esc;
 523     logfont.lfOrientation = orient;
 524     logfont.lfWeight = weight;
 525     logfont.lfItalic = italic;
 526     logfont.lfUnderline = underline;
 527     logfont.lfStrikeOut = strikeout;
 528     logfont.lfCharSet = charset;
 529     logfont.lfOutPrecision = outpres;
 530     logfont.lfClipPrecision = clippres;
 531     logfont.lfQuality = quality;
 532     logfont.lfPitchAndFamily = pitch;
 533
 534     if (name)
 535         lstrcpynW(logfont.lfFaceName, name,
 536                   sizeof(logfont.lfFaceName) / sizeof(WCHAR));
 537     else
 538         logfont.lfFaceName[0] = '\0';
 539
 540     return CreateFontIndirectW( &logfont );
 541 }
 542
 543
 544 /***********************************************************************
 545  *           FONT_SelectObject
 546  *
 547  * If the driver supports vector fonts we create a gdi font first and
 548  * then call the driver to give it a chance to supply its own device
 549  * font.  If the driver wants to do this it returns TRUE and we can
 550  * delete the gdi font, if the driver wants to use the gdi font it
 551  * should return FALSE, to signal an error return GDI_ERROR.  For
 552  * drivers that don't support vector fonts they must supply their own
 553  * font.
 554  */
 555 static HGDIOBJ FONT_SelectObject( HGDIOBJ handle, void *obj, HDC hdc )
 556 {
 557     HGDIOBJ ret = 0;
 558     DC *dc = DC_GetDCPtr( hdc );
 559
 560     if (!dc) return 0;
 561
 562     if (dc->hFont != handle || dc->gdiFont == NULL)
 563     {
 564         if(GetDeviceCaps(dc->hSelf, TEXTCAPS) & TC_VA_ABLE)
 565             dc->gdiFont = WineEngCreateFontInstance(dc, handle);
 566     }
 567
 568     if (dc->funcs->pSelectFont) ret = dc->funcs->pSelectFont( dc->physDev, handle, dc->gdiFont );
 569
 570     if (ret && dc->gdiFont) dc->gdiFont = 0;
 571
 572     if (ret == HGDI_ERROR)
 573         ret = 0; /* SelectObject returns 0 on error */
 574     else
 575     {
 576         ret = dc->hFont;
 577         dc->hFont = handle;
 578     }
 579     GDI_ReleaseObj( hdc );
 580     return ret;
 581 }
 582
 583
 584 /***********************************************************************
 585  *           FONT_GetObject16
 586  */
 587 static INT FONT_GetObject16( HGDIOBJ handle, void *obj, INT count, LPVOID buffer )
 588 {
 589     FONTOBJ *font = obj;
 590     LOGFONT16 lf16;
 591
 592     FONT_LogFontWTo16( &font->logfont, &lf16 );
 593
 594     if (count > sizeof(LOGFONT16)) count = sizeof(LOGFONT16);
 595     memcpy( buffer, &lf16, count );
 596     return count;
 597 }
 598
 599 /***********************************************************************
 600  *           FONT_GetObjectA
 601  */
 602 static INT FONT_GetObjectA( HGDIOBJ handle, void *obj, INT count, LPVOID buffer )
 603 {
 604     FONTOBJ *font = obj;
 605     LOGFONTA lfA;
 606
 607     if(!buffer)
 608         return sizeof(lfA);
 609     FONT_LogFontWToA( &font->logfont, &lfA );
 610
 611     if (count > sizeof(lfA)) count = sizeof(lfA);
 612     memcpy( buffer, &lfA, count );
 613     return count;
 614 }
 615
 616 /***********************************************************************
 617  *           FONT_GetObjectW
 618  */
 619 static INT FONT_GetObjectW( HGDIOBJ handle, void *obj, INT count, LPVOID buffer )
 620 {
 621     FONTOBJ *font = obj;
 622     if(!buffer)
 623         return sizeof(LOGFONTW);
 624     if (count > sizeof(LOGFONTW)) count = sizeof(LOGFONTW);
 625     memcpy( buffer, &font->logfont, count );
 626     return count;
 627 }
 628
 629
 630 /***********************************************************************
 631  *           FONT_DeleteObject
 632  */
 633 static BOOL FONT_DeleteObject( HGDIOBJ handle, void *obj )
 634 {
 635     WineEngDestroyFontInstance( handle );
 636     return GDI_FreeObject( handle, obj );
 637 }
 638
 639
 640 /***********************************************************************
 641  *              FONT_EnumInstance16
 642  *
 643  * Called by the device driver layer to pass font info
 644  * down to the application.
 645  *
 646  * Note: plf is really an ENUMLOGFONTEXW, and ptm is a NEWTEXTMETRICEXW.
 647  *       We have to use other types because of the FONTENUMPROCW definition.
 648  */
 649 static INT CALLBACK FONT_EnumInstance16( const LOGFONTW *plf, const TEXTMETRICW *ptm,
 650                                          DWORD fType, LPARAM lp )
 651 {
 652     fontEnum16 *pfe = (fontEnum16*)lp;
 653     INT ret = 1;
 654     DC *dc;
 655
 656     if( pfe->lpLogFontParam->lfCharSet == DEFAULT_CHARSET ||
 657         pfe->lpLogFontParam->lfCharSet == plf->lfCharSet )
 658     {
 659         WORD args[7];
 660         DWORD result;
 661
 662         FONT_EnumLogFontExWTo16((const ENUMLOGFONTEXW *)plf, pfe->lpLogFont);
 663         FONT_NewTextMetricExWTo16((const NEWTEXTMETRICEXW *)ptm, pfe->lpTextMetric);
 664         pfe->dwFlags |= ENUM_CALLED;
 665         GDI_ReleaseObj( pfe->hdc );  /* release the GDI lock */
 666
 667         args[6] = SELECTOROF(pfe->segLogFont);
 668         args[5] = OFFSETOF(pfe->segLogFont);
 669         args[4] = SELECTOROF(pfe->segTextMetric);
 670         args[3] = OFFSETOF(pfe->segTextMetric);
 671         args[2] = fType;
 672         args[1] = HIWORD(pfe->lpData);
 673         args[0] = LOWORD(pfe->lpData);
 674         WOWCallback16Ex( (DWORD)pfe->lpEnumFunc, WCB16_PASCAL, sizeof(args), args, &result );
 675         ret = LOWORD(result);
 676
 677         /* get the lock again and make sure the DC is still valid */
 678         dc = DC_GetDCPtr( pfe->hdc );
 679         if (!dc || dc != pfe->dc || dc->physDev != pfe->physDev)
 680         {
 681             if (dc) GDI_ReleaseObj( pfe->hdc );
 682             pfe->hdc = 0;  /* make sure we don't try to release it later on */
 683             ret = 0;
 684         }
 685     }
 686     return ret;
 687 }
 688
 689 /***********************************************************************
 690  *              FONT_EnumInstance
 691  *
 692  * Note: plf is really an ENUMLOGFONTEXW, and ptm is a NEWTEXTMETRICEXW.
 693  *       We have to use other types because of the FONTENUMPROCW definition.
 694  */
 695 static INT CALLBACK FONT_EnumInstance( const LOGFONTW *plf, const TEXTMETRICW *ptm,
 696                                        DWORD fType, LPARAM lp )
 697 {
 698     fontEnum32 *pfe = (fontEnum32*)lp;
 699     INT ret = 1;
 700     DC *dc;
 701
 702     /* lfCharSet is at the same offset in both LOGFONTA and LOGFONTW */
 703     if((pfe->lpLogFontParam->lfCharSet == DEFAULT_CHARSET ||
 704         pfe->lpLogFontParam->lfCharSet == plf->lfCharSet) &&
 705        (!(fType & RASTER_FONTTYPE) || GetDeviceCaps(pfe->hdc, TEXTCAPS) & TC_RA_ABLE) )
 706     {
 707         /* convert font metrics */
 708         ENUMLOGFONTEXA logfont;
 709         NEWTEXTMETRICEXA tmA;
 710
 711         pfe->dwFlags |= ENUM_CALLED;
 712         if (!(pfe->dwFlags & ENUM_UNICODE))
 713         {
 714             FONT_EnumLogFontExWToA( (const ENUMLOGFONTEXW *)plf, &logfont);
 715             FONT_NewTextMetricExWToA( (const NEWTEXTMETRICEXW *)ptm, &tmA );
 716             plf = (LOGFONTW *)&logfont.elfLogFont;
 717             ptm = (TEXTMETRICW *)&tmA;
 718         }
 719         GDI_ReleaseObj( pfe->hdc );  /* release the GDI lock */
 720
 721         ret = pfe->lpEnumFunc( plf, ptm, fType, pfe->lpData );
 722
 723         /* get the lock again and make sure the DC is still valid */
 724         dc = DC_GetDCPtr( pfe->hdc );
 725         if (!dc || dc != pfe->dc || dc->physDev != pfe->physDev)
 726         {
 727             if (dc) GDI_ReleaseObj( pfe->hdc );
 728             pfe->hdc = 0;  /* make sure we don't try to release it later on */
 729             ret = 0;
 730         }
 731     }
 732     return ret;
 733 }
 734
 735 /***********************************************************************
 736  *              EnumFontFamiliesEx      (GDI.613)
 737  */
 738 INT16 WINAPI EnumFontFamiliesEx16( HDC16 hDC, LPLOGFONT16 plf,
 739                                    FONTENUMPROC16 efproc, LPARAM lParam,
 740                                    DWORD dwFlags)
 741 {
 742     fontEnum16 fe16;
 743     INT16       ret = 1, ret2;
 744     DC*         dc = DC_GetDCPtr( HDC_32(hDC) );
 745     NEWTEXTMETRICEX16 tm16;
 746     ENUMLOGFONTEX16 lf16;
 747     LOGFONTW lfW;
 748     BOOL enum_gdi_fonts;
 749
 750     if (!dc) return 0;
 751     FONT_LogFont16ToW(plf, &lfW);
 752
 753     fe16.hdc = HDC_32(hDC);
 754     fe16.dc = dc;
 755     fe16.physDev = dc->physDev;
 756     fe16.lpLogFontParam = plf;
 757     fe16.lpEnumFunc = efproc;
 758     fe16.lpData = lParam;
 759     fe16.lpTextMetric = &tm16;
 760     fe16.lpLogFont = &lf16;
 761     fe16.segTextMetric = MapLS( &tm16 );
 762     fe16.segLogFont = MapLS( &lf16 );
 763     fe16.dwFlags = 0;
 764
 765     enum_gdi_fonts = GetDeviceCaps(fe16.hdc, TEXTCAPS) & TC_VA_ABLE;
 766
 767     if (!dc->funcs->pEnumDeviceFonts && !enum_gdi_fonts)
 768     {
 769         ret = 0;
 770         goto done;
 771     }
 772
 773     if (enum_gdi_fonts)
 774         ret = WineEngEnumFonts( &lfW, FONT_EnumInstance16, (LPARAM)&fe16 );
 775     fe16.dwFlags &= ~ENUM_CALLED;
 776     if (ret && dc->funcs->pEnumDeviceFonts) {
 777         ret2 = dc->funcs->pEnumDeviceFonts( dc->physDev, &lfW, FONT_EnumInstance16, (LPARAM)&fe16 );
 778         if(fe16.dwFlags & ENUM_CALLED) /* update ret iff a font gets enumed */
 779             ret = ret2;
 780     }
 781 done:
 782     UnMapLS( fe16.segTextMetric );
 783     UnMapLS( fe16.segLogFont );
 784     if (fe16.hdc) GDI_ReleaseObj( fe16.hdc );
 785     return ret;
 786 }
 787
 788 /***********************************************************************
 789  *              FONT_EnumFontFamiliesEx
 790  */
 791 static INT FONT_EnumFontFamiliesEx( HDC hDC, LPLOGFONTW plf,
 792                                     FONTENUMPROCW efproc,
 793                                     LPARAM lParam, DWORD dwUnicode)
 794 {
 795     INT ret = 1, ret2;
 796     DC *dc = DC_GetDCPtr( hDC );
 797     fontEnum32 fe32;
 798     BOOL enum_gdi_fonts;
 799
 800     if (!dc) return 0;
 801
 802     TRACE("lfFaceName = %s lfCharset = %d\n", debugstr_w(plf->lfFaceName),
 803           plf->lfCharSet);
 804     fe32.lpLogFontParam = plf;
 805     fe32.lpEnumFunc = efproc;
 806     fe32.lpData = lParam;
 807     fe32.dwFlags = dwUnicode;
 808     fe32.hdc = hDC;
 809     fe32.dc = dc;
 810     fe32.physDev = dc->physDev;
 811
 812     enum_gdi_fonts = GetDeviceCaps(hDC, TEXTCAPS) & TC_VA_ABLE;
 813
 814     if (!dc->funcs->pEnumDeviceFonts && !enum_gdi_fonts)
 815     {
 816         ret = 0;
 817         goto done;
 818     }
 819
 820     if (enum_gdi_fonts)
 821         ret = WineEngEnumFonts( plf, FONT_EnumInstance, (LPARAM)&fe32 );
 822     fe32.dwFlags &= ~ENUM_CALLED;
 823     if (ret && dc->funcs->pEnumDeviceFonts) {
 824         ret2 = dc->funcs->pEnumDeviceFonts( dc->physDev, plf, FONT_EnumInstance, (LPARAM)&fe32 );
 825         if(fe32.dwFlags & ENUM_CALLED) /* update ret iff a font gets enumed */
 826             ret = ret2;
 827     }
 828  done:
 829     if (fe32.hdc) GDI_ReleaseObj( fe32.hdc );
 830     return ret;
 831 }
 832
 833 /***********************************************************************
 834  *              EnumFontFamiliesExW     (GDI32.@)
 835  */
 836 INT WINAPI EnumFontFamiliesExW( HDC hDC, LPLOGFONTW plf,
 837                                     FONTENUMPROCW efproc,
 838                                     LPARAM lParam, DWORD dwFlags )
 839 {
 840     return  FONT_EnumFontFamiliesEx( hDC, plf, efproc, lParam, ENUM_UNICODE );
 841 }
 842
 843 /***********************************************************************
 844  *              EnumFontFamiliesExA     (GDI32.@)
 845  */
 846 INT WINAPI EnumFontFamiliesExA( HDC hDC, LPLOGFONTA plf,
 847                                     FONTENUMPROCA efproc,
 848                                     LPARAM lParam, DWORD dwFlags)
 849 {
 850     LOGFONTW lfW;
 851     FONT_LogFontAToW( plf, &lfW );
 852
 853     return FONT_EnumFontFamiliesEx( hDC, &lfW, (FONTENUMPROCW)efproc, lParam, 0);
 854 }
 855
 856 /***********************************************************************
 857  *              EnumFontFamilies        (GDI.330)
 858  */
 859 INT16 WINAPI EnumFontFamilies16( HDC16 hDC, LPCSTR lpFamily,
 860                                  FONTENUMPROC16 efproc, LPARAM lpData )
 861 {
 862     LOGFONT16   lf;
 863
 864     lf.lfCharSet = DEFAULT_CHARSET;
 865     if( lpFamily ) lstrcpynA( lf.lfFaceName, lpFamily, LF_FACESIZE );
 866     else lf.lfFaceName[0] = '\0';
 867
 868     return EnumFontFamiliesEx16( hDC, &lf, efproc, lpData, 0 );
 869 }
 870
 871 /***********************************************************************
 872  *              EnumFontFamiliesA       (GDI32.@)
 873  */
 874 INT WINAPI EnumFontFamiliesA( HDC hDC, LPCSTR lpFamily,
 875                                   FONTENUMPROCA efproc, LPARAM lpData )
 876 {
 877     LOGFONTA    lf;
 878
 879     lf.lfCharSet = DEFAULT_CHARSET;
 880     if( lpFamily ) lstrcpynA( lf.lfFaceName, lpFamily, LF_FACESIZE );
 881     else lf.lfFaceName[0] = lf.lfFaceName[1] = '\0';
 882
 883     return EnumFontFamiliesExA( hDC, &lf, efproc, lpData, 0 );
 884 }
 885
 886 /***********************************************************************
 887  *              EnumFontFamiliesW       (GDI32.@)
 888  */
 889 INT WINAPI EnumFontFamiliesW( HDC hDC, LPCWSTR lpFamily,
 890                                   FONTENUMPROCW efproc, LPARAM lpData )
 891 {
 892     LOGFONTW  lf;
 893
 894     lf.lfCharSet = DEFAULT_CHARSET;
 895     if( lpFamily ) lstrcpynW( lf.lfFaceName, lpFamily, LF_FACESIZE );
 896     else lf.lfFaceName[0] = 0;
 897
 898     return EnumFontFamiliesExW( hDC, &lf, efproc, lpData, 0 );
 899 }
 900
 901 /***********************************************************************
 902  *              EnumFonts               (GDI.70)
 903  */
 904 INT16 WINAPI EnumFonts16( HDC16 hDC, LPCSTR lpName, FONTENUMPROC16 efproc,
 905                           LPARAM lpData )
 906 {
 907     return EnumFontFamilies16( hDC, lpName, efproc, lpData );
 908 }
 909
 910 /***********************************************************************
 911  *              EnumFontsA              (GDI32.@)
 912  */
 913 INT WINAPI EnumFontsA( HDC hDC, LPCSTR lpName, FONTENUMPROCA efproc,
 914                            LPARAM lpData )
 915 {
 916     return EnumFontFamiliesA( hDC, lpName, efproc, lpData );
 917 }
 918
 919 /***********************************************************************
 920  *              EnumFontsW              (GDI32.@)
 921  */
 922 INT WINAPI EnumFontsW( HDC hDC, LPCWSTR lpName, FONTENUMPROCW efproc,
 923                            LPARAM lpData )
 924 {
 925     return EnumFontFamiliesW( hDC, lpName, efproc, lpData );
 926 }
 927
 928
 929 /***********************************************************************
 930  *           GetTextCharacterExtra    (GDI32.@)
 931  */
 932 INT WINAPI GetTextCharacterExtra( HDC hdc )
 933 {
 934     INT ret;
 935     DC *dc = DC_GetDCPtr( hdc );
 936     if (!dc) return 0x80000000;
 937     ret = dc->charExtra;
 938     GDI_ReleaseObj( hdc );
 939     return ret;
 940 }
 941
 942
 943 /***********************************************************************
 944  *           SetTextCharacterExtra    (GDI32.@)
 945  */
 946 INT WINAPI SetTextCharacterExtra( HDC hdc, INT extra )
 947 {
 948     INT prev;
 949     DC * dc = DC_GetDCPtr( hdc );
 950     if (!dc) return 0x80000000;
 951     if (dc->funcs->pSetTextCharacterExtra)
 952         prev = dc->funcs->pSetTextCharacterExtra( dc->physDev, extra );
 953     else
 954     {
 955         prev = dc->charExtra;
 956         dc->charExtra = extra;
 957     }
 958     GDI_ReleaseObj( hdc );
 959     return prev;
 960 }
 961
 962
 963 /***********************************************************************
 964  *           SetTextJustification    (GDI32.@)
 965  */
 966 BOOL WINAPI SetTextJustification( HDC hdc, INT extra, INT breaks )
 967 {
 968     BOOL ret = TRUE;
 969     DC * dc = DC_GetDCPtr( hdc );
 970     if (!dc) return FALSE;
 971     if (dc->funcs->pSetTextJustification)
 972         ret = dc->funcs->pSetTextJustification( dc->physDev, extra, breaks );
 973     else
 974     {
 975         extra = abs((extra * dc->vportExtX + dc->wndExtX / 2) / dc->wndExtX);
 976         if (!extra) breaks = 0;
 977         if (breaks)
 978         {
 979             dc->breakExtra = extra / breaks;
 980             dc->breakRem   = extra - (breaks * dc->breakExtra);
 981         }
 982         else
 983         {
 984             dc->breakExtra = 0;
 985             dc->breakRem   = 0;
 986         }
 987     }
 988     GDI_ReleaseObj( hdc );
 989     return ret;
 990 }
 991
 992
 993 /***********************************************************************
 994  *           GetTextFaceA    (GDI32.@)
 995  */
 996 INT WINAPI GetTextFaceA( HDC hdc, INT count, LPSTR name )
 997 {
 998     INT res = GetTextFaceW(hdc, 0, NULL);
 999     LPWSTR nameW = HeapAlloc( GetProcessHeap(), 0, res * 2 );
1000     GetTextFaceW( hdc, res, nameW );
1001
1002     if (name)
1003     {
1004         if (count && !WideCharToMultiByte( CP_ACP, 0, nameW, -1, name, count, NULL, NULL))
1005             name[count-1] = 0;
1006         res = strlen(name);
1007     }
1008     else
1009         res = WideCharToMultiByte( CP_ACP, 0, nameW, -1, NULL, 0, NULL, NULL);
1010     HeapFree( GetProcessHeap(), 0, nameW );
1011     return res;
1012 }
1013
1014 /***********************************************************************
1015  *           GetTextFaceW    (GDI32.@)
1016  */
1017 INT WINAPI GetTextFaceW( HDC hdc, INT count, LPWSTR name )
1018 {
1019     FONTOBJ *font;
1020     INT     ret = 0;
1021
1022     DC * dc = DC_GetDCPtr( hdc );
1023     if (!dc) return 0;
1024
1025     if(dc->gdiFont)
1026         ret = WineEngGetTextFace(dc->gdiFont, count, name);
1027     else if ((font = (FONTOBJ *) GDI_GetObjPtr( dc->hFont, FONT_MAGIC )))
1028     {
1029         if (name)
1030         {
1031             lstrcpynW( name, font->logfont.lfFaceName, count );
1032             ret = strlenW(name);
1033         }
1034         else ret = strlenW(font->logfont.lfFaceName) + 1;
1035         GDI_ReleaseObj( dc->hFont );
1036     }
1037     GDI_ReleaseObj( hdc );
1038     return ret;
1039 }
1040
1041
1042 /***********************************************************************
1043  *           GetTextExtentPoint32A    (GDI32.@)
1044  */
1045 BOOL WINAPI GetTextExtentPoint32A( HDC hdc, LPCSTR str, INT count,
1046                                      LPSIZE size )
1047 {
1048     BOOL ret = FALSE;
1049     INT wlen;
1050     LPWSTR p = FONT_mbtowc(hdc, str, count, &wlen, NULL);
1051
1052     if (p) {
1053         ret = GetTextExtentPoint32W( hdc, p, wlen, size );
1054         HeapFree( GetProcessHeap(), 0, p );
1055     }
1056
1057     TRACE("(%p %s %d %p): returning %ld x %ld\n",
1058           hdc, debugstr_an (str, count), count, size, size->cx, size->cy );
1059     return ret;
1060 }
1061
1062
1063 /***********************************************************************
1064  * GetTextExtentPoint32W [GDI32.@]
1065  *
1066  * Computes width/height for a string.
1067  *
1068  * Computes width and height of the specified string.
1069  *
1070  * RETURNS
1071  *    Success: TRUE
1072  *    Failure: FALSE
1073  */
1074 BOOL WINAPI GetTextExtentPoint32W(
1075     HDC hdc,     /* [in]  Handle of device context */
1076     LPCWSTR str,   /* [in]  Address of text string */
1077     INT count,   /* [in]  Number of characters in string */
1078     LPSIZE size) /* [out] Address of structure for string size */
1079 {
1080     BOOL ret = FALSE;
1081     DC * dc = DC_GetDCPtr( hdc );
1082     if (!dc) return FALSE;
1083
1084     if(dc->gdiFont)
1085         ret = WineEngGetTextExtentPoint(dc->gdiFont, str, count, size);
1086     else if(dc->funcs->pGetTextExtentPoint)
1087         ret = dc->funcs->pGetTextExtentPoint( dc->physDev, str, count, size );
1088
1089     if (ret)
1090     {
1091         size->cx = abs(INTERNAL_XDSTOWS(dc, size->cx));
1092         size->cy = abs(INTERNAL_YDSTOWS(dc, size->cy));
1093         size->cx += count * dc->charExtra + dc->breakRem;
1094     }
1095
1096     GDI_ReleaseObj( hdc );
1097
1098     TRACE("(%p %s %d %p): returning %ld x %ld\n",
1099           hdc, debugstr_wn (str, count), count, size, size->cx, size->cy );
1100     return ret;
1101 }
1102
1103 /***********************************************************************
1104  * GetTextExtentPointI [GDI32.@]
1105  *
1106  * Computes width and height of the array of glyph indices.
1107  *
1108  * RETURNS
1109  *    Success: TRUE
1110  *    Failure: FALSE
1111  */
1112 BOOL WINAPI GetTextExtentPointI(
1113     HDC hdc,     /* [in]  Handle of device context */
1114     const WORD *indices,   /* [in]  Address of glyph index array */
1115     INT count,   /* [in]  Number of glyphs in array */
1116     LPSIZE size) /* [out] Address of structure for string size */
1117 {
1118     BOOL ret = FALSE;
1119     DC * dc = DC_GetDCPtr( hdc );
1120     if (!dc) return FALSE;
1121
1122     if(dc->gdiFont) {
1123         ret = WineEngGetTextExtentPointI(dc->gdiFont, indices, count, size);
1124         size->cx = abs(INTERNAL_XDSTOWS(dc, size->cx));
1125         size->cy = abs(INTERNAL_YDSTOWS(dc, size->cy));
1126         size->cx += count * dc->charExtra;
1127     }
1128     else if(dc->funcs->pGetTextExtentPoint) {
1129         FIXME("calling GetTextExtentPoint\n");
1130         ret = dc->funcs->pGetTextExtentPoint( dc->physDev, (LPCWSTR)indices, count, size );
1131     }
1132
1133     GDI_ReleaseObj( hdc );
1134
1135     TRACE("(%p %p %d %p): returning %ld x %ld\n",
1136           hdc, indices, count, size, size->cx, size->cy );
1137     return ret;
1138 }
1139
1140
1141 /***********************************************************************
1142  *           GetTextExtentPointA    (GDI32.@)
1143  */
1144 BOOL WINAPI GetTextExtentPointA( HDC hdc, LPCSTR str, INT count,
1145                                           LPSIZE size )
1146 {
1147     TRACE("not bug compatible.\n");
1148     return GetTextExtentPoint32A( hdc, str, count, size );
1149 }
1150
1151 /***********************************************************************
1152  *           GetTextExtentPointW   (GDI32.@)
1153  */
1154 BOOL WINAPI GetTextExtentPointW( HDC hdc, LPCWSTR str, INT count,
1155                                           LPSIZE size )
1156 {
1157     TRACE("not bug compatible.\n");
1158     return GetTextExtentPoint32W( hdc, str, count, size );
1159 }
1160
1161
1162 /***********************************************************************
1163  *           GetTextExtentExPointA    (GDI32.@)
1164  */
1165 BOOL WINAPI GetTextExtentExPointA( HDC hdc, LPCSTR str, INT count,
1166                                    INT maxExt, LPINT lpnFit,
1167                                    LPINT alpDx, LPSIZE size )
1168 {
1169     BOOL ret;
1170     INT wlen;
1171     LPWSTR p = FONT_mbtowc( hdc, str, count, &wlen, NULL);
1172     ret = GetTextExtentExPointW( hdc, p, wlen, maxExt, lpnFit, alpDx, size);
1173     if (lpnFit) *lpnFit = WideCharToMultiByte(CP_ACP,0,p,*lpnFit,NULL,0,NULL,NULL);
1174     HeapFree( GetProcessHeap(), 0, p );
1175     return ret;
1176 }
1177
1178
1179 /***********************************************************************
1180  *           GetTextExtentExPointW    (GDI32.@)
1181  *
1182  * Return the size of the string as it would be if it was output properly by
1183  * e.g. TextOut.
1184  *
1185  * This should include
1186  * - Intercharacter spacing
1187  * - justification spacing (not yet done)
1188  * - kerning? see below
1189  *
1190  * Kerning.  Since kerning would be carried out by the rendering code it should
1191  * be done by the driver.  However they don't support it yet.  Also I am not
1192  * yet persuaded that (certainly under Win95) any kerning is actually done.
1193  *
1194  * str: According to MSDN this should be null-terminated.  That is not true; a
1195  *      null will not terminate it early.
1196  * size: Certainly under Win95 this appears buggy or weird if *lpnFit is less
1197  *       than count.  I have seen it be either the size of the full string or
1198  *       1 less than the size of the full string.  I have not seen it bear any
1199  *       resemblance to the portion that would fit.
1200  * lpnFit: What exactly is fitting?  Stupidly, in my opinion, it includes the
1201  *         trailing intercharacter spacing and any trailing justification.
1202  *
1203  * FIXME
1204  * Currently we do this by measuring each character etc.  We should do it by
1205  * passing the request to the driver, perhaps by extending the
1206  * pGetTextExtentPoint function to take the alpDx argument.  That would avoid
1207  * thinking about kerning issues and rounding issues in the justification.
1208  */
1209
1210 BOOL WINAPI GetTextExtentExPointW( HDC hdc, LPCWSTR str, INT count,
1211                                    INT maxExt, LPINT lpnFit,
1212                                    LPINT alpDx, LPSIZE size )
1213 {
1214     int index, nFit, extent;
1215     SIZE tSize;
1216     BOOL ret = FALSE;
1217
1218     TRACE("(%p, %s, %d)\n",hdc,debugstr_wn(str,count),maxExt);
1219
1220     size->cx = size->cy = nFit = extent = 0;
1221     for(index = 0; index < count; index++)
1222     {
1223         if(!GetTextExtentPoint32W( hdc, str, 1, &tSize )) goto done;
1224         /* GetTextExtentPoint includes intercharacter spacing. */
1225         /* FIXME - justification needs doing yet.  Remember that the base
1226          * data will not be in logical coordinates.
1227          */
1228         extent += tSize.cx;
1229         if( !lpnFit || extent <= maxExt )
1230         /* It is allowed to be equal. */
1231         {
1232             nFit++;
1233             if( alpDx ) alpDx[index] = extent;
1234         }
1235         if( tSize.cy > size->cy ) size->cy = tSize.cy;
1236         str++;
1237     }
1238     size->cx = extent;
1239     if(lpnFit) *lpnFit = nFit;
1240     ret = TRUE;
1241
1242     TRACE("returning %d %ld x %ld\n",nFit,size->cx,size->cy);
1243
1244 done:
1245     return ret;
1246 }
1247
1248 /***********************************************************************
1249  *           GetTextMetricsA    (GDI32.@)
1250  */
1251 BOOL WINAPI GetTextMetricsA( HDC hdc, TEXTMETRICA *metrics )
1252 {
1253     TEXTMETRICW tm32;
1254
1255     if (!GetTextMetricsW( hdc, &tm32 )) return FALSE;
1256     FONT_TextMetricWToA( &tm32, metrics );
1257     return TRUE;
1258 }
1259
1260 /***********************************************************************
1261  *           GetTextMetricsW    (GDI32.@)
1262  */
1263 BOOL WINAPI GetTextMetricsW( HDC hdc, TEXTMETRICW *metrics )
1264 {
1265     BOOL ret = FALSE;
1266     DC * dc = DC_GetDCPtr( hdc );
1267     if (!dc) return FALSE;
1268
1269     if (dc->gdiFont)
1270         ret = WineEngGetTextMetrics(dc->gdiFont, metrics);
1271     else if (dc->funcs->pGetTextMetrics)
1272         ret = dc->funcs->pGetTextMetrics( dc->physDev, metrics );
1273
1274     if (ret)
1275     {
1276     /* device layer returns values in device units
1277      * therefore we have to convert them to logical */
1278
1279 #define WDPTOLP(x) ((x<0)?                                      \
1280                 (-abs(INTERNAL_XDSTOWS(dc, (x)))):              \
1281                 (abs(INTERNAL_XDSTOWS(dc, (x)))))
1282 #define HDPTOLP(y) ((y<0)?                                      \
1283                 (-abs(INTERNAL_YDSTOWS(dc, (y)))):              \
1284                 (abs(INTERNAL_YDSTOWS(dc, (y)))))
1285
1286     metrics->tmHeight           = HDPTOLP(metrics->tmHeight);
1287     metrics->tmAscent           = HDPTOLP(metrics->tmAscent);
1288     metrics->tmDescent          = HDPTOLP(metrics->tmDescent);
1289     metrics->tmInternalLeading  = HDPTOLP(metrics->tmInternalLeading);
1290     metrics->tmExternalLeading  = HDPTOLP(metrics->tmExternalLeading);
1291     metrics->tmAveCharWidth     = WDPTOLP(metrics->tmAveCharWidth);
1292     metrics->tmMaxCharWidth     = WDPTOLP(metrics->tmMaxCharWidth);
1293     metrics->tmOverhang         = WDPTOLP(metrics->tmOverhang);
1294         ret = TRUE;
1295 #undef WDPTOLP
1296 #undef HDPTOLP
1297     TRACE("text metrics:\n"
1298           "    Weight = %03li\t FirstChar = %i\t AveCharWidth = %li\n"
1299           "    Italic = % 3i\t LastChar = %i\t\t MaxCharWidth = %li\n"
1300           "    UnderLined = %01i\t DefaultChar = %i\t Overhang = %li\n"
1301           "    StruckOut = %01i\t BreakChar = %i\t CharSet = %i\n"
1302           "    PitchAndFamily = %02x\n"
1303           "    --------------------\n"
1304           "    InternalLeading = %li\n"
1305           "    Ascent = %li\n"
1306           "    Descent = %li\n"
1307           "    Height = %li\n",
1308           metrics->tmWeight, metrics->tmFirstChar, metrics->tmAveCharWidth,
1309           metrics->tmItalic, metrics->tmLastChar, metrics->tmMaxCharWidth,
1310           metrics->tmUnderlined, metrics->tmDefaultChar, metrics->tmOverhang,
1311           metrics->tmStruckOut, metrics->tmBreakChar, metrics->tmCharSet,
1312           metrics->tmPitchAndFamily,
1313           metrics->tmInternalLeading,
1314           metrics->tmAscent,
1315           metrics->tmDescent,
1316           metrics->tmHeight );
1317     }
1318     GDI_ReleaseObj( hdc );
1319     return ret;
1320 }
1321
1322
1323 /***********************************************************************
1324  * GetOutlineTextMetrics [GDI.308]  Gets metrics for TrueType fonts.
1325  *
1326  * NOTES
1327  *    lpOTM should be LPOUTLINETEXTMETRIC
1328  *
1329  * RETURNS
1330  *    Success: Non-zero or size of required buffer
1331  *    Failure: 0
1332  */
1333 UINT16 WINAPI GetOutlineTextMetrics16(
1334     HDC16 hdc,    /* [in]  Handle of device context */
1335     UINT16 cbData, /* [in]  Size of metric data array */
1336     LPOUTLINETEXTMETRIC16 lpOTM)  /* [out] Address of metric data array */
1337 {
1338     FIXME("(%04x,%04x,%p): stub\n", hdc,cbData,lpOTM);
1339     return 0;
1340 }
1341
1342
1343 /***********************************************************************
1344  *              GetOutlineTextMetricsA (GDI32.@)
1345  * Gets metrics for TrueType fonts.
1346  *
1347  * NOTES
1348  *    If the supplied buffer isn't big enough Windows partially fills it up to
1349  *    its given length and returns that length.
1350  *
1351  * RETURNS
1352  *    Success: Non-zero or size of required buffer
1353  *    Failure: 0
1354  */
1355 UINT WINAPI GetOutlineTextMetricsA(
1356     HDC hdc,    /* [in]  Handle of device context */
1357     UINT cbData, /* [in]  Size of metric data array */
1358     LPOUTLINETEXTMETRICA lpOTM)  /* [out] Address of metric data array */
1359 {
1360     char buf[512], *ptr;
1361     UINT ret, needed;
1362     OUTLINETEXTMETRICW *lpOTMW = (OUTLINETEXTMETRICW *)buf;
1363     OUTLINETEXTMETRICA *output = lpOTM;
1364     INT left, len;
1365
1366     if((ret = GetOutlineTextMetricsW(hdc, 0, NULL)) == 0)
1367         return 0;
1368     if(ret > sizeof(buf))
1369         lpOTMW = HeapAlloc(GetProcessHeap(), 0, ret);
1370     GetOutlineTextMetricsW(hdc, ret, lpOTMW);
1371
1372     needed = sizeof(OUTLINETEXTMETRICA);
1373     if(lpOTMW->otmpFamilyName)
1374         needed += WideCharToMultiByte(CP_ACP, 0,
1375            (WCHAR*)((char*)lpOTMW + (ptrdiff_t)lpOTMW->otmpFamilyName), -1,
1376                                       NULL, 0, NULL, NULL);
1377     if(lpOTMW->otmpFaceName)
1378         needed += WideCharToMultiByte(CP_ACP, 0,
1379            (WCHAR*)((char*)lpOTMW + (ptrdiff_t)lpOTMW->otmpFaceName), -1,
1380                                       NULL, 0, NULL, NULL);
1381     if(lpOTMW->otmpStyleName)
1382         needed += WideCharToMultiByte(CP_ACP, 0,
1383            (WCHAR*)((char*)lpOTMW + (ptrdiff_t)lpOTMW->otmpStyleName), -1,
1384                                       NULL, 0, NULL, NULL);
1385     if(lpOTMW->otmpFullName)
1386         needed += WideCharToMultiByte(CP_ACP, 0,
1387            (WCHAR*)((char*)lpOTMW + (ptrdiff_t)lpOTMW->otmpFullName), -1,
1388                                       NULL, 0, NULL, NULL);
1389
1390     if(!lpOTM) {
1391         ret = needed;
1392         goto end;
1393     }
1394
1395     TRACE("needed = %d\n", needed);
1396     if(needed > cbData)
1397         /* Since the supplied buffer isn't big enough, we'll alloc one
1398            that is and memcpy the first cbData bytes into the lpOTM at
1399            the end. */
1400         output = HeapAlloc(GetProcessHeap(), 0, needed);
1401
1402     ret = output->otmSize = min(needed, cbData);
1403     FONT_TextMetricWToA( &lpOTMW->otmTextMetrics, &output->otmTextMetrics );
1404     output->otmFiller = 0;
1405     output->otmPanoseNumber = lpOTMW->otmPanoseNumber;
1406     output->otmfsSelection = lpOTMW->otmfsSelection;
1407     output->otmfsType = lpOTMW->otmfsType;
1408     output->otmsCharSlopeRise = lpOTMW->otmsCharSlopeRise;
1409     output->otmsCharSlopeRun = lpOTMW->otmsCharSlopeRun;
1410     output->otmItalicAngle = lpOTMW->otmItalicAngle;
1411     output->otmEMSquare = lpOTMW->otmEMSquare;
1412     output->otmAscent = lpOTMW->otmAscent;
1413     output->otmDescent = lpOTMW->otmDescent;
1414     output->otmLineGap = lpOTMW->otmLineGap;
1415     output->otmsCapEmHeight = lpOTMW->otmsCapEmHeight;
1416     output->otmsXHeight = lpOTMW->otmsXHeight;
1417     output->otmrcFontBox = lpOTMW->otmrcFontBox;
1418     output->otmMacAscent = lpOTMW->otmMacAscent;
1419     output->otmMacDescent = lpOTMW->otmMacDescent;
1420     output->otmMacLineGap = lpOTMW->otmMacLineGap;
1421     output->otmusMinimumPPEM = lpOTMW->otmusMinimumPPEM;
1422     output->otmptSubscriptSize = lpOTMW->otmptSubscriptSize;
1423     output->otmptSubscriptOffset = lpOTMW->otmptSubscriptOffset;
1424     output->otmptSuperscriptSize = lpOTMW->otmptSuperscriptSize;
1425     output->otmptSuperscriptOffset = lpOTMW->otmptSuperscriptOffset;
1426     output->otmsStrikeoutSize = lpOTMW->otmsStrikeoutSize;
1427     output->otmsStrikeoutPosition = lpOTMW->otmsStrikeoutPosition;
1428     output->otmsUnderscoreSize = lpOTMW->otmsUnderscoreSize;
1429     output->otmsUnderscorePosition = lpOTMW->otmsUnderscorePosition;
1430
1431
1432     ptr = (char*)(output + 1);
1433     left = needed - sizeof(*output);
1434
1435     if(lpOTMW->otmpFamilyName) {
1436         output->otmpFamilyName = (LPSTR)(ptr - (char*)output);
1437         len = WideCharToMultiByte(CP_ACP, 0,
1438              (WCHAR*)((char*)lpOTMW + (ptrdiff_t)lpOTMW->otmpFamilyName), -1,
1439                                   ptr, left, NULL, NULL);
1440         left -= len;
1441         ptr += len;
1442     } else
1443         output->otmpFamilyName = 0;
1444
1445     if(lpOTMW->otmpFaceName) {
1446         output->otmpFaceName = (LPSTR)(ptr - (char*)output);
1447         len = WideCharToMultiByte(CP_ACP, 0,
1448              (WCHAR*)((char*)lpOTMW + (ptrdiff_t)lpOTMW->otmpFaceName), -1,
1449                                   ptr, left, NULL, NULL);
1450         left -= len;
1451         ptr += len;
1452     } else
1453         output->otmpFaceName = 0;
1454
1455     if(lpOTMW->otmpStyleName) {
1456         output->otmpStyleName = (LPSTR)(ptr - (char*)output);
1457         len = WideCharToMultiByte(CP_ACP, 0,
1458              (WCHAR*)((char*)lpOTMW + (ptrdiff_t)lpOTMW->otmpStyleName), -1,
1459                                   ptr, left, NULL, NULL);
1460         left -= len;
1461         ptr += len;
1462     } else
1463         output->otmpStyleName = 0;
1464
1465     if(lpOTMW->otmpFullName) {
1466         output->otmpFullName = (LPSTR)(ptr - (char*)output);
1467         len = WideCharToMultiByte(CP_ACP, 0,
1468              (WCHAR*)((char*)lpOTMW + (ptrdiff_t)lpOTMW->otmpFullName), -1,
1469                                   ptr, left, NULL, NULL);
1470         left -= len;
1471     } else
1472         output->otmpFullName = 0;
1473
1474     assert(left == 0);
1475
1476     if(output != lpOTM) {
1477         memcpy(lpOTM, output, cbData);
1478         HeapFree(GetProcessHeap(), 0, output);
1479     }
1480
1481 end:
1482     if(lpOTMW != (OUTLINETEXTMETRICW *)buf)
1483         HeapFree(GetProcessHeap(), 0, lpOTMW);
1484
1485     return ret;
1486 }
1487
1488
1489 /***********************************************************************
1490  *           GetOutlineTextMetricsW [GDI32.@]
1491  */
1492 UINT WINAPI GetOutlineTextMetricsW(
1493     HDC hdc,    /* [in]  Handle of device context */
1494     UINT cbData, /* [in]  Size of metric data array */
1495     LPOUTLINETEXTMETRICW lpOTM)  /* [out] Address of metric data array */
1496 {
1497     DC *dc = DC_GetDCPtr( hdc );
1498     OUTLINETEXTMETRICW *output = lpOTM;
1499     UINT ret;
1500
1501     TRACE("(%p,%d,%p)\n", hdc, cbData, lpOTM);
1502     if(!dc) return 0;
1503
1504     if(dc->gdiFont) {
1505         ret = WineEngGetOutlineTextMetrics(dc->gdiFont, cbData, output);
1506         if(lpOTM && ret) {
1507             if(ret > cbData) {
1508                 output = HeapAlloc(GetProcessHeap(), 0, ret);
1509                 WineEngGetOutlineTextMetrics(dc->gdiFont, ret, output);
1510             }
1511
1512 #define WDPTOLP(x) ((x<0)?                                      \
1513                 (-abs(INTERNAL_XDSTOWS(dc, (x)))):              \
1514                 (abs(INTERNAL_XDSTOWS(dc, (x)))))
1515 #define HDPTOLP(y) ((y<0)?                                      \
1516                 (-abs(INTERNAL_YDSTOWS(dc, (y)))):              \
1517                 (abs(INTERNAL_YDSTOWS(dc, (y)))))
1518
1519             output->otmTextMetrics.tmHeight           = HDPTOLP(output->otmTextMetrics.tmHeight);
1520             output->otmTextMetrics.tmAscent           = HDPTOLP(output->otmTextMetrics.tmAscent);
1521             output->otmTextMetrics.tmDescent          = HDPTOLP(output->otmTextMetrics.tmDescent);
1522             output->otmTextMetrics.tmInternalLeading  = HDPTOLP(output->otmTextMetrics.tmInternalLeading);
1523             output->otmTextMetrics.tmExternalLeading  = HDPTOLP(output->otmTextMetrics.tmExternalLeading);
1524             output->otmTextMetrics.tmAveCharWidth     = WDPTOLP(output->otmTextMetrics.tmAveCharWidth);
1525             output->otmTextMetrics.tmMaxCharWidth     = WDPTOLP(output->otmTextMetrics.tmMaxCharWidth);
1526             output->otmTextMetrics.tmOverhang         = WDPTOLP(output->otmTextMetrics.tmOverhang);
1527             output->otmAscent = HDPTOLP(output->otmAscent);
1528             output->otmDescent = HDPTOLP(output->otmDescent);
1529             output->otmLineGap = HDPTOLP(output->otmLineGap);
1530             output->otmsCapEmHeight = HDPTOLP(output->otmsCapEmHeight);
1531             output->otmsXHeight = HDPTOLP(output->otmsXHeight);
1532             output->otmrcFontBox.top = HDPTOLP(output->otmrcFontBox.top);
1533             output->otmrcFontBox.bottom = HDPTOLP(output->otmrcFontBox.bottom);
1534             output->otmrcFontBox.left = WDPTOLP(output->otmrcFontBox.left);
1535             output->otmrcFontBox.right = WDPTOLP(output->otmrcFontBox.right);
1536             output->otmMacAscent = HDPTOLP(output->otmMacAscent);
1537             output->otmMacDescent = HDPTOLP(output->otmMacDescent);
1538             output->otmMacLineGap = HDPTOLP(output->otmMacLineGap);
1539             output->otmptSubscriptSize.x = WDPTOLP(output->otmptSubscriptSize.x);
1540             output->otmptSubscriptSize.y = HDPTOLP(output->otmptSubscriptSize.y);
1541             output->otmptSubscriptOffset.x = WDPTOLP(output->otmptSubscriptOffset.x);
1542             output->otmptSubscriptOffset.y = HDPTOLP(output->otmptSubscriptOffset.y);
1543             output->otmptSuperscriptSize.x = WDPTOLP(output->otmptSuperscriptSize.x);
1544             output->otmptSuperscriptSize.y = HDPTOLP(output->otmptSuperscriptSize.y);
1545             output->otmptSuperscriptOffset.x = WDPTOLP(output->otmptSuperscriptOffset.x);
1546             output->otmptSuperscriptOffset.y = HDPTOLP(output->otmptSuperscriptOffset.y);
1547             output->otmsStrikeoutSize = HDPTOLP(output->otmsStrikeoutSize);
1548             output->otmsStrikeoutPosition = HDPTOLP(output->otmsStrikeoutPosition);
1549             output->otmsUnderscoreSize = HDPTOLP(output->otmsUnderscoreSize);
1550             output->otmsUnderscorePosition = HDPTOLP(output->otmsUnderscorePosition);
1551 #undef WDPTOLP
1552 #undef HDPTOLP
1553             if(output != lpOTM) {
1554                 memcpy(lpOTM, output, cbData);
1555                 HeapFree(GetProcessHeap(), 0, output);
1556                 ret = cbData;
1557             }
1558         }
1559     }
1560
1561     else { /* This stuff was in GetOutlineTextMetricsA, I've moved it here
1562               but really this should just be a return 0. */
1563
1564         ret = sizeof(*lpOTM);
1565         if (lpOTM) {
1566             if(cbData < ret)
1567                 ret = 0;
1568             else {
1569                 memset(lpOTM, 0, ret);
1570                 lpOTM->otmSize = sizeof(*lpOTM);
1571                 GetTextMetricsW(hdc, &lpOTM->otmTextMetrics);
1572                 /*
1573                   Further fill of the structure not implemented,
1574                   Needs real values for the structure members
1575                 */
1576             }
1577         }
1578     }
1579     GDI_ReleaseObj(hdc);
1580     return ret;
1581 }
1582
1583
1584 /***********************************************************************
1585  *           GetCharWidthW      (GDI32.@)
1586  *           GetCharWidth32W    (GDI32.@)
1587  */
1588 BOOL WINAPI GetCharWidth32W( HDC hdc, UINT firstChar, UINT lastChar,
1589                                LPINT buffer )
1590 {
1591     UINT i;
1592     BOOL ret = FALSE;
1593     DC * dc = DC_GetDCPtr( hdc );
1594     if (!dc) return FALSE;
1595
1596     if (dc->gdiFont)
1597         ret = WineEngGetCharWidth( dc->gdiFont, firstChar, lastChar, buffer );
1598     else if (dc->funcs->pGetCharWidth)
1599         ret = dc->funcs->pGetCharWidth( dc->physDev, firstChar, lastChar, buffer);
1600
1601     if (ret)
1602     {
1603         /* convert device units to logical */
1604         for( i = firstChar; i <= lastChar; i++, buffer++ )
1605             *buffer = INTERNAL_XDSTOWS(dc, *buffer);
1606         ret = TRUE;
1607     }
1608     GDI_ReleaseObj( hdc );
1609     return ret;
1610 }
1611
1612
1613 /***********************************************************************
1614  *           GetCharWidthA      (GDI32.@)
1615  *           GetCharWidth32A    (GDI32.@)
1616  */
1617 BOOL WINAPI GetCharWidth32A( HDC hdc, UINT firstChar, UINT lastChar,
1618                                LPINT buffer )
1619 {
1620     INT i, wlen, count = (INT)(lastChar - firstChar + 1);
1621     LPSTR str;
1622     LPWSTR wstr;
1623     BOOL ret = TRUE;
1624
1625     if(count <= 0) return FALSE;
1626
1627     str = HeapAlloc(GetProcessHeap(), 0, count);
1628     for(i = 0; i < count; i++)
1629         str[i] = (BYTE)(firstChar + i);
1630
1631     wstr = FONT_mbtowc(hdc, str, count, &wlen, NULL);
1632
1633     for(i = 0; i < wlen; i++)
1634     {
1635         if(!GetCharWidth32W(hdc, wstr[i], wstr[i], buffer))
1636         {
1637             ret = FALSE;
1638             break;
1639         }
1640         buffer++;
1641     }
1642
1643     HeapFree(GetProcessHeap(), 0, str);
1644     HeapFree(GetProcessHeap(), 0, wstr);
1645
1646     return ret;
1647 }
1648
1649
1650 /***********************************************************************
1651  *           ExtTextOutA    (GDI32.@)
1652  */
1653 BOOL WINAPI ExtTextOutA( HDC hdc, INT x, INT y, UINT flags,
1654                          const RECT *lprect, LPCSTR str, UINT count, const INT *lpDx )
1655 {
1656     INT wlen;
1657     UINT codepage;
1658     LPWSTR p = FONT_mbtowc(hdc, str, count, &wlen, &codepage);
1659     BOOL ret;
1660     LPINT lpDxW = NULL;
1661
1662     if (lpDx) {
1663         unsigned int i = 0, j = 0;
1664
1665         lpDxW = (LPINT)HeapAlloc( GetProcessHeap(), 0, wlen*sizeof(INT));
1666         while(i < count) {
1667             if(IsDBCSLeadByteEx(codepage, str[i])) {
1668                 lpDxW[j++] = lpDx[i] + lpDx[i+1];
1669                 i = i + 2;
1670             } else {
1671                 lpDxW[j++] = lpDx[i];
1672                 i = i + 1;
1673             }
1674         }
1675     }
1676
1677     ret = ExtTextOutW( hdc, x, y, flags, lprect, p, wlen, lpDxW );
1678
1679     HeapFree( GetProcessHeap(), 0, p );
1680     if (lpDxW) HeapFree( GetProcessHeap(), 0, lpDxW );
1681     return ret;
1682 }
1683
1684
1685 /***********************************************************************
1686  *           ExtTextOutW    (GDI32.@)
1687  */
1688 BOOL WINAPI ExtTextOutW( HDC hdc, INT x, INT y, UINT flags,
1689                          const RECT *lprect, LPCWSTR str, UINT count, const INT *lpDx )
1690 {
1691     BOOL ret = FALSE;
1692     DC * dc = DC_GetDCUpdate( hdc );
1693     if (dc)
1694     {
1695         if(PATH_IsPathOpen(dc->path))
1696             FIXME("called on an open path\n");
1697         else if(dc->funcs->pExtTextOut)
1698         {
1699             if( !(flags&(ETO_GLYPH_INDEX|ETO_IGNORELANGUAGE)) && BidiAvail && count>0 )
1700             {
1701                 /* The caller did not specify that language processing was already done.
1702                  */
1703                 LPWSTR lpReorderedString=HeapAlloc(GetProcessHeap(), 0, count*sizeof(WCHAR));
1704
1705                 BIDI_Reorder( str, count, GCP_REORDER,
1706                               ((flags&ETO_RTLREADING)!=0 || (GetTextAlign(hdc)&TA_RTLREADING)!=0)?
1707                               WINE_GCPW_FORCE_RTL:WINE_GCPW_FORCE_LTR,
1708                               lpReorderedString, count, NULL );
1709
1710                 ret = dc->funcs->pExtTextOut(dc->physDev,x,y,flags|ETO_IGNORELANGUAGE,
1711                                              lprect,lpReorderedString,count,lpDx,dc->breakExtra);
1712                 HeapFree(GetProcessHeap(), 0, lpReorderedString);
1713             } else
1714                 ret = dc->funcs->pExtTextOut(dc->physDev,x,y,flags,lprect,str,count,
1715                                              lpDx,dc->breakExtra);
1716         }
1717         GDI_ReleaseObj( hdc );
1718     }
1719     return ret;
1720 }
1721
1722
1723 /***********************************************************************
1724  *           TextOutA    (GDI32.@)
1725  */
1726 BOOL WINAPI TextOutA( HDC hdc, INT x, INT y, LPCSTR str, INT count )
1727 {
1728     return ExtTextOutA( hdc, x, y, 0, NULL, str, count, NULL );
1729 }
1730
1731
1732 /***********************************************************************
1733  *           TextOutW    (GDI32.@)
1734  */
1735 BOOL WINAPI TextOutW(HDC hdc, INT x, INT y, LPCWSTR str, INT count)
1736 {
1737     return ExtTextOutW( hdc, x, y, 0, NULL, str, count, NULL );
1738 }
1739
1740
1741 /***********************************************************************
1742  *              PolyTextOutA (GDI32.@)
1743  *
1744  * Draw several Strings
1745  */
1746 BOOL WINAPI PolyTextOutA ( HDC hdc,               /* [in] Handle to device context */
1747                            PPOLYTEXTA pptxt,      /* [in] Array of strings */
1748                            INT cStrings )         /* [in] Number of strings in array */
1749 {
1750     for (; cStrings>0; cStrings--, pptxt++)
1751         if (!ExtTextOutA( hdc, pptxt->x, pptxt->y, pptxt->uiFlags, &pptxt->rcl, pptxt->lpstr, pptxt->n, pptxt->pdx ))
1752             return FALSE;
1753     return TRUE;
1754 }
1755
1756
1757
1758 /***********************************************************************
1759  *              PolyTextOutW (GDI32.@)
1760  *
1761  * Draw several Strings
1762  */
1763 BOOL WINAPI PolyTextOutW ( HDC hdc,               /* [in] Handle to device context */
1764                            PPOLYTEXTW pptxt,      /* [in] Array of strings */
1765                            INT cStrings )         /* [in] Number of strings in array */
1766 {
1767     for (; cStrings>0; cStrings--, pptxt++)
1768         if (!ExtTextOutW( hdc, pptxt->x, pptxt->y, pptxt->uiFlags, &pptxt->rcl, pptxt->lpstr, pptxt->n, pptxt->pdx ))
1769             return FALSE;
1770     return TRUE;
1771 }
1772
1773
1774 /* FIXME: all following APIs ******************************************/
1775
1776
1777 /***********************************************************************
1778  *           SetMapperFlags    (GDI32.@)
1779  */
1780 DWORD WINAPI SetMapperFlags( HDC hDC, DWORD dwFlag )
1781 {
1782     DC *dc = DC_GetDCPtr( hDC );
1783     DWORD ret = 0;
1784     if(!dc) return 0;
1785     if(dc->funcs->pSetMapperFlags)
1786         ret = dc->funcs->pSetMapperFlags( dc->physDev, dwFlag );
1787     else
1788         FIXME("(%p, 0x%08lx): stub - harmless\n", hDC, dwFlag);
1789     GDI_ReleaseObj( hDC );
1790     return ret;
1791 }
1792
1793 /***********************************************************************
1794  *          GetAspectRatioFilterEx  (GDI.486)
1795  */
1796 BOOL16 WINAPI GetAspectRatioFilterEx16( HDC16 hdc, LPSIZE16 pAspectRatio )
1797 {
1798   FIXME("(%04x, %p): -- Empty Stub !\n", hdc, pAspectRatio);
1799   return FALSE;
1800 }
1801
1802 /***********************************************************************
1803  *          GetAspectRatioFilterEx  (GDI32.@)
1804  */
1805 BOOL WINAPI GetAspectRatioFilterEx( HDC hdc, LPSIZE pAspectRatio )
1806 {
1807   FIXME("(%p, %p): -- Empty Stub !\n", hdc, pAspectRatio);
1808   return FALSE;
1809 }
1810
1811
1812 /***********************************************************************
1813  *           GetCharABCWidthsA   (GDI32.@)
1814  */
1815 BOOL WINAPI GetCharABCWidthsA(HDC hdc, UINT firstChar, UINT lastChar,
1816                                   LPABC abc )
1817 {
1818     INT i, wlen, count = (INT)(lastChar - firstChar + 1);
1819     LPSTR str;
1820     LPWSTR wstr;
1821     BOOL ret = TRUE;
1822
1823     if(count <= 0) return FALSE;
1824
1825     str = HeapAlloc(GetProcessHeap(), 0, count);
1826     for(i = 0; i < count; i++)
1827         str[i] = (BYTE)(firstChar + i);
1828
1829     wstr = FONT_mbtowc(hdc, str, count, &wlen, NULL);
1830
1831     for(i = 0; i < wlen; i++)
1832     {
1833         if(!GetCharABCWidthsW(hdc, wstr[i], wstr[i], abc))
1834         {
1835             ret = FALSE;
1836             break;
1837         }
1838         abc++;
1839     }
1840
1841     HeapFree(GetProcessHeap(), 0, str);
1842     HeapFree(GetProcessHeap(), 0, wstr);
1843
1844     return ret;
1845 }
1846
1847
1848 /******************************************************************************
1849  * GetCharABCWidthsW [GDI32.@]
1850  *
1851  * Retrieves widths of characters in range.
1852  *
1853  * PARAMS
1854  *    hdc       [I] Handle of device context
1855  *    firstChar [I] First character in range to query
1856  *    lastChar  [I] Last character in range to query
1857  *    abc       [O] Address of character-width structure
1858  *
1859  * NOTES
1860  *    Only works with TrueType fonts
1861  *
1862  * RETURNS
1863  *    Success: TRUE
1864  *    Failure: FALSE
1865  */
1866 BOOL WINAPI GetCharABCWidthsW( HDC hdc, UINT firstChar, UINT lastChar,
1867                                    LPABC abc )
1868 {
1869     DC *dc = DC_GetDCPtr(hdc);
1870     unsigned int i;
1871     BOOL ret = FALSE;
1872
1873     if(dc->gdiFont)
1874         ret = WineEngGetCharABCWidths( dc->gdiFont, firstChar, lastChar, abc );
1875     else
1876         FIXME(": stub\n");
1877
1878     if (ret)
1879     {
1880         /* convert device units to logical */
1881         for( i = firstChar; i <= lastChar; i++, abc++ ) {
1882             abc->abcA = INTERNAL_XDSTOWS(dc, abc->abcA);
1883             abc->abcB = INTERNAL_XDSTOWS(dc, abc->abcB);
1884             abc->abcC = INTERNAL_XDSTOWS(dc, abc->abcC);
1885         }
1886         ret = TRUE;
1887     }
1888
1889     GDI_ReleaseObj(hdc);
1890     return ret;
1891 }
1892
1893
1894 /***********************************************************************
1895  *           GetGlyphOutline    (GDI.309)
1896  */
1897 DWORD WINAPI GetGlyphOutline16( HDC16 hdc, UINT16 uChar, UINT16 fuFormat,
1898                                 LPGLYPHMETRICS16 lpgm, DWORD cbBuffer,
1899                                 LPVOID lpBuffer, const MAT2 *lpmat2 )
1900 {
1901     FIXME("(%04x, '%c', %04x, %p, %ld, %p, %p): stub\n",
1902           hdc, uChar, fuFormat, lpgm, cbBuffer, lpBuffer, lpmat2 );
1903     return ~0UL; /* failure */
1904 }
1905
1906
1907 /***********************************************************************
1908  *           GetGlyphOutlineA    (GDI32.@)
1909  */
1910 DWORD WINAPI GetGlyphOutlineA( HDC hdc, UINT uChar, UINT fuFormat,
1911                                  LPGLYPHMETRICS lpgm, DWORD cbBuffer,
1912                                  LPVOID lpBuffer, const MAT2 *lpmat2 )
1913 {
1914     LPWSTR p = NULL;
1915     DWORD ret;
1916     UINT c;
1917
1918     if(!(fuFormat & GGO_GLYPH_INDEX)) {
1919         p = FONT_mbtowc(hdc, (char*)&uChar, 1, NULL, NULL);
1920         c = p[0];
1921     } else
1922         c = uChar;
1923     ret = GetGlyphOutlineW(hdc, c, fuFormat, lpgm, cbBuffer, lpBuffer,
1924                            lpmat2);
1925     if(p)
1926         HeapFree(GetProcessHeap(), 0, p);
1927     return ret;
1928 }
1929
1930 /***********************************************************************
1931  *           GetGlyphOutlineW    (GDI32.@)
1932  */
1933 DWORD WINAPI GetGlyphOutlineW( HDC hdc, UINT uChar, UINT fuFormat,
1934                                  LPGLYPHMETRICS lpgm, DWORD cbBuffer,
1935                                  LPVOID lpBuffer, const MAT2 *lpmat2 )
1936 {
1937     DC *dc = DC_GetDCPtr(hdc);
1938     DWORD ret;
1939
1940     TRACE("(%p, %04x, %04x, %p, %ld, %p, %p)\n",
1941           hdc, uChar, fuFormat, lpgm, cbBuffer, lpBuffer, lpmat2 );
1942
1943     if(!dc) return GDI_ERROR;
1944
1945     if(dc->gdiFont)
1946       ret = WineEngGetGlyphOutline(dc->gdiFont, uChar, fuFormat, lpgm,
1947                                    cbBuffer, lpBuffer, lpmat2);
1948     else
1949       ret = GDI_ERROR;
1950
1951     GDI_ReleaseObj(hdc);
1952     return ret;
1953 }
1954
1955
1956 /***********************************************************************
1957  *           CreateScalableFontResourceA   (GDI32.@)
1958  */
1959 BOOL WINAPI CreateScalableFontResourceA( DWORD fHidden,
1960                                              LPCSTR lpszResourceFile,
1961                                              LPCSTR lpszFontFile,
1962                                              LPCSTR lpszCurrentPath )
1963 {
1964     HANDLE f;
1965
1966     /* fHidden=1 - only visible for the calling app, read-only, not
1967      * enumbered with EnumFonts/EnumFontFamilies
1968      * lpszCurrentPath can be NULL
1969      */
1970     FIXME("(%ld,%s,%s,%s): stub\n",
1971           fHidden, debugstr_a(lpszResourceFile), debugstr_a(lpszFontFile),
1972           debugstr_a(lpszCurrentPath) );
1973
1974     /* If the output file already exists, return the ERROR_FILE_EXISTS error as specified in MSDN */
1975     if ((f = CreateFileA(lpszResourceFile, 0, 0, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, 0)) != INVALID_HANDLE_VALUE) {
1976         CloseHandle(f);
1977         SetLastError(ERROR_FILE_EXISTS);
1978         return FALSE;
1979     }
1980     return FALSE; /* create failed */
1981 }
1982
1983 /***********************************************************************
1984  *           CreateScalableFontResourceW   (GDI32.@)
1985  */
1986 BOOL WINAPI CreateScalableFontResourceW( DWORD fHidden,
1987                                              LPCWSTR lpszResourceFile,
1988                                              LPCWSTR lpszFontFile,
1989                                              LPCWSTR lpszCurrentPath )
1990 {
1991     FIXME("(%ld,%p,%p,%p): stub\n",
1992           fHidden, lpszResourceFile, lpszFontFile, lpszCurrentPath );
1993     return FALSE; /* create failed */
1994 }
1995
1996
1997 /*************************************************************************
1998  *             GetRasterizerCaps   (GDI32.@)
1999  */
2000 BOOL WINAPI GetRasterizerCaps( LPRASTERIZER_STATUS lprs, UINT cbNumBytes)
2001 {
2002   lprs->nSize = sizeof(RASTERIZER_STATUS);
2003   lprs->wFlags = TT_AVAILABLE|TT_ENABLED;
2004   lprs->nLanguageID = 0;
2005   return TRUE;
2006 }
2007
2008
2009 /*************************************************************************
2010  *             GetKerningPairsA   (GDI32.@)
2011  */
2012 DWORD WINAPI GetKerningPairsA( HDC hDC, DWORD cPairs,
2013                                LPKERNINGPAIR lpKerningPairs )
2014 {
2015     return GetKerningPairsW( hDC, cPairs, lpKerningPairs );
2016 }
2017
2018
2019 /*************************************************************************
2020  *             GetKerningPairsW   (GDI32.@)
2021  */
2022 DWORD WINAPI GetKerningPairsW( HDC hDC, DWORD cPairs,
2023                                  LPKERNINGPAIR lpKerningPairs )
2024 {
2025     unsigned int i;
2026     FIXME("(%p,%ld,%p): almost empty stub!\n", hDC, cPairs, lpKerningPairs);
2027     for (i = 0; i < cPairs; i++)
2028         lpKerningPairs[i].iKernAmount = 0;
2029     return 0;
2030 }
2031
2032 /*************************************************************************
2033  * TranslateCharsetInfo [GDI32.@]
2034  *
2035  * Fills a CHARSETINFO structure for a character set, code page, or
2036  * font. This allows making the correspondance between different labelings
2037  * (character set, Windows, ANSI, and OEM codepages, and Unicode ranges)
2038  * of the same encoding.
2039  *
2040  * Only one codepage will be set in lpCs->fs. If TCI_SRCFONTSIG is used,
2041  * only one codepage should be set in *lpSrc.
2042  *
2043  * RETURNS
2044  *   TRUE on success, FALSE on failure.
2045  *
2046  */
2047 BOOL WINAPI TranslateCharsetInfo(
2048   LPDWORD lpSrc, /* [in]
2049        if flags == TCI_SRCFONTSIG: pointer to fsCsb of a FONTSIGNATURE
2050        if flags == TCI_SRCCHARSET: a character set value
2051        if flags == TCI_SRCCODEPAGE: a code page value
2052                  */
2053   LPCHARSETINFO lpCs, /* [out] structure to receive charset information */
2054   DWORD flags /* [in] determines interpretation of lpSrc */)
2055 {
2056     int index = 0;
2057     switch (flags) {
2058     case TCI_SRCFONTSIG:
2059         while (!(*lpSrc>>index & 0x0001) && index<MAXTCIINDEX) index++;
2060       break;
2061     case TCI_SRCCODEPAGE:
2062       while ((UINT) (lpSrc) != FONT_tci[index].ciACP && index < MAXTCIINDEX) index++;
2063       break;
2064     case TCI_SRCCHARSET:
2065       while ((UINT) (lpSrc) != FONT_tci[index].ciCharset && index < MAXTCIINDEX) index++;
2066       break;
2067     default:
2068       return FALSE;
2069     }
2070     if (index >= MAXTCIINDEX || FONT_tci[index].ciCharset == DEFAULT_CHARSET) return FALSE;
2071     memcpy(lpCs, &FONT_tci[index], sizeof(CHARSETINFO));
2072     return TRUE;
2073 }
2074
2075 /*************************************************************************
2076  *             GetFontLanguageInfo   (GDI32.@)
2077  */
2078 DWORD WINAPI GetFontLanguageInfo(HDC hdc)
2079 {
2080         FONTSIGNATURE fontsig;
2081         static const DWORD GCP_DBCS_MASK=0x003F0000,
2082                 GCP_DIACRITIC_MASK=0x00000000,
2083                 FLI_GLYPHS_MASK=0x00000000,
2084                 GCP_GLYPHSHAPE_MASK=0x00000040,
2085                 GCP_KASHIDA_MASK=0x00000000,
2086                 GCP_LIGATE_MASK=0x00000000,
2087                 GCP_USEKERNING_MASK=0x00000000,
2088                 GCP_REORDER_MASK=0x00000060;
2089
2090         DWORD result=0;
2091
2092         GetTextCharsetInfo( hdc, &fontsig, 0 );
2093         /* We detect each flag we return using a bitmask on the Codepage Bitfields */
2094
2095         if( (fontsig.fsCsb[0]&GCP_DBCS_MASK)!=0 )
2096                 result|=GCP_DBCS;
2097
2098         if( (fontsig.fsCsb[0]&GCP_DIACRITIC_MASK)!=0 )
2099                 result|=GCP_DIACRITIC;
2100
2101         if( (fontsig.fsCsb[0]&FLI_GLYPHS_MASK)!=0 )
2102                 result|=FLI_GLYPHS;
2103
2104         if( (fontsig.fsCsb[0]&GCP_GLYPHSHAPE_MASK)!=0 )
2105                 result|=GCP_GLYPHSHAPE;
2106
2107         if( (fontsig.fsCsb[0]&GCP_KASHIDA_MASK)!=0 )
2108                 result|=GCP_KASHIDA;
2109
2110         if( (fontsig.fsCsb[0]&GCP_LIGATE_MASK)!=0 )
2111                 result|=GCP_LIGATE;
2112
2113         if( (fontsig.fsCsb[0]&GCP_USEKERNING_MASK)!=0 )
2114                 result|=GCP_USEKERNING;
2115
2116         /* this might need a test for a HEBREW- or ARABIC_CHARSET as well */
2117         if( GetTextAlign( hdc) & TA_RTLREADING )
2118             if( (fontsig.fsCsb[0]&GCP_REORDER_MASK)!=0 )
2119                     result|=GCP_REORDER;
2120
2121         return result;
2122 }
2123
2124
2125 /*************************************************************************
2126  * GetFontData [GDI32.@]
2127  *
2128  * Retrieve data for TrueType font.
2129  *
2130  * RETURNS
2131  *
2132  * success: Number of bytes returned
2133  * failure: GDI_ERROR
2134  *
2135  * NOTES
2136  *
2137  * Calls SetLastError()
2138  *
2139  */
2140 DWORD WINAPI GetFontData(HDC hdc, DWORD table, DWORD offset,
2141     LPVOID buffer, DWORD length)
2142 {
2143     DC *dc = DC_GetDCPtr(hdc);
2144     DWORD ret = GDI_ERROR;
2145
2146     if(!dc) return GDI_ERROR;
2147
2148     if(dc->gdiFont)
2149       ret = WineEngGetFontData(dc->gdiFont, table, offset, buffer, length);
2150
2151     GDI_ReleaseObj(hdc);
2152     return ret;
2153 }
2154
2155 /*************************************************************************
2156  * GetGlyphIndicesA [GDI32.@]
2157  */
2158 DWORD WINAPI GetGlyphIndicesA(HDC hdc, LPCSTR lpstr, INT count,
2159                               LPWORD pgi, DWORD flags)
2160 {
2161     DWORD ret;
2162     WCHAR *lpstrW;
2163     INT countW;
2164
2165     TRACE("(%p, %s, %d, %p, 0x%lx)\n",
2166           hdc, debugstr_an(lpstr, count), count, pgi, flags);
2167
2168     lpstrW = FONT_mbtowc(hdc, lpstr, count, &countW, NULL);
2169     ret = GetGlyphIndicesW(hdc, lpstrW, countW, pgi, flags);
2170     HeapFree(GetProcessHeap(), 0, lpstrW);
2171
2172     return ret;
2173 }
2174
2175 /*************************************************************************
2176  * GetGlyphIndicesW [GDI32.@]
2177  */
2178 DWORD WINAPI GetGlyphIndicesW(HDC hdc, LPCWSTR lpstr, INT count,
2179                               LPWORD pgi, DWORD flags)
2180 {
2181     DC *dc = DC_GetDCPtr(hdc);
2182     DWORD ret = GDI_ERROR;
2183
2184     TRACE("(%p, %s, %d, %p, 0x%lx)\n",
2185           hdc, debugstr_wn(lpstr, count), count, pgi, flags);
2186
2187     if(!dc) return GDI_ERROR;
2188
2189     if(dc->gdiFont)
2190         ret = WineEngGetGlyphIndices(dc->gdiFont, lpstr, count, pgi, flags);
2191
2192     GDI_ReleaseObj(hdc);
2193     return ret;
2194 }
2195
2196 /*************************************************************************
2197  * GetCharacterPlacementA [GDI32.@]
2198  *
2199  * NOTES:
2200  *  the web browser control of ie4 calls this with dwFlags=0
2201  */
2202 DWORD WINAPI
2203 GetCharacterPlacementA(HDC hdc, LPCSTR lpString, INT uCount,
2204                          INT nMaxExtent, GCP_RESULTSA *lpResults,
2205                          DWORD dwFlags)
2206 {
2207     WCHAR *lpStringW;
2208     INT uCountW;
2209     GCP_RESULTSW resultsW;
2210     DWORD ret;
2211     UINT font_cp;
2212
2213     TRACE("%s, %d, %d, 0x%08lx\n",
2214           debugstr_an(lpString, uCount), uCount, nMaxExtent, dwFlags);
2215
2216     /* both structs are equal in size */
2217     memcpy(&resultsW, lpResults, sizeof(resultsW));
2218
2219     lpStringW = FONT_mbtowc(hdc, lpString, uCount, &uCountW, &font_cp);
2220     if(lpResults->lpOutString)
2221         resultsW.lpOutString = HeapAlloc(GetProcessHeap(), 0, sizeof(WCHAR)*uCountW);
2222
2223     ret = GetCharacterPlacementW(hdc, lpStringW, uCountW, nMaxExtent, &resultsW, dwFlags);
2224
2225     if(lpResults->lpOutString) {
2226         WideCharToMultiByte(font_cp, 0, resultsW.lpOutString, uCountW,
2227                             lpResults->lpOutString, uCount, NULL, NULL );
2228     }
2229
2230     HeapFree(GetProcessHeap(), 0, lpStringW);
2231     HeapFree(GetProcessHeap(), 0, resultsW.lpOutString);
2232
2233     return ret;
2234 }
2235
2236 /*************************************************************************
2237  * GetCharacterPlacementW [GDI32.@]
2238  *
2239  *   Retrieve information about a string. This includes the width, reordering,
2240  *   Glyphing and so on.
2241  *
2242  * RETURNS
2243  *
2244  *   The width and height of the string if successful, 0 if failed.
2245  *
2246  * BUGS
2247  *
2248  *   All flags except GCP_REORDER are not yet implemented.
2249  *   Reordering is not 100% complient to the Windows BiDi method.
2250  *   Caret positioning is not yet implemented for BiDi.
2251  *   Classes are not yet implemented.
2252  *
2253  */
2254 DWORD WINAPI
2255 GetCharacterPlacementW(
2256                 HDC hdc,                /* [in] Device context for which the rendering is to be done */
2257                 LPCWSTR lpString,       /* [in] The string for which information is to be returned */
2258                 INT uCount,             /* [in] Number of WORDS in string. */
2259                 INT nMaxExtent,         /* [in] Maximum extent the string is to take (in HDC logical units) */
2260                 GCP_RESULTSW *lpResults,/* [in/out] A pointer to a GCP_RESULTSW struct */
2261                 DWORD dwFlags           /* [in] Flags specifying how to process the string */
2262                 )
2263 {
2264     DWORD ret=0;
2265     SIZE size;
2266     UINT i, nSet;
2267
2268     TRACE("%s, %d, %d, 0x%08lx\n",
2269           debugstr_wn(lpString, uCount), uCount, nMaxExtent, dwFlags);
2270
2271     TRACE("lStructSize=%ld, lpOutString=%p, lpOrder=%p, lpDx=%p, lpCaretPos=%p\n"
2272           "lpClass=%p, lpGlyphs=%p, nGlyphs=%u, nMaxFit=%d\n",
2273             lpResults->lStructSize, lpResults->lpOutString, lpResults->lpOrder,
2274             lpResults->lpDx, lpResults->lpCaretPos, lpResults->lpClass,
2275             lpResults->lpGlyphs, lpResults->nGlyphs, lpResults->nMaxFit);
2276
2277     if(dwFlags&(~GCP_REORDER))                  FIXME("flags 0x%08lx ignored\n", dwFlags);
2278     if(lpResults->lpClass)      FIXME("classes not implemented\n");
2279     if (lpResults->lpCaretPos && (dwFlags & GCP_REORDER))
2280         FIXME("Caret positions for complex scripts not implemented\n");
2281
2282         nSet = (UINT)uCount;
2283         if(nSet > lpResults->nGlyphs)
2284                 nSet = lpResults->nGlyphs;
2285
2286         /* return number of initialized fields */
2287         lpResults->nGlyphs = nSet;
2288
2289         if((dwFlags&GCP_REORDER)==0 || !BidiAvail)
2290         {
2291                 /* Treat the case where no special handling was requested in a fastpath way */
2292                 /* copy will do if the GCP_REORDER flag is not set */
2293                 if(lpResults->lpOutString)
2294                     strncpyW( lpResults->lpOutString, lpString, nSet );
2295
2296                 if(lpResults->lpOrder)
2297                 {
2298                         for(i = 0; i < nSet; i++)
2299                                 lpResults->lpOrder[i] = i;
2300                 }
2301         } else
2302         {
2303             BIDI_Reorder( lpString, uCount, dwFlags, WINE_GCPW_FORCE_LTR, lpResults->lpOutString,
2304                           nSet, lpResults->lpOrder );
2305         }
2306
2307         /* FIXME: Will use the placement chars */
2308         if (lpResults->lpDx)
2309         {
2310                 int c;
2311                 for (i = 0; i < nSet; i++)
2312                 {
2313                         if (GetCharWidth32W(hdc, lpString[i], lpString[i], &c))
2314                                 lpResults->lpDx[i]= c;
2315                 }
2316         }
2317
2318     if (lpResults->lpCaretPos && !(dwFlags & GCP_REORDER))
2319     {
2320         int pos = 0;
2321
2322         lpResults->lpCaretPos[0] = 0;
2323         for (i = 1; i < nSet; i++)
2324             if (GetTextExtentPoint32W(hdc, &(lpString[i - 1]), 1, &size))
2325                 lpResults->lpCaretPos[i] = (pos += size.cx);
2326     }
2327
2328     if(lpResults->lpGlyphs)
2329         GetGlyphIndicesW(hdc, lpString, nSet, lpResults->lpGlyphs, 0);
2330
2331     if (GetTextExtentPoint32W(hdc, lpString, uCount, &size))
2332       ret = MAKELONG(size.cx, size.cy);
2333
2334     return ret;
2335 }
2336
2337 /*************************************************************************
2338  *      GetCharABCWidthsFloatA [GDI32.@]
2339  */
2340 BOOL WINAPI GetCharABCWidthsFloatA(HDC hdc, UINT iFirstChar, UINT iLastChar,
2341                                         LPABCFLOAT lpABCF)
2342 {
2343        FIXME_(gdi)("GetCharABCWidthsFloatA, stub\n");
2344        return 0;
2345 }
2346
2347 /*************************************************************************
2348  *      GetCharABCWidthsFloatW [GDI32.@]
2349  */
2350 BOOL WINAPI GetCharABCWidthsFloatW(HDC hdc, UINT iFirstChar,
2351                                         UINT iLastChar, LPABCFLOAT lpABCF)
2352 {
2353        FIXME_(gdi)("GetCharABCWidthsFloatW, stub\n");
2354        return 0;
2355 }
2356
2357 /*************************************************************************
2358  *      GetCharWidthFloatA [GDI32.@]
2359  */
2360 BOOL WINAPI GetCharWidthFloatA(HDC hdc, UINT iFirstChar,
2361                                     UINT iLastChar, PFLOAT pxBuffer)
2362 {
2363        FIXME_(gdi)("GetCharWidthFloatA, stub\n");
2364        return 0;
2365 }
2366
2367 /*************************************************************************
2368  *      GetCharWidthFloatW [GDI32.@]
2369  */
2370 BOOL WINAPI GetCharWidthFloatW(HDC hdc, UINT iFirstChar,
2371                                     UINT iLastChar, PFLOAT pxBuffer)
2372 {
2373        FIXME_(gdi)("GetCharWidthFloatW, stub\n");
2374        return 0;
2375 }
2376
2377
2378 /***********************************************************************
2379  *                                                                     *
2380  *           Font Resource API                                         *
2381  *                                                                     *
2382  ***********************************************************************/
2383
2384 /***********************************************************************
2385  *           AddFontResourceA    (GDI32.@)
2386  */
2387 INT WINAPI AddFontResourceA( LPCSTR str )
2388 {
2389     return AddFontResourceExA( str, 0, NULL);
2390 }
2391
2392 /***********************************************************************
2393  *           AddFontResourceW    (GDI32.@)
2394  */
2395 INT WINAPI AddFontResourceW( LPCWSTR str )
2396 {
2397     return AddFontResourceExW(str, 0, NULL);
2398 }
2399
2400
2401 /***********************************************************************
2402  *           AddFontResourceExA    (GDI32.@)
2403  */
2404 INT WINAPI AddFontResourceExA( LPCSTR str, DWORD fl, PVOID pdv )
2405 {
2406     DWORD len = MultiByteToWideChar(CP_ACP, 0, str, -1, NULL, 0);
2407     LPWSTR strW = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
2408     INT ret;
2409
2410     MultiByteToWideChar(CP_ACP, 0, str, -1, strW, len);
2411     ret = AddFontResourceExW(strW, fl, pdv);
2412     HeapFree(GetProcessHeap(), 0, strW);
2413     return ret;
2414 }
2415
2416 /***********************************************************************
2417  *           AddFontResourceExW    (GDI32.@)
2418  */
2419 INT WINAPI AddFontResourceExW( LPCWSTR str, DWORD fl, PVOID pdv )
2420 {
2421     return WineEngAddFontResourceEx(str, fl, pdv);
2422 }
2423
2424 /***********************************************************************
2425  *           RemoveFontResourceA    (GDI32.@)
2426  */
2427 BOOL WINAPI RemoveFontResourceA( LPCSTR str )
2428 {
2429     return RemoveFontResourceExA(str, 0, 0);
2430 }
2431
2432 /***********************************************************************
2433  *           RemoveFontResourceW    (GDI32.@)
2434  */
2435 BOOL WINAPI RemoveFontResourceW( LPCWSTR str )
2436 {
2437     return RemoveFontResourceExW(str, 0, 0);
2438 }
2439
2440 /***********************************************************************
2441  *           RemoveFontResourceExA    (GDI32.@)
2442  */
2443 BOOL WINAPI RemoveFontResourceExA( LPCSTR str, DWORD fl, PVOID pdv )
2444 {
2445     DWORD len = MultiByteToWideChar(CP_ACP, 0, str, -1, NULL, 0);
2446     LPWSTR strW = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
2447     INT ret;
2448
2449     MultiByteToWideChar(CP_ACP, 0, str, -1, strW, len);
2450     ret = RemoveFontResourceExW(strW, fl, pdv);
2451     HeapFree(GetProcessHeap(), 0, strW);
2452     return ret;
2453 }
2454
2455 /***********************************************************************
2456  *           RemoveFontResourceExW    (GDI32.@)
2457  */
2458 BOOL WINAPI RemoveFontResourceExW( LPCWSTR str, DWORD fl, PVOID pdv )
2459 {
2460     return WineEngRemoveFontResourceEx(str, fl, pdv);
2461 }
2462
2463 /***********************************************************************
2464  *           GetTextCharset    (GDI32.@)
2465  */
2466 UINT WINAPI GetTextCharset(HDC hdc)
2467 {
2468     /* MSDN docs say this is equivalent */
2469     return GetTextCharsetInfo(hdc, NULL, 0);
2470 }
2471
2472 /***********************************************************************
2473  *           GetTextCharsetInfo    (GDI32.@)
2474  */
2475 UINT WINAPI GetTextCharsetInfo(HDC hdc, LPFONTSIGNATURE fs, DWORD flags)
2476 {
2477     UINT ret = DEFAULT_CHARSET;
2478     DC *dc = DC_GetDCPtr(hdc);
2479
2480     if (!dc) goto done;
2481
2482     if (dc->gdiFont)
2483         ret = WineEngGetTextCharsetInfo(dc->gdiFont, fs, flags);
2484
2485     GDI_ReleaseObj(hdc);
2486
2487 done:
2488     if (ret == DEFAULT_CHARSET && fs)
2489         memset(fs, 0, sizeof(FONTSIGNATURE));
2490     return ret;
2491 }