git.oblomov.eu Git - wine/blob - objects/font.c

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