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