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

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