objects/font.c

   1 /*
   2  * GDI font objects
   3  *
   4  * Copyright 1993 Alexandre Julliard
   5  *           1997 Alex Korobka
   6  */
   7
   8 #include <stdlib.h>
   9 #include <string.h>
  10 #include "wine/winestring.h"
  11 #include "font.h"
  12 #include "heap.h"
  13 #include "metafile.h"
  14 #include "options.h"
  15 #include "debugtools.h"
  16 #include "winerror.h"
  17 #include "dc.h"
  18
  19 DECLARE_DEBUG_CHANNEL(font)
  20 DECLARE_DEBUG_CHANNEL(gdi)
  21
  22 #define ENUM_UNICODE    0x00000001
  23
  24 typedef struct
  25 {
  26   LPLOGFONT16           lpLogFontParam;
  27   FONTENUMPROCEX16      lpEnumFunc;
  28   LPARAM                lpData;
  29
  30   LPNEWTEXTMETRICEX16   lpTextMetric;
  31   LPENUMLOGFONTEX16     lpLogFont;
  32   SEGPTR                segTextMetric;
  33   SEGPTR                segLogFont;
  34 } fontEnum16;
  35
  36 typedef struct
  37 {
  38   LPLOGFONTW          lpLogFontParam;
  39   FONTENUMPROCEXW     lpEnumFunc;
  40   LPARAM                lpData;
  41
  42   LPNEWTEXTMETRICEXW  lpTextMetric;
  43   LPENUMLOGFONTEXW    lpLogFont;
  44   DWORD                 dwFlags;
  45 } fontEnum32;
  46
  47 /*
  48  *  For TranslateCharsetInfo
  49  */
  50 #define FS(x) {{0,0,0,0},{0x1<<(x),0}}
  51 #define MAXTCIINDEX 32
  52 static CHARSETINFO FONT_tci[MAXTCIINDEX] = {
  53   /* ANSI */
  54   { ANSI_CHARSET, 1252, FS(0)},
  55   { EASTEUROPE_CHARSET, 1250, FS(1)},
  56   { RUSSIAN_CHARSET, 1251, FS(2)},
  57   { GREEK_CHARSET, 1253, FS(3)},
  58   { TURKISH_CHARSET, 1254, FS(4)},
  59   { HEBREW_CHARSET, 1255, FS(5)},
  60   { ARABIC_CHARSET, 1256, FS(6)},
  61   { BALTIC_CHARSET, 1257, FS(7)},
  62   /* reserved by ANSI */
  63   { DEFAULT_CHARSET, 0, FS(0)},
  64   { DEFAULT_CHARSET, 0, FS(0)},
  65   { DEFAULT_CHARSET, 0, FS(0)},
  66   { DEFAULT_CHARSET, 0, FS(0)},
  67   { DEFAULT_CHARSET, 0, FS(0)},
  68   { DEFAULT_CHARSET, 0, FS(0)},
  69   { DEFAULT_CHARSET, 0, FS(0)},
  70   { DEFAULT_CHARSET, 0, FS(0)},
  71   /* ANSI and OEM */
  72   { THAI_CHARSET,  874,  FS(16)},
  73   { SHIFTJIS_CHARSET, 932, FS(17)},
  74   { GB2312_CHARSET, 936, FS(18)},
  75   { HANGEUL_CHARSET, 949, FS(19)},
  76   { CHINESEBIG5_CHARSET, 950, FS(20)},
  77   { JOHAB_CHARSET, 1361, FS(21)},
  78   /* reserved for alternate ANSI and OEM */
  79   { DEFAULT_CHARSET, 0, FS(0)},
  80   { DEFAULT_CHARSET, 0, FS(0)},
  81   { DEFAULT_CHARSET, 0, FS(0)},
  82   { DEFAULT_CHARSET, 0, FS(0)},
  83   { DEFAULT_CHARSET, 0, FS(0)},
  84   { DEFAULT_CHARSET, 0, FS(0)},
  85   { DEFAULT_CHARSET, 0, FS(0)},
  86   { DEFAULT_CHARSET, 0, FS(0)},
  87   /* reserved for system */
  88   { DEFAULT_CHARSET, 0, FS(0)},
  89   { DEFAULT_CHARSET, 0, FS(0)},
  90 };
  91
  92 /***********************************************************************
  93  *              LOGFONT conversion functions.
  94  */
  95 static void __logfont32to16( INT16* plf16, const INT* plf32 )
  96 {
  97     int  i;
  98     for( i = 0; i < 5; i++ ) *plf16++ = *plf32++;
  99    *((INT*)plf16)++ = *plf32++;
 100    *((INT*)plf16)   = *plf32;
 101 }
 102
 103 static void __logfont16to32( INT* plf32, const INT16* plf16 )
 104 {
 105     int i;
 106     for( i = 0; i < 5; i++ ) *plf32++ = *plf16++;
 107    *plf32++ = *((INT*)plf16)++;
 108    *plf32   = *((INT*)plf16);
 109 }
 110
 111 void FONT_LogFont32ATo16( const LOGFONTA* font32, LPLOGFONT16 font16 )
 112 {
 113   __logfont32to16( (INT16*)font16, (const INT*)font32 );
 114     lstrcpynA( font16->lfFaceName, font32->lfFaceName, LF_FACESIZE );
 115 }
 116
 117 void FONT_LogFont32WTo16( const LOGFONTW* font32, LPLOGFONT16 font16 )
 118 {
 119   __logfont32to16( (INT16*)font16, (const INT*)font32 );
 120     lstrcpynWtoA( font16->lfFaceName, font32->lfFaceName, LF_FACESIZE );
 121 }
 122
 123 void FONT_LogFont16To32A( const LPLOGFONT16 font16, LPLOGFONTA font32 )
 124 {
 125   __logfont16to32( (INT*)font32, (const INT16*)font16 );
 126     lstrcpynA( font32->lfFaceName, font16->lfFaceName, LF_FACESIZE );
 127 }
 128
 129 void FONT_LogFont16To32W( const LPLOGFONT16 font16, LPLOGFONTW font32 )
 130 {
 131   __logfont16to32( (INT*)font32, (const INT16*)font16 );
 132     lstrcpynAtoW( font32->lfFaceName, font16->lfFaceName, LF_FACESIZE );
 133 }
 134
 135 void FONT_EnumLogFontEx16To32A( const LPENUMLOGFONTEX16 font16, LPENUMLOGFONTEXA font32 )
 136 {
 137     FONT_LogFont16To32A( (LPLOGFONT16)font16, (LPLOGFONTA)font32);
 138     lstrcpynA( font32->elfFullName, font16->elfFullName, LF_FULLFACESIZE );
 139     lstrcpynA( font32->elfStyle, font16->elfStyle, LF_FACESIZE );
 140     lstrcpynA( font32->elfScript, font16->elfScript, LF_FACESIZE );
 141 }
 142
 143 void FONT_EnumLogFontEx16To32W( const LPENUMLOGFONTEX16 font16, LPENUMLOGFONTEXW font32 )
 144 {
 145     FONT_LogFont16To32W( (LPLOGFONT16)font16, (LPLOGFONTW)font32);
 146     lstrcpynAtoW( font32->elfFullName, font16->elfFullName, LF_FULLFACESIZE );
 147     lstrcpynAtoW( font32->elfStyle, font16->elfStyle, LF_FACESIZE );
 148     lstrcpynAtoW( font32->elfScript, font16->elfScript, LF_FACESIZE );
 149 }
 150
 151 /***********************************************************************
 152  *              TEXTMETRIC conversion functions.
 153  */
 154 void FONT_TextMetric32Ato16(const LPTEXTMETRICA ptm32, LPTEXTMETRIC16 ptm16 )
 155 {
 156     ptm16->tmHeight = ptm32->tmHeight;
 157     ptm16->tmAscent = ptm32->tmAscent;
 158     ptm16->tmDescent = ptm32->tmDescent;
 159     ptm16->tmInternalLeading = ptm32->tmInternalLeading;
 160     ptm16->tmExternalLeading = ptm32->tmExternalLeading;
 161     ptm16->tmAveCharWidth = ptm32->tmAveCharWidth;
 162     ptm16->tmMaxCharWidth = ptm32->tmMaxCharWidth;
 163     ptm16->tmWeight = ptm32->tmWeight;
 164     ptm16->tmOverhang = ptm32->tmOverhang;
 165     ptm16->tmDigitizedAspectX = ptm32->tmDigitizedAspectX;
 166     ptm16->tmDigitizedAspectY = ptm32->tmDigitizedAspectY;
 167     ptm16->tmFirstChar = ptm32->tmFirstChar;
 168     ptm16->tmLastChar = ptm32->tmLastChar;
 169     ptm16->tmDefaultChar = ptm32->tmDefaultChar;
 170     ptm16->tmBreakChar = ptm32->tmBreakChar;
 171     ptm16->tmItalic = ptm32->tmItalic;
 172     ptm16->tmUnderlined = ptm32->tmUnderlined;
 173     ptm16->tmStruckOut = ptm32->tmStruckOut;
 174     ptm16->tmPitchAndFamily = ptm32->tmPitchAndFamily;
 175     ptm16->tmCharSet = ptm32->tmCharSet;
 176 }
 177
 178 void FONT_TextMetric32Wto16(const LPTEXTMETRICW ptm32, LPTEXTMETRIC16 ptm16 )
 179 {
 180     ptm16->tmHeight = ptm32->tmHeight;
 181     ptm16->tmAscent = ptm32->tmAscent;
 182     ptm16->tmDescent = ptm32->tmDescent;
 183     ptm16->tmInternalLeading = ptm32->tmInternalLeading;
 184     ptm16->tmExternalLeading = ptm32->tmExternalLeading;
 185     ptm16->tmAveCharWidth = ptm32->tmAveCharWidth;
 186     ptm16->tmMaxCharWidth = ptm32->tmMaxCharWidth;
 187     ptm16->tmWeight = ptm32->tmWeight;
 188     ptm16->tmOverhang = ptm32->tmOverhang;
 189     ptm16->tmDigitizedAspectX = ptm32->tmDigitizedAspectX;
 190     ptm16->tmDigitizedAspectY = ptm32->tmDigitizedAspectY;
 191     ptm16->tmFirstChar = ptm32->tmFirstChar;
 192     ptm16->tmLastChar = ptm32->tmLastChar;
 193     ptm16->tmDefaultChar = ptm32->tmDefaultChar;
 194     ptm16->tmBreakChar = ptm32->tmBreakChar;
 195     ptm16->tmItalic = ptm32->tmItalic;
 196     ptm16->tmUnderlined = ptm32->tmUnderlined;
 197     ptm16->tmStruckOut = ptm32->tmStruckOut;
 198     ptm16->tmPitchAndFamily = ptm32->tmPitchAndFamily;
 199     ptm16->tmCharSet = ptm32->tmCharSet;
 200 }
 201
 202 void FONT_TextMetric16to32A(const LPTEXTMETRIC16 ptm16, LPTEXTMETRICA ptm32 )
 203 {
 204     ptm32->tmHeight = ptm16->tmHeight;
 205     ptm32->tmAscent = ptm16->tmAscent;
 206     ptm32->tmDescent = ptm16->tmDescent;
 207     ptm32->tmInternalLeading = ptm16->tmInternalLeading;
 208     ptm32->tmExternalLeading = ptm16->tmExternalLeading;
 209     ptm32->tmAveCharWidth = ptm16->tmAveCharWidth;
 210     ptm32->tmMaxCharWidth = ptm16->tmMaxCharWidth;
 211     ptm32->tmWeight = ptm16->tmWeight;
 212     ptm32->tmOverhang = ptm16->tmOverhang;
 213     ptm32->tmDigitizedAspectX = ptm16->tmDigitizedAspectX;
 214     ptm32->tmDigitizedAspectY = ptm16->tmDigitizedAspectY;
 215     ptm32->tmFirstChar = ptm16->tmFirstChar;
 216     ptm32->tmLastChar = ptm16->tmLastChar;
 217     ptm32->tmDefaultChar = ptm16->tmDefaultChar;
 218     ptm32->tmBreakChar = ptm16->tmBreakChar;
 219     ptm32->tmItalic = ptm16->tmItalic;
 220     ptm32->tmUnderlined = ptm16->tmUnderlined;
 221     ptm32->tmStruckOut = ptm16->tmStruckOut;
 222     ptm32->tmPitchAndFamily = ptm16->tmPitchAndFamily;
 223     ptm32->tmCharSet = ptm16->tmCharSet;
 224 }
 225
 226 void FONT_TextMetric16to32W(const LPTEXTMETRIC16 ptm16, LPTEXTMETRICW ptm32 )
 227 {
 228     ptm32->tmHeight = ptm16->tmHeight;
 229     ptm32->tmAscent = ptm16->tmAscent;
 230     ptm32->tmDescent = ptm16->tmDescent;
 231     ptm32->tmInternalLeading = ptm16->tmInternalLeading;
 232     ptm32->tmExternalLeading = ptm16->tmExternalLeading;
 233     ptm32->tmAveCharWidth = ptm16->tmAveCharWidth;
 234     ptm32->tmMaxCharWidth = ptm16->tmMaxCharWidth;
 235     ptm32->tmWeight = ptm16->tmWeight;
 236     ptm32->tmOverhang = ptm16->tmOverhang;
 237     ptm32->tmDigitizedAspectX = ptm16->tmDigitizedAspectX;
 238     ptm32->tmDigitizedAspectY = ptm16->tmDigitizedAspectY;
 239     ptm32->tmFirstChar = ptm16->tmFirstChar;
 240     ptm32->tmLastChar = ptm16->tmLastChar;
 241     ptm32->tmDefaultChar = ptm16->tmDefaultChar;
 242     ptm32->tmBreakChar = ptm16->tmBreakChar;
 243     ptm32->tmItalic = ptm16->tmItalic;
 244     ptm32->tmUnderlined = ptm16->tmUnderlined;
 245     ptm32->tmStruckOut = ptm16->tmStruckOut;
 246     ptm32->tmPitchAndFamily = ptm16->tmPitchAndFamily;
 247     ptm32->tmCharSet = ptm16->tmCharSet;
 248 }
 249
 250 void FONT_TextMetric32Ato32W(const LPTEXTMETRICA ptm32A, LPTEXTMETRICW ptm32W )
 251 {
 252     ptm32W->tmHeight = ptm32A->tmHeight;
 253     ptm32W->tmAscent = ptm32A->tmAscent;
 254     ptm32W->tmDescent = ptm32A->tmDescent;
 255     ptm32W->tmInternalLeading = ptm32A->tmInternalLeading;
 256     ptm32W->tmExternalLeading = ptm32A->tmExternalLeading;
 257     ptm32W->tmAveCharWidth = ptm32A->tmAveCharWidth;
 258     ptm32W->tmMaxCharWidth = ptm32A->tmMaxCharWidth;
 259     ptm32W->tmWeight = ptm32A->tmWeight;
 260     ptm32W->tmOverhang = ptm32A->tmOverhang;
 261     ptm32W->tmDigitizedAspectX = ptm32A->tmDigitizedAspectX;
 262     ptm32W->tmDigitizedAspectY = ptm32A->tmDigitizedAspectY;
 263     ptm32W->tmFirstChar = ptm32A->tmFirstChar;
 264     ptm32W->tmLastChar = ptm32A->tmLastChar;
 265     ptm32W->tmDefaultChar = ptm32A->tmDefaultChar;
 266     ptm32W->tmBreakChar = ptm32A->tmBreakChar;
 267     ptm32W->tmItalic = ptm32A->tmItalic;
 268     ptm32W->tmUnderlined = ptm32A->tmUnderlined;
 269     ptm32W->tmStruckOut = ptm32A->tmStruckOut;
 270     ptm32W->tmPitchAndFamily = ptm32A->tmPitchAndFamily;
 271     ptm32W->tmCharSet = ptm32A->tmCharSet;
 272 }
 273
 274 /***********************************************************************
 275  *           CreateFontIndirect16   (GDI.57)
 276  */
 277 HFONT16 WINAPI CreateFontIndirect16( const LOGFONT16 *font )
 278 {
 279     HFONT16 hFont = 0;
 280
 281     if (font)
 282     {
 283         hFont = GDI_AllocObject( sizeof(FONTOBJ), FONT_MAGIC );
 284         if( hFont )
 285         {
 286             FONTOBJ* fontPtr;
 287             fontPtr = (FONTOBJ *) GDI_HEAP_LOCK( hFont );
 288             memcpy( &fontPtr->logfont, font, sizeof(LOGFONT16) );
 289
 290             TRACE_(font)("(%i %i %i %i) '%s' %s %s => %04x\n",
 291                                  font->lfHeight, font->lfWidth,
 292                                  font->lfEscapement, font->lfOrientation,
 293                                  font->lfFaceName ? font->lfFaceName : "NULL",
 294                                  font->lfWeight > 400 ? "Bold" : "",
 295                                  font->lfItalic ? "Italic" : "",
 296                                  hFont);
 297
 298             if (font->lfEscapement != font->lfOrientation) {
 299               /* this should really depend on whether GM_ADVANCED is set */
 300               fontPtr->logfont.lfOrientation = fontPtr->logfont.lfEscapement;
 301               WARN_(font)(
 302        "orientation angle %f set to escapement angle %f for new font %04x\n",
 303            font->lfOrientation/10., font->lfEscapement/10., hFont);
 304             }
 305             GDI_HEAP_UNLOCK( hFont );
 306         }
 307     }
 308     else WARN_(font)("(NULL) => NULL\n");
 309
 310     return hFont;
 311 }
 312
 313 /***********************************************************************
 314  *           CreateFontIndirectA   (GDI32.44)
 315  */
 316 HFONT WINAPI CreateFontIndirectA( const LOGFONTA *font )
 317 {
 318     LOGFONT16 font16;
 319
 320     FONT_LogFont32ATo16( font, &font16 );
 321     return CreateFontIndirect16( &font16 );
 322 }
 323
 324 /***********************************************************************
 325  *           CreateFontIndirectW   (GDI32.45)
 326  */
 327 HFONT WINAPI CreateFontIndirectW( const LOGFONTW *font )
 328 {
 329     LOGFONT16 font16;
 330
 331     FONT_LogFont32WTo16( font, &font16 );
 332     return CreateFontIndirect16( &font16 );
 333 }
 334
 335 /***********************************************************************
 336  *           CreateFont16    (GDI.56)
 337  */
 338 HFONT16 WINAPI CreateFont16(INT16 height, INT16 width, INT16 esc, INT16 orient,
 339                             INT16 weight, BYTE italic, BYTE underline,
 340                             BYTE strikeout, BYTE charset, BYTE outpres,
 341                             BYTE clippres, BYTE quality, BYTE pitch,
 342                             LPCSTR name )
 343 {
 344     LOGFONT16 logfont;
 345
 346     TRACE_(font)("('%s',%d,%d)\n",
 347                  (name ? name : "(null)") , height, width);
 348
 349     logfont.lfHeight = height;
 350     logfont.lfWidth = width;
 351     logfont.lfEscapement = esc;
 352     logfont.lfOrientation = orient;
 353     logfont.lfWeight = weight;
 354     logfont.lfItalic = italic;
 355     logfont.lfUnderline = underline;
 356     logfont.lfStrikeOut = strikeout;
 357     logfont.lfCharSet = charset;
 358     logfont.lfOutPrecision = outpres;
 359     logfont.lfClipPrecision = clippres;
 360     logfont.lfQuality = quality;
 361     logfont.lfPitchAndFamily = pitch;
 362
 363     if (name)
 364         lstrcpynA(logfont.lfFaceName,name,sizeof(logfont.lfFaceName));
 365     else
 366         logfont.lfFaceName[0] = '\0';
 367
 368     return CreateFontIndirect16( &logfont );
 369 }
 370
 371 /*************************************************************************
 372  *           CreateFontA    (GDI32.43)
 373  */
 374 HFONT WINAPI CreateFontA( INT height, INT width, INT esc,
 375                               INT orient, INT weight, DWORD italic,
 376                               DWORD underline, DWORD strikeout, DWORD charset,
 377                               DWORD outpres, DWORD clippres, DWORD quality,
 378                               DWORD pitch, LPCSTR name )
 379 {
 380     return (HFONT)CreateFont16( height, width, esc, orient, weight, italic,
 381                                   underline, strikeout, charset, outpres,
 382                                   clippres, quality, pitch, name );
 383 }
 384
 385 /*************************************************************************
 386  *           CreateFontW    (GDI32.46)
 387  */
 388 HFONT WINAPI CreateFontW( INT height, INT width, INT esc,
 389                               INT orient, INT weight, DWORD italic,
 390                               DWORD underline, DWORD strikeout, DWORD charset,
 391                               DWORD outpres, DWORD clippres, DWORD quality,
 392                               DWORD pitch, LPCWSTR name )
 393 {
 394     LPSTR namea = HEAP_strdupWtoA( GetProcessHeap(), 0, name );
 395     HFONT ret = (HFONT)CreateFont16( height, width, esc, orient, weight,
 396                                          italic, underline, strikeout, charset,
 397                                          outpres, clippres, quality, pitch,
 398                                          namea );
 399     if (namea) HeapFree( GetProcessHeap(), 0, namea );
 400     return ret;
 401 }
 402
 403
 404 /***********************************************************************
 405  *           FONT_GetObject16
 406  */
 407 INT16 FONT_GetObject16( FONTOBJ * font, INT16 count, LPSTR buffer )
 408 {
 409     if (count > sizeof(LOGFONT16)) count = sizeof(LOGFONT16);
 410     memcpy( buffer, &font->logfont, count );
 411     return count;
 412 }
 413
 414 /***********************************************************************
 415  *           FONT_GetObjectA
 416  */
 417 INT FONT_GetObjectA( FONTOBJ *font, INT count, LPSTR buffer )
 418 {
 419     LOGFONTA fnt32;
 420
 421     FONT_LogFont16To32A( &font->logfont, &fnt32 );
 422
 423     if (count > sizeof(fnt32)) count = sizeof(fnt32);
 424     memcpy( buffer, &fnt32, count );
 425     return count;
 426 }
 427 /***********************************************************************
 428  *           FONT_GetObjectW
 429  */
 430 INT FONT_GetObjectW( FONTOBJ *font, INT count, LPSTR buffer )
 431 {
 432     LOGFONTW fnt32;
 433
 434     FONT_LogFont16To32W( &font->logfont, &fnt32 );
 435
 436     if (count > sizeof(fnt32)) count = sizeof(fnt32);
 437     memcpy( buffer, &fnt32, count );
 438     return count;
 439 }
 440
 441
 442 /***********************************************************************
 443  *              FONT_EnumInstance16
 444  *
 445  * Called by the device driver layer to pass font info
 446  * down to the application.
 447  */
 448 static INT FONT_EnumInstance16( LPENUMLOGFONTEX16 plf,
 449                                   LPNEWTEXTMETRIC16 ptm, UINT16 fType, LPARAM lp )
 450 {
 451 #define pfe ((fontEnum16*)lp)
 452     if( pfe->lpLogFontParam->lfCharSet == DEFAULT_CHARSET ||
 453         pfe->lpLogFontParam->lfCharSet == plf->elfLogFont.lfCharSet )
 454     {
 455         memcpy( pfe->lpLogFont, plf, sizeof(ENUMLOGFONT16) );
 456         memcpy( pfe->lpTextMetric, ptm, sizeof(NEWTEXTMETRIC16) );
 457
 458         return pfe->lpEnumFunc( pfe->segLogFont, pfe->segTextMetric, fType, (LPARAM)(pfe->lpData) );
 459     }
 460 #undef pfe
 461     return 1;
 462 }
 463
 464 /***********************************************************************
 465  *              FONT_EnumInstance
 466  */
 467 static INT FONT_EnumInstance( LPENUMLOGFONTEX16 plf,
 468                                   LPNEWTEXTMETRIC16 ptm, UINT16 fType, LPARAM lp )
 469 {
 470     /* lfCharSet is at the same offset in both LOGFONT32A and LOGFONT32W */
 471
 472 #define pfe ((fontEnum32*)lp)
 473     if( pfe->lpLogFontParam->lfCharSet == DEFAULT_CHARSET ||
 474         pfe->lpLogFontParam->lfCharSet == plf->elfLogFont.lfCharSet )
 475     {
 476         /* convert font metrics */
 477
 478         if( pfe->dwFlags & ENUM_UNICODE )
 479         {
 480             FONT_EnumLogFontEx16To32W( plf, pfe->lpLogFont );
 481             FONT_TextMetric16to32W( (LPTEXTMETRIC16)ptm, (LPTEXTMETRICW)(pfe->lpTextMetric) );
 482
 483             return pfe->lpEnumFunc( pfe->lpLogFont, pfe->lpTextMetric, fType, pfe->lpData );
 484         }
 485         else
 486         {
 487             ENUMLOGFONTEXA logfont;
 488
 489             FONT_EnumLogFontEx16To32A( plf, &logfont);
 490             FONT_TextMetric16to32A( (LPTEXTMETRIC16)ptm, (LPTEXTMETRICA)pfe->lpTextMetric );
 491
 492             return pfe->lpEnumFunc( (LPENUMLOGFONTEXW)&logfont,
 493                                 pfe->lpTextMetric, fType, pfe->lpData );
 494         }
 495     }
 496 #undef pfe
 497     return 1;
 498 }
 499
 500 /***********************************************************************
 501  *              EnumFontFamiliesEx16    (GDI.613)
 502  */
 503 INT16 WINAPI EnumFontFamiliesEx16( HDC16 hDC, LPLOGFONT16 plf,
 504                                    FONTENUMPROCEX16 efproc, LPARAM lParam,
 505                                    DWORD dwFlags)
 506 {
 507     INT16       retVal = 0;
 508     DC*         dc = (DC*) GDI_GetObjPtr( hDC, DC_MAGIC );
 509
 510     if( dc && dc->funcs->pEnumDeviceFonts )
 511     {
 512         LPNEWTEXTMETRICEX16     lptm16 = SEGPTR_ALLOC( sizeof(NEWTEXTMETRICEX16) );
 513         if( lptm16 )
 514         {
 515             LPENUMLOGFONTEX16   lplf16 = SEGPTR_ALLOC( sizeof(ENUMLOGFONTEX16) );
 516             if( lplf16 )
 517             {
 518                 fontEnum16      fe16;
 519
 520                 fe16.lpLogFontParam = plf;
 521                 fe16.lpEnumFunc = efproc;
 522                 fe16.lpData = lParam;
 523
 524                 fe16.lpTextMetric = lptm16;
 525                 fe16.lpLogFont = lplf16;
 526                 fe16.segTextMetric = SEGPTR_GET(lptm16);
 527                 fe16.segLogFont = SEGPTR_GET(lplf16);
 528
 529                 retVal = dc->funcs->pEnumDeviceFonts( dc, plf, FONT_EnumInstance16, (LPARAM)&fe16 );
 530
 531                 SEGPTR_FREE(lplf16);
 532             }
 533             SEGPTR_FREE(lptm16);
 534         }
 535     }
 536     return retVal;
 537 }
 538
 539 /***********************************************************************
 540  *              FONT_EnumFontFamiliesEx
 541  */
 542 static INT FONT_EnumFontFamiliesEx( HDC hDC, LPLOGFONTW plf, FONTENUMPROCEXW efproc,
 543                                                    LPARAM lParam, DWORD dwUnicode)
 544 {
 545     DC*         dc = (DC*) GDI_GetObjPtr( hDC, DC_MAGIC );
 546
 547     if( dc && dc->funcs->pEnumDeviceFonts )
 548     {
 549         LOGFONT16               lf16;
 550         NEWTEXTMETRICEXW        tm32w;
 551         ENUMLOGFONTEXW  lf32w;
 552         fontEnum32              fe32;
 553
 554         fe32.lpLogFontParam = plf;
 555         fe32.lpEnumFunc = efproc;
 556         fe32.lpData = lParam;
 557
 558         fe32.lpTextMetric = &tm32w;
 559         fe32.lpLogFont = &lf32w;
 560         fe32.dwFlags = dwUnicode;
 561
 562         /* the only difference between LOGFONT32A and LOGFONT32W is in the lfFaceName */
 563
 564         if( plf->lfFaceName[0] )
 565         {
 566             if( dwUnicode )
 567                 lstrcpynWtoA( lf16.lfFaceName, plf->lfFaceName, LF_FACESIZE );
 568             else
 569                 lstrcpynA( lf16.lfFaceName, (LPCSTR)plf->lfFaceName, LF_FACESIZE );
 570         }
 571         else lf16.lfFaceName[0] = '\0';
 572         lf16.lfCharSet = plf->lfCharSet;
 573
 574         return dc->funcs->pEnumDeviceFonts( dc, &lf16, FONT_EnumInstance, (LPARAM)&fe32 );
 575     }
 576     return 0;
 577 }
 578
 579 /***********************************************************************
 580  *              EnumFontFamiliesExW     (GDI32.82)
 581  */
 582 INT WINAPI EnumFontFamiliesExW( HDC hDC, LPLOGFONTW plf,
 583                                     FONTENUMPROCEXW efproc,
 584                                     LPARAM lParam, DWORD dwFlags )
 585 {
 586     return  FONT_EnumFontFamiliesEx( hDC, plf, efproc, lParam, ENUM_UNICODE );
 587 }
 588
 589 /***********************************************************************
 590  *              EnumFontFamiliesExA     (GDI32.81)
 591  */
 592 INT WINAPI EnumFontFamiliesExA( HDC hDC, LPLOGFONTA plf,
 593                                     FONTENUMPROCEXA efproc,
 594                                     LPARAM lParam, DWORD dwFlags)
 595 {
 596     return  FONT_EnumFontFamiliesEx( hDC, (LPLOGFONTW)plf,
 597                                       (FONTENUMPROCEXW)efproc, lParam, 0);
 598 }
 599
 600 /***********************************************************************
 601  *              EnumFontFamilies16      (GDI.330)
 602  */
 603 INT16 WINAPI EnumFontFamilies16( HDC16 hDC, LPCSTR lpFamily,
 604                                  FONTENUMPROC16 efproc, LPARAM lpData )
 605 {
 606     LOGFONT16   lf;
 607
 608     lf.lfCharSet = DEFAULT_CHARSET;
 609     if( lpFamily ) lstrcpynA( lf.lfFaceName, lpFamily, LF_FACESIZE );
 610     else lf.lfFaceName[0] = '\0';
 611
 612     return EnumFontFamiliesEx16( hDC, &lf, (FONTENUMPROCEX16)efproc, lpData, 0 );
 613 }
 614
 615 /***********************************************************************
 616  *              EnumFontFamiliesA       (GDI32.80)
 617  */
 618 INT WINAPI EnumFontFamiliesA( HDC hDC, LPCSTR lpFamily,
 619                                   FONTENUMPROCA efproc, LPARAM lpData )
 620 {
 621     LOGFONTA    lf;
 622
 623     lf.lfCharSet = DEFAULT_CHARSET;
 624     if( lpFamily ) lstrcpynA( lf.lfFaceName, lpFamily, LF_FACESIZE );
 625     else lf.lfFaceName[0] = lf.lfFaceName[1] = '\0';
 626
 627     return FONT_EnumFontFamiliesEx( hDC, (LPLOGFONTW)&lf,
 628                                            (FONTENUMPROCEXW)efproc, lpData, 0 );
 629 }
 630
 631 /***********************************************************************
 632  *              EnumFontFamiliesW       (GDI32.83)
 633  */
 634 INT WINAPI EnumFontFamiliesW( HDC hDC, LPCWSTR lpFamily,
 635                                   FONTENUMPROCW efproc, LPARAM lpData )
 636 {
 637     LOGFONTW  lf;
 638
 639     lf.lfCharSet = DEFAULT_CHARSET;
 640     if( lpFamily ) lstrcpynW( lf.lfFaceName, lpFamily, LF_FACESIZE );
 641     else lf.lfFaceName[0] = 0;
 642
 643     return FONT_EnumFontFamiliesEx( hDC, &lf, (FONTENUMPROCEXW)efproc,
 644                                                 lpData, ENUM_UNICODE );
 645 }
 646
 647 /***********************************************************************
 648  *              EnumFonts16             (GDI.70)
 649  */
 650 INT16 WINAPI EnumFonts16( HDC16 hDC, LPCSTR lpName, FONTENUMPROC16 efproc,
 651                           LPARAM lpData )
 652 {
 653     return EnumFontFamilies16( hDC, lpName, (FONTENUMPROCEX16)efproc, lpData );
 654 }
 655
 656 /***********************************************************************
 657  *              EnumFontsA              (GDI32.84)
 658  */
 659 INT WINAPI EnumFontsA( HDC hDC, LPCSTR lpName, FONTENUMPROCA efproc,
 660                            LPARAM lpData )
 661 {
 662     return EnumFontFamiliesA( hDC, lpName, efproc, lpData );
 663 }
 664
 665 /***********************************************************************
 666  *              EnumFontsW              (GDI32.85)
 667  */
 668 INT WINAPI EnumFontsW( HDC hDC, LPCWSTR lpName, FONTENUMPROCW efproc,
 669                            LPARAM lpData )
 670 {
 671     return EnumFontFamiliesW( hDC, lpName, efproc, lpData );
 672 }
 673
 674
 675 /***********************************************************************
 676  *           GetTextCharacterExtra16    (GDI.89)
 677  */
 678 INT16 WINAPI GetTextCharacterExtra16( HDC16 hdc )
 679 {
 680     DC * dc = (DC *) GDI_GetObjPtr( hdc, DC_MAGIC );
 681     if (!dc) return 0;
 682     return abs( (dc->w.charExtra * dc->wndExtX + dc->vportExtX / 2)
 683                  / dc->vportExtX );
 684 }
 685
 686
 687 /***********************************************************************
 688  *           GetTextCharacterExtra    (GDI32.225)
 689  */
 690 INT WINAPI GetTextCharacterExtra( HDC hdc )
 691 {
 692     DC * dc = (DC *) GDI_GetObjPtr( hdc, DC_MAGIC );
 693     if (!dc) return 0;
 694     return abs( (dc->w.charExtra * dc->wndExtX + dc->vportExtX / 2)
 695                  / dc->vportExtX );
 696 }
 697
 698
 699 /***********************************************************************
 700  *           SetTextCharacterExtra16    (GDI.8)
 701  */
 702 INT16 WINAPI SetTextCharacterExtra16( HDC16 hdc, INT16 extra )
 703 {
 704     return (INT16)SetTextCharacterExtra( hdc, extra );
 705 }
 706
 707
 708 /***********************************************************************
 709  *           SetTextCharacterExtra    (GDI32.337)
 710  */
 711 INT WINAPI SetTextCharacterExtra( HDC hdc, INT extra )
 712 {
 713     INT prev;
 714     DC * dc = DC_GetDCPtr( hdc );
 715     if (!dc) return 0;
 716     if (dc->funcs->pSetTextCharacterExtra)
 717         return dc->funcs->pSetTextCharacterExtra( dc, extra );
 718     extra = (extra * dc->vportExtX + dc->wndExtX / 2) / dc->wndExtX;
 719     prev = dc->w.charExtra;
 720     dc->w.charExtra = abs(extra);
 721     return (prev * dc->wndExtX + dc->vportExtX / 2) / dc->vportExtX;
 722 }
 723
 724
 725 /***********************************************************************
 726  *           SetTextJustification16    (GDI.10)
 727  */
 728 INT16 WINAPI SetTextJustification16( HDC16 hdc, INT16 extra, INT16 breaks )
 729 {
 730     return SetTextJustification( hdc, extra, breaks );
 731 }
 732
 733
 734 /***********************************************************************
 735  *           SetTextJustification    (GDI32.339)
 736  */
 737 BOOL WINAPI SetTextJustification( HDC hdc, INT extra, INT breaks )
 738 {
 739     DC * dc = DC_GetDCPtr( hdc );
 740     if (!dc) return 0;
 741     if (dc->funcs->pSetTextJustification)
 742         return dc->funcs->pSetTextJustification( dc, extra, breaks );
 743
 744     extra = abs((extra * dc->vportExtX + dc->wndExtX / 2) / dc->wndExtX);
 745     if (!extra) breaks = 0;
 746     dc->w.breakTotalExtra = extra;
 747     dc->w.breakCount = breaks;
 748     if (breaks)
 749     {
 750         dc->w.breakExtra = extra / breaks;
 751         dc->w.breakRem   = extra - (dc->w.breakCount * dc->w.breakExtra);
 752     }
 753     else
 754     {
 755         dc->w.breakExtra = 0;
 756         dc->w.breakRem   = 0;
 757     }
 758     return 1;
 759 }
 760
 761
 762 /***********************************************************************
 763  *           GetTextFace16    (GDI.92)
 764  */
 765 INT16 WINAPI GetTextFace16( HDC16 hdc, INT16 count, LPSTR name )
 766 {
 767         return GetTextFaceA(hdc,count,name);
 768 }
 769
 770 /***********************************************************************
 771  *           GetTextFaceA    (GDI32.234)
 772  */
 773 INT WINAPI GetTextFaceA( HDC hdc, INT count, LPSTR name )
 774 {
 775     FONTOBJ *font;
 776
 777     DC * dc = (DC *) GDI_GetObjPtr( hdc, DC_MAGIC );
 778     if (!dc) return 0;
 779     if (!(font = (FONTOBJ *) GDI_GetObjPtr( dc->w.hFont, FONT_MAGIC )))
 780         return 0;
 781     if (name)
 782         lstrcpynA( name, font->logfont.lfFaceName, count );
 783     GDI_HEAP_UNLOCK( dc->w.hFont );
 784     if (name)
 785         return strlen(name);
 786     else
 787         return strlen(font->logfont.lfFaceName) + 1;
 788 }
 789
 790 /***********************************************************************
 791  *           GetTextFaceW    (GDI32.235)
 792  */
 793 INT WINAPI GetTextFaceW( HDC hdc, INT count, LPWSTR name )
 794 {
 795     LPSTR nameA = HeapAlloc( GetProcessHeap(), 0, count );
 796     INT res = GetTextFaceA(hdc,count,nameA);
 797     lstrcpyAtoW( name, nameA );
 798     HeapFree( GetProcessHeap(), 0, nameA );
 799     return res;
 800 }
 801
 802
 803 /***********************************************************************
 804  *           GetTextExtent16    (GDI.91)
 805  */
 806 DWORD WINAPI GetTextExtent16( HDC16 hdc, LPCSTR str, INT16 count )
 807 {
 808     SIZE16 size;
 809     if (!GetTextExtentPoint16( hdc, str, count, &size )) return 0;
 810     return MAKELONG( size.cx, size.cy );
 811 }
 812
 813
 814 /***********************************************************************
 815  *           GetTextExtentPoint16    (GDI.471)
 816  *
 817  * FIXME: Should this have a bug for compatibility?
 818  * Original Windows versions of GetTextExtentPoint{A,W} have documented
 819  * bugs (-> MSDN KB q147647.txt).
 820  */
 821 BOOL16 WINAPI GetTextExtentPoint16( HDC16 hdc, LPCSTR str, INT16 count,
 822                                     LPSIZE16 size )
 823 {
 824     SIZE size32;
 825     BOOL ret = GetTextExtentPoint32A( hdc, str, count, &size32 );
 826     CONV_SIZE32TO16( &size32, size );
 827     return (BOOL16)ret;
 828 }
 829
 830
 831 /***********************************************************************
 832  *           GetTextExtentPoint32A    (GDI32.230)
 833  */
 834 BOOL WINAPI GetTextExtentPoint32A( HDC hdc, LPCSTR str, INT count,
 835                                      LPSIZE size )
 836 {
 837     DC * dc = (DC *) GDI_GetObjPtr( hdc, DC_MAGIC );
 838     if (!dc)
 839     {
 840         if (!(dc = (DC *)GDI_GetObjPtr( hdc, METAFILE_DC_MAGIC )))
 841             return FALSE;
 842     }
 843
 844     if (!dc->funcs->pGetTextExtentPoint ||
 845         !dc->funcs->pGetTextExtentPoint( dc, str, count, size ))
 846         return FALSE;
 847
 848     TRACE_(font)("(%08x %s %d %p): returning %d,%d\n",
 849                  hdc, debugstr_an (str, count), count,
 850                  size, size->cx, size->cy );
 851     return TRUE;
 852 }
 853
 854
 855 /***********************************************************************
 856  * GetTextExtentPoint32W [GDI32.231]  Computes width/height for a string
 857  *
 858  * Computes width and height of the specified string.
 859  *
 860  * RETURNS
 861  *    Success: TRUE
 862  *    Failure: FALSE
 863  */
 864 BOOL WINAPI GetTextExtentPoint32W(
 865     HDC hdc,     /* [in]  Handle of device context */
 866     LPCWSTR str,   /* [in]  Address of text string */
 867     INT count,   /* [in]  Number of characters in string */
 868     LPSIZE size) /* [out] Address of structure for string size */
 869 {
 870     LPSTR p;
 871     BOOL ret;
 872
 873   /* str may not be 0 terminated so we can't use HEAP_strdupWtoA.
 874    * We allocate one more than we need so that lstrcpynWtoA can write a
 875    * trailing 0 if it wants.
 876    */
 877
 878     if(!count) count = lstrlenW(str);
 879     p = HeapAlloc( GetProcessHeap(), 0, count+1 );
 880     lstrcpynWtoA(p, str, count+1);
 881     ret = GetTextExtentPoint32A( hdc, p, count, size );
 882     HeapFree( GetProcessHeap(), 0, p );
 883     return ret;
 884 }
 885
 886
 887 /***********************************************************************
 888  *           GetTextExtentPointA    (GDI32.232)
 889  */
 890 BOOL WINAPI GetTextExtentPointA( HDC hdc, LPCSTR str, INT count,
 891                                           LPSIZE size )
 892 {
 893     TRACE_(font)("not bug compatible.\n");
 894     return GetTextExtentPoint32A( hdc, str, count, size );
 895 }
 896
 897 /***********************************************************************
 898  *           GetTextExtentPointW   (GDI32.233)
 899  */
 900 BOOL WINAPI GetTextExtentPointW( HDC hdc, LPCWSTR str, INT count,
 901                                           LPSIZE size )
 902 {
 903     TRACE_(font)("not bug compatible.\n");
 904     return GetTextExtentPoint32W( hdc, str, count, size );
 905 }
 906
 907
 908 /***********************************************************************
 909  *           GetTextExtentExPointA    (GDI32.228)
 910  */
 911 BOOL WINAPI GetTextExtentExPointA( HDC hdc, LPCSTR str, INT count,
 912                                        INT maxExt, LPINT lpnFit,
 913                                        LPINT alpDx, LPSIZE size )
 914 {
 915     int index, nFit, extent;
 916     SIZE tSize;
 917     DC * dc = (DC *) GDI_GetObjPtr( hdc, DC_MAGIC );
 918
 919     if (!dc)
 920     {
 921         if (!(dc = (DC *)GDI_GetObjPtr( hdc, METAFILE_DC_MAGIC )))
 922             return FALSE;
 923     }
 924     if (!dc->funcs->pGetTextExtentPoint) return FALSE;
 925
 926     size->cx = size->cy = nFit = extent = 0;
 927     for(index = 0; index < count; index++)
 928     {
 929         if(!dc->funcs->pGetTextExtentPoint( dc, str, 1, &tSize )) return FALSE;
 930         if( extent+tSize.cx < maxExt )
 931         {
 932             extent+=tSize.cx;
 933             nFit++;
 934             str++;
 935             if( alpDx ) alpDx[index] = extent;
 936             if( tSize.cy > size->cy ) size->cy = tSize.cy;
 937         }
 938         else break;
 939     }
 940     size->cx = extent;
 941    *lpnFit = nFit;
 942
 943     TRACE_(font)("(%08x '%.*s' %d) returning %d %d %d\n",
 944                hdc,count,str,maxExt,nFit, size->cx,size->cy);
 945     return TRUE;
 946 }
 947
 948
 949 /***********************************************************************
 950  *           GetTextExtentExPointW    (GDI32.229)
 951  */
 952
 953 BOOL WINAPI GetTextExtentExPointW( HDC hdc, LPCWSTR str, INT count,
 954                                        INT maxExt, LPINT lpnFit,
 955                                        LPINT alpDx, LPSIZE size )
 956 {
 957     LPSTR p;
 958     BOOL ret;
 959
 960   /* Docs say str should be 0 terminated here, but we'll use count just in case
 961    */
 962
 963     if(!count) count = lstrlenW(str);
 964     p = HeapAlloc( GetProcessHeap(), 0, count+1 );
 965     lstrcpynWtoA(p, str, count+1);
 966     ret = GetTextExtentExPointA( hdc, p, count, maxExt,
 967                                         lpnFit, alpDx, size);
 968     HeapFree( GetProcessHeap(), 0, p );
 969     return ret;
 970 }
 971
 972 /***********************************************************************
 973  *           GetTextMetrics16    (GDI.93)
 974  */
 975 BOOL16 WINAPI GetTextMetrics16( HDC16 hdc, TEXTMETRIC16 *metrics )
 976 {
 977     TEXTMETRICA tm32;
 978
 979     if (!GetTextMetricsA( (HDC)hdc, &tm32 )) return FALSE;
 980     FONT_TextMetric32Ato16( &tm32, metrics );
 981     return TRUE;
 982 }
 983
 984
 985 /***********************************************************************
 986  *           GetTextMetricsA    (GDI32.236)
 987  */
 988 BOOL WINAPI GetTextMetricsA( HDC hdc, TEXTMETRICA *metrics )
 989 {
 990     DC * dc = (DC *) GDI_GetObjPtr( hdc, DC_MAGIC );
 991     if (!dc)
 992     {
 993         if (!(dc = (DC *)GDI_GetObjPtr( hdc, METAFILE_DC_MAGIC )))
 994             return FALSE;
 995     }
 996
 997     if (!dc->funcs->pGetTextMetrics ||
 998         !dc->funcs->pGetTextMetrics( dc, metrics ))
 999         return FALSE;
1000
1001     /* device layer returns values in device units
1002      * therefore we have to convert them to logical */
1003
1004 #define WDPTOLP(x) ((x<0)?                                      \
1005                 (-abs((x)*dc->wndExtX/dc->vportExtX)):          \
1006                 (abs((x)*dc->wndExtX/dc->vportExtX)))
1007 #define HDPTOLP(y) ((y<0)?                                      \
1008                 (-abs((y)*dc->wndExtY/dc->vportExtY)):          \
1009                 (abs((y)*dc->wndExtY/dc->vportExtY)))
1010
1011     metrics->tmHeight           = HDPTOLP(metrics->tmHeight);
1012     metrics->tmAscent           = HDPTOLP(metrics->tmAscent);
1013     metrics->tmDescent          = HDPTOLP(metrics->tmDescent);
1014     metrics->tmInternalLeading  = HDPTOLP(metrics->tmInternalLeading);
1015     metrics->tmExternalLeading  = HDPTOLP(metrics->tmExternalLeading);
1016     metrics->tmAveCharWidth     = WDPTOLP(metrics->tmAveCharWidth);
1017     metrics->tmMaxCharWidth     = WDPTOLP(metrics->tmMaxCharWidth);
1018     metrics->tmOverhang         = WDPTOLP(metrics->tmOverhang);
1019
1020     TRACE_(font)("text metrics:\n"
1021     "    Weight = %03li\t FirstChar = %03i\t AveCharWidth = %li\n"
1022     "    Italic = % 3i\t LastChar = %03i\t\t MaxCharWidth = %li\n"
1023     "    UnderLined = %01i\t DefaultChar = %03i\t Overhang = %li\n"
1024     "    StruckOut = %01i\t BreakChar = %03i\t CharSet = %i\n"
1025     "    PitchAndFamily = %02x\n"
1026     "    --------------------\n"
1027     "    InternalLeading = %li\n"
1028     "    Ascent = %li\n"
1029     "    Descent = %li\n"
1030     "    Height = %li\n",
1031     metrics->tmWeight, metrics->tmFirstChar, metrics->tmAveCharWidth,
1032     metrics->tmItalic, metrics->tmLastChar, metrics->tmMaxCharWidth,
1033     metrics->tmUnderlined, metrics->tmDefaultChar, metrics->tmOverhang,
1034     metrics->tmStruckOut, metrics->tmBreakChar, metrics->tmCharSet,
1035     metrics->tmPitchAndFamily,
1036     metrics->tmInternalLeading,
1037     metrics->tmAscent,
1038     metrics->tmDescent,
1039     metrics->tmHeight );
1040     return TRUE;
1041 }
1042
1043
1044 /***********************************************************************
1045  *           GetTextMetricsW    (GDI32.237)
1046  */
1047 BOOL WINAPI GetTextMetricsW( HDC hdc, TEXTMETRICW *metrics )
1048 {
1049     TEXTMETRICA tm;
1050     if (!GetTextMetricsA( (HDC16)hdc, &tm )) return FALSE;
1051     FONT_TextMetric32Ato32W( &tm, metrics );
1052     return TRUE;
1053 }
1054
1055
1056 /***********************************************************************
1057  * GetOutlineTextMetrics16 [GDI.308]  Gets metrics for TrueType fonts.
1058  *
1059  * NOTES
1060  *    lpOTM should be LPOUTLINETEXTMETRIC
1061  *
1062  * RETURNS
1063  *    Success: Non-zero or size of required buffer
1064  *    Failure: 0
1065  */
1066 UINT16 WINAPI GetOutlineTextMetrics16(
1067     HDC16 hdc,    /* [in]  Handle of device context */
1068     UINT16 cbData, /* [in]  Size of metric data array */
1069     LPOUTLINETEXTMETRIC16 lpOTM)  /* [out] Address of metric data array */
1070 {
1071     FIXME_(font)("(%04x,%04x,%p): stub\n", hdc,cbData,lpOTM);
1072     return 0;
1073 }
1074
1075
1076 /***********************************************************************
1077  * GetOutlineTextMetricsA [GDI.207]  Gets metrics for TrueType fonts.
1078  *
1079  *
1080  * RETURNS
1081  *    Success: Non-zero or size of required buffer
1082  *    Failure: 0
1083  */
1084 UINT WINAPI GetOutlineTextMetricsA(
1085     HDC hdc,    /* [in]  Handle of device context */
1086     UINT cbData, /* [in]  Size of metric data array */
1087     LPOUTLINETEXTMETRICA lpOTM)  /* [out] Address of metric data array */
1088 {
1089
1090
1091     UINT rtn = FALSE;
1092     LPTEXTMETRICA lptxtMetr;
1093
1094
1095
1096     if (lpOTM == 0)
1097     {
1098
1099         lpOTM = (LPOUTLINETEXTMETRICA)HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,sizeof(OUTLINETEXTMETRICA));
1100         rtn = sizeof(OUTLINETEXTMETRICA);
1101         cbData = rtn;
1102     } else
1103     {
1104         cbData = sizeof(*lpOTM);
1105         rtn = cbData;
1106     };
1107
1108     lpOTM->otmSize = cbData;
1109
1110     lptxtMetr =HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,sizeof(TEXTMETRICA));
1111
1112     if (!GetTextMetricsA(hdc,lptxtMetr))
1113     {
1114         return 0;
1115     } else
1116     {
1117        memcpy(&(lpOTM->otmTextMetrics),lptxtMetr,sizeof(TEXTMETRICA));
1118     };
1119
1120     HeapFree(GetProcessHeap(),HEAP_ZERO_MEMORY,lptxtMetr);
1121
1122     lpOTM->otmFilter = 0;
1123
1124     lpOTM->otmPanoseNumber.bFamilyType  = 0;
1125     lpOTM->otmPanoseNumber.bSerifStyle  = 0;
1126     lpOTM->otmPanoseNumber.bWeight      = 0;
1127     lpOTM->otmPanoseNumber.bProportion  = 0;
1128     lpOTM->otmPanoseNumber.bContrast    = 0;
1129     lpOTM->otmPanoseNumber.bStrokeVariation = 0;
1130     lpOTM->otmPanoseNumber.bArmStyle    = 0;
1131     lpOTM->otmPanoseNumber.bLetterform  = 0;
1132     lpOTM->otmPanoseNumber.bMidline     = 0;
1133     lpOTM->otmPanoseNumber.bXHeight     = 0;
1134
1135     lpOTM->otmfsSelection     = 0;
1136     lpOTM->otmfsType          = 0;
1137
1138     /*
1139      Further fill of the structure not implemented,
1140      Needs real values for the structure members
1141      */
1142
1143     return rtn;
1144 }
1145
1146 /***********************************************************************
1147  *           GetOutlineTextMetricsW [GDI32.208]
1148  */
1149 UINT WINAPI GetOutlineTextMetricsW(
1150     HDC hdc,    /* [in]  Handle of device context */
1151     UINT cbData, /* [in]  Size of metric data array */
1152     LPOUTLINETEXTMETRICW lpOTM)  /* [out] Address of metric data array */
1153 {
1154     FIXME_(font)("(%d,%d,%p): stub\n", hdc, cbData, lpOTM);
1155     return 0;
1156 }
1157
1158 /***********************************************************************
1159  *           GetCharWidth16    (GDI.350)
1160  */
1161 BOOL16 WINAPI GetCharWidth16( HDC16 hdc, UINT16 firstChar, UINT16 lastChar,
1162                               LPINT16 buffer )
1163 {
1164     BOOL        retVal = FALSE;
1165
1166     if( firstChar != lastChar )
1167     {
1168         LPINT   buf32 = (LPINT)HeapAlloc(GetProcessHeap(), 0,
1169                                  sizeof(INT)*(1 + (lastChar - firstChar)));
1170         if( buf32 )
1171         {
1172             LPINT       obuf32 = buf32;
1173             int         i;
1174
1175             retVal = GetCharWidth32A(hdc, firstChar, lastChar, buf32);
1176             if (retVal)
1177             {
1178                 for (i = firstChar; i <= lastChar; i++)
1179                     *buffer++ = *buf32++;
1180             }
1181             HeapFree(GetProcessHeap(), 0, obuf32);
1182         }
1183     }
1184     else /* happens quite often to warrant a special treatment */
1185     {
1186         INT chWidth;
1187         retVal = GetCharWidth32A(hdc, firstChar, lastChar, &chWidth );
1188        *buffer = chWidth;
1189     }
1190     return retVal;
1191 }
1192
1193
1194 /***********************************************************************
1195  *           GetCharWidth32A    (GDI32.155)
1196  */
1197 BOOL WINAPI GetCharWidth32A( HDC hdc, UINT firstChar, UINT lastChar,
1198                                LPINT buffer )
1199 {
1200     UINT i, extra;
1201     DC * dc = (DC *) GDI_GetObjPtr( hdc, DC_MAGIC );
1202     if (!dc)
1203     {
1204         if (!(dc = (DC *)GDI_GetObjPtr( hdc, METAFILE_DC_MAGIC )))
1205             return FALSE;
1206     }
1207
1208     if (!dc->funcs->pGetCharWidth ||
1209         !dc->funcs->pGetCharWidth( dc, firstChar, lastChar, buffer))
1210         return FALSE;
1211
1212     /* convert device units to logical */
1213
1214     extra = dc->vportExtX >> 1;
1215     for( i = firstChar; i <= lastChar; i++, buffer++ )
1216          *buffer = (*buffer * dc->wndExtX + extra) / dc->vportExtX;
1217
1218     return TRUE;
1219 }
1220
1221
1222 /***********************************************************************
1223  *           GetCharWidth32W    (GDI32.158)
1224  */
1225 BOOL WINAPI GetCharWidth32W( HDC hdc, UINT firstChar, UINT lastChar,
1226                                LPINT buffer )
1227 {
1228     return GetCharWidth32A( hdc, firstChar, lastChar, buffer );
1229 }
1230
1231
1232
1233 /* FIXME: all following APIs *******************************************
1234  *
1235  *
1236  *           SetMapperFlags16    (GDI.349)
1237  */
1238 DWORD WINAPI SetMapperFlags16( HDC16 hDC, DWORD dwFlag )
1239 {
1240     return SetMapperFlags( hDC, dwFlag );
1241 }
1242
1243
1244 /***********************************************************************
1245  *           SetMapperFlags    (GDI32.322)
1246  */
1247 DWORD WINAPI SetMapperFlags( HDC hDC, DWORD dwFlag )
1248 {
1249     DC *dc = DC_GetDCPtr( hDC );
1250     DWORD ret = 0;
1251     if(!dc) return 0;
1252     if(dc->funcs->pSetMapperFlags)
1253         ret = dc->funcs->pSetMapperFlags( dc, dwFlag );
1254     else
1255         FIXME_(font)("(0x%04x, 0x%08lx): stub - harmless\n", hDC, dwFlag);
1256     GDI_HEAP_UNLOCK( hDC );
1257     return ret;
1258 }
1259
1260 /***********************************************************************
1261  *          GetAspectRatioFilterEx16  (GDI.486)
1262  */
1263 BOOL16 WINAPI GetAspectRatioFilterEx16( HDC16 hdc, LPSIZE16 pAspectRatio )
1264 {
1265   FIXME_(font)("(%04x, %p): -- Empty Stub !\n",
1266                 hdc, pAspectRatio);
1267   return FALSE;
1268 }
1269
1270 /***********************************************************************
1271  *          GetAspectRatioFilterEx  (GDI32.142)
1272  */
1273 BOOL WINAPI GetAspectRatioFilterEx( HDC hdc, LPSIZE pAspectRatio )
1274 {
1275   FIXME_(font)("(%04x, %p): -- Empty Stub !\n",
1276         hdc, pAspectRatio);
1277   return FALSE;
1278 }
1279
1280 /***********************************************************************
1281  *           GetCharABCWidths16   (GDI.307)
1282  */
1283 BOOL16 WINAPI GetCharABCWidths16( HDC16 hdc, UINT16 firstChar, UINT16 lastChar,
1284                                   LPABC16 abc )
1285 {
1286     ABC abc32;
1287     if (!GetCharABCWidthsA( hdc, firstChar, lastChar, &abc32 )) return FALSE;
1288     abc->abcA = abc32.abcA;
1289     abc->abcB = abc32.abcB;
1290     abc->abcC = abc32.abcC;
1291     return TRUE;
1292 }
1293
1294
1295 /***********************************************************************
1296  *           GetCharABCWidthsA   (GDI32.149)
1297  */
1298 BOOL WINAPI GetCharABCWidthsA(HDC hdc, UINT firstChar, UINT lastChar,
1299                                   LPABC abc )
1300 {
1301     return GetCharABCWidthsW( hdc, firstChar, lastChar, abc );
1302 }
1303
1304
1305 /******************************************************************************
1306  * GetCharABCWidthsW [GDI32.152]  Retrieves widths of characters in range
1307  *
1308  * PARAMS
1309  *    hdc       [I] Handle of device context
1310  *    firstChar [I] First character in range to query
1311  *    lastChar  [I] Last character in range to query
1312  *    abc       [O] Address of character-width structure
1313  *
1314  * NOTES
1315  *    Only works with TrueType fonts
1316  *
1317  * RETURNS
1318  *    Success: TRUE
1319  *    Failure: FALSE
1320  */
1321 BOOL WINAPI GetCharABCWidthsW( HDC hdc, UINT firstChar, UINT lastChar,
1322                                    LPABC abc )
1323 {
1324     /* No TrueType fonts in Wine so far */
1325     FIXME_(font)("(%04x,%04x,%04x,%p): stub\n", hdc, firstChar, lastChar, abc);
1326     return FALSE;
1327 }
1328
1329
1330 /***********************************************************************
1331  *           GetGlyphOutline16    (GDI.309)
1332  */
1333 DWORD WINAPI GetGlyphOutline16( HDC16 hdc, UINT16 uChar, UINT16 fuFormat,
1334                                 LPGLYPHMETRICS16 lpgm, DWORD cbBuffer,
1335                                 LPVOID lpBuffer, const MAT2 *lpmat2 )
1336 {
1337     FIXME_(font)("(%04x, '%c', %04x, %p, %ld, %p, %p): stub\n",
1338           hdc, uChar, fuFormat, lpgm, cbBuffer, lpBuffer, lpmat2 );
1339     return (DWORD)-1; /* failure */
1340 }
1341
1342
1343 /***********************************************************************
1344  *           GetGlyphOutlineA    (GDI32.186)
1345  */
1346 DWORD WINAPI GetGlyphOutlineA( HDC hdc, UINT uChar, UINT fuFormat,
1347                                  LPGLYPHMETRICS lpgm, DWORD cbBuffer,
1348                                  LPVOID lpBuffer, const MAT2 *lpmat2 )
1349 {
1350     FIXME_(font)("(%04x, '%c', %04x, %p, %ld, %p, %p): stub\n",
1351           hdc, uChar, fuFormat, lpgm, cbBuffer, lpBuffer, lpmat2 );
1352     return (DWORD)-1; /* failure */
1353 }
1354
1355 /***********************************************************************
1356  *           GetGlyphOutlineW    (GDI32.187)
1357  */
1358 DWORD WINAPI GetGlyphOutlineW( HDC hdc, UINT uChar, UINT fuFormat,
1359                                  LPGLYPHMETRICS lpgm, DWORD cbBuffer,
1360                                  LPVOID lpBuffer, const MAT2 *lpmat2 )
1361 {
1362     FIXME_(font)("(%04x, '%c', %04x, %p, %ld, %p, %p): stub\n",
1363           hdc, uChar, fuFormat, lpgm, cbBuffer, lpBuffer, lpmat2 );
1364     return (DWORD)-1; /* failure */
1365 }
1366
1367 /***********************************************************************
1368  *           CreateScalableFontResource16   (GDI.310)
1369  */
1370 BOOL16 WINAPI CreateScalableFontResource16( UINT16 fHidden,
1371                                             LPCSTR lpszResourceFile,
1372                                             LPCSTR fontFile, LPCSTR path )
1373 {
1374     return CreateScalableFontResourceA( fHidden, lpszResourceFile,
1375                                           fontFile, path );
1376 }
1377
1378 /***********************************************************************
1379  *           CreateScalableFontResourceA   (GDI32.62)
1380  */
1381 BOOL WINAPI CreateScalableFontResourceA( DWORD fHidden,
1382                                              LPCSTR lpszResourceFile,
1383                                              LPCSTR lpszFontFile,
1384                                              LPCSTR lpszCurrentPath )
1385 {
1386     /* fHidden=1 - only visible for the calling app, read-only, not
1387      * enumbered with EnumFonts/EnumFontFamilies
1388      * lpszCurrentPath can be NULL
1389      */
1390     FIXME_(font)("(%ld,%s,%s,%s): stub\n",
1391           fHidden, lpszResourceFile, lpszFontFile, lpszCurrentPath );
1392     return FALSE; /* create failed */
1393 }
1394
1395 /***********************************************************************
1396  *           CreateScalableFontResourceW   (GDI32.63)
1397  */
1398 BOOL WINAPI CreateScalableFontResourceW( DWORD fHidden,
1399                                              LPCWSTR lpszResourceFile,
1400                                              LPCWSTR lpszFontFile,
1401                                              LPCWSTR lpszCurrentPath )
1402 {
1403     FIXME_(font)("(%ld,%p,%p,%p): stub\n",
1404           fHidden, lpszResourceFile, lpszFontFile, lpszCurrentPath );
1405     return FALSE; /* create failed */
1406 }
1407
1408
1409 /*************************************************************************
1410  *             GetRasterizerCaps16   (GDI.313)
1411  */
1412 BOOL16 WINAPI GetRasterizerCaps16( LPRASTERIZER_STATUS lprs, UINT16 cbNumBytes)
1413 {
1414     return GetRasterizerCaps( lprs, cbNumBytes );
1415 }
1416
1417
1418 /*************************************************************************
1419  *             GetRasterizerCaps   (GDI32.216)
1420  */
1421 BOOL WINAPI GetRasterizerCaps( LPRASTERIZER_STATUS lprs, UINT cbNumBytes)
1422 {
1423   lprs->nSize = sizeof(RASTERIZER_STATUS);
1424   lprs->wFlags = TT_AVAILABLE|TT_ENABLED;
1425   lprs->nLanguageID = 0;
1426   return TRUE;
1427 }
1428
1429
1430 /*************************************************************************
1431  *             GetKerningPairs16   (GDI.332)
1432  */
1433 INT16 WINAPI GetKerningPairs16( HDC16 hDC, INT16 cPairs,
1434                                 LPKERNINGPAIR16 lpKerningPairs )
1435 {
1436     /* At this time kerning is ignored (set to 0) */
1437     int i;
1438     FIXME_(font)("(%x,%d,%p): almost empty stub!\n",
1439           hDC, cPairs, lpKerningPairs);
1440     for (i = 0; i < cPairs; i++)
1441         lpKerningPairs[i].iKernAmount = 0;
1442     return 0;
1443 }
1444
1445
1446
1447 /*************************************************************************
1448  *             GetKerningPairsA   (GDI32.192)
1449  */
1450 DWORD WINAPI GetKerningPairsA( HDC hDC, DWORD cPairs,
1451                                  LPKERNINGPAIR lpKerningPairs )
1452 {
1453     int i;
1454     FIXME_(font)("(%x,%ld,%p): almost empty stub!\n",
1455           hDC, cPairs, lpKerningPairs);
1456     for (i = 0; i < cPairs; i++)
1457         lpKerningPairs[i].iKernAmount = 0;
1458     return 0;
1459 }
1460
1461
1462 /*************************************************************************
1463  *             GetKerningPairsW   (GDI32.193)
1464  */
1465 DWORD WINAPI GetKerningPairsW( HDC hDC, DWORD cPairs,
1466                                  LPKERNINGPAIR lpKerningPairs )
1467 {
1468     return GetKerningPairsA( hDC, cPairs, lpKerningPairs );
1469 }
1470
1471 /*************************************************************************
1472  * TranslateCharsetInfo [GDI32.382]
1473  *
1474  * Fills a CHARSETINFO structure for a character set, code page, or
1475  * font. This allows making the correspondance between different labelings
1476  * (character set, Windows, ANSI, and OEM codepages, and Unicode ranges)
1477  * of the same encoding.
1478  *
1479  * Only one codepage will be set in lpCs->fs. If TCI_SRCFONTSIG is used,
1480  * only one codepage should be set in *lpSrc.
1481  *
1482  * RETURNS
1483  *   TRUE on success, FALSE on failure.
1484  *
1485  */
1486 BOOL WINAPI TranslateCharsetInfo(
1487   LPDWORD lpSrc, /*
1488        if flags == TCI_SRCFONTSIG: pointer to fsCsb of a FONTSIGNATURE
1489        if flags == TCI_SRCCHARSET: a character set value
1490        if flags == TCI_SRCCODEPAGE: a code page value
1491                  */
1492   LPCHARSETINFO lpCs, /* structure to receive charset information */
1493   DWORD flags /* determines interpretation of lpSrc */
1494 ) {
1495     int index = 0;
1496     switch (flags) {
1497     case TCI_SRCFONTSIG:
1498         while (!(*lpSrc>>index & 0x0001) && index<MAXTCIINDEX) index++;
1499       break;
1500     case TCI_SRCCODEPAGE:
1501       while ((UINT) (lpSrc) != FONT_tci[index].ciACP && index < MAXTCIINDEX) index++;
1502       break;
1503     case TCI_SRCCHARSET:
1504       while ((UINT) (lpSrc) != FONT_tci[index].ciCharset && index < MAXTCIINDEX) index++;
1505       break;
1506     default:
1507       return FALSE;
1508     }
1509     if (index >= MAXTCIINDEX || FONT_tci[index].ciCharset == DEFAULT_CHARSET) return FALSE;
1510     memcpy(lpCs, &FONT_tci[index], sizeof(CHARSETINFO));
1511     return TRUE;
1512 }
1513
1514 /*************************************************************************
1515  *             GetFontLanguageInfo   (GDI32.182)
1516  */
1517 DWORD WINAPI GetFontLanguageInfo(HDC hdc) {
1518         /* return value 0 is correct for most cases anyway */
1519         FIXME_(font)("(%x):stub!\n", hdc);
1520         return 0;
1521 }
1522
1523 /*************************************************************************
1524  *             GetFontLanguageInfo   (GDI.616)
1525  */
1526 DWORD WINAPI GetFontLanguageInfo16(HDC16 hdc) {
1527         /* return value 0 is correct for most cases anyway */
1528         FIXME_(font)("(%x):stub!\n",hdc);
1529         return 0;
1530 }
1531
1532 /*************************************************************************
1533  * GetFontData [GDI32.181] Retrieve data for TrueType font
1534  *
1535  * RETURNS
1536  *
1537  * success: Number of bytes returned
1538  * failure: GDI_ERROR
1539  *
1540  * NOTES
1541  *
1542  * Calls SetLastError()
1543  *
1544  * BUGS
1545  *
1546  * Unimplemented
1547  */
1548 DWORD WINAPI GetFontData(HDC hdc, DWORD table, DWORD offset,
1549     LPVOID buffer, DWORD length)
1550 {
1551     FIXME_(font)("(%x,%ld,%ld,%p,%ld): stub\n",
1552         hdc, table, offset, buffer, length);
1553     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1554     return GDI_ERROR;
1555 }
1556
1557 /*************************************************************************
1558  * GetCharacterPlacementA [GDI32.160]
1559  *
1560  * NOTES:
1561  *  the web browser control of ie4 calls this with dwFlags=0
1562  */
1563 DWORD WINAPI
1564 GetCharacterPlacementA(HDC hdc, LPCSTR lpString, INT uCount,
1565                          INT nMaxExtent, GCP_RESULTSA *lpResults,
1566                          DWORD dwFlags)
1567 {
1568     DWORD ret=0;
1569     SIZE size;
1570
1571     TRACE_(font)("%s 0x%08x 0x%08x 0x%08lx:stub!\n",
1572       debugstr_a(lpString), uCount, nMaxExtent, dwFlags);
1573
1574     TRACE_(font)("lpOrder=%p lpDx=%p lpCaretPos=%p lpClass=%p lpOutString=%p lpGlyphs=%p\n",
1575       lpResults->lpOrder, lpResults->lpDx, lpResults->lpCaretPos, lpResults->lpClass,
1576       lpResults->lpOutString, lpResults->lpGlyphs);
1577
1578     if(dwFlags)                 FIXME_(font)("flags 0x%08lx ignored\n", dwFlags);
1579     if(lpResults->lpOrder)      FIXME_(font)("reordering not implemented\n");
1580     if(lpResults->lpCaretPos)   FIXME_(font)("caret positions not implemented\n");
1581     if(lpResults->lpClass)      FIXME_(font)("classes not implemented\n");
1582     if(lpResults->lpGlyphs)     FIXME_(font)("glyphs not implemented\n");
1583
1584     /* copy will do if the GCP_REORDER flag is not set */
1585     if(lpResults->lpOutString)
1586     {
1587       lstrcpynA(lpResults->lpOutString, lpString, uCount);
1588     }
1589
1590     if (lpResults->lpDx)
1591     {
1592       int i, c;
1593       for (i=0; i<uCount;i++)
1594       {
1595         if (GetCharWidth32A(hdc, lpString[i], lpString[i], &c))
1596           lpResults->lpDx[i]= c;
1597       }
1598     }
1599
1600     if (GetTextExtentPoint32A(hdc, lpString, uCount, &size))
1601       ret = MAKELONG(size.cx, size.cy);
1602
1603     return ret;
1604 }
1605
1606 /*************************************************************************
1607  * GetCharacterPlacementW [GDI32.161]
1608  */
1609 DWORD WINAPI
1610 GetCharacterPlacementW(HDC hdc, LPCWSTR lpString, INT uCount,
1611                          INT nMaxExtent, GCP_RESULTSW *lpResults,
1612                          DWORD dwFlags)
1613 {
1614     /* return value 0 is correct for most cases anyway */
1615     FIXME_(font)(":stub!\n");
1616     return 0;
1617 }
1618
1619 /*************************************************************************
1620  *      GetCharABCWidthsFloatA [GDI32.150]
1621  */
1622 BOOL WINAPI GetCharABCWidthsFloatA(HDC hdc, UINT iFirstChar, UINT iLastChar,
1623                                         LPABCFLOAT lpABCF)
1624 {
1625        FIXME_(gdi)("GetCharABCWidthsFloatA, stub\n");
1626        return 0;
1627 }
1628
1629 /*************************************************************************
1630  *      GetCharABCWidthsFloatW [GDI32.151]
1631  */
1632 BOOL WINAPI GetCharABCWidthsFloatW(HDC hdc, UINT iFirstChar,
1633                                         UINT iLastChar, LPABCFLOAT lpABCF)
1634 {
1635        FIXME_(gdi)("GetCharABCWidthsFloatW, stub\n");
1636        return 0;
1637 }
1638
1639 /*************************************************************************
1640  *      GetCharWidthFloatA [GDI32.156]
1641  */
1642 BOOL WINAPI GetCharWidthFloatA(HDC hdc, UINT iFirstChar,
1643                                     UINT iLastChar, PFLOAT pxBuffer)
1644 {
1645        FIXME_(gdi)("GetCharWidthFloatA, stub\n");
1646        return 0;
1647 }
1648
1649 /*************************************************************************
1650  *      GetCharWidthFloatW [GDI32.157]
1651  */
1652 BOOL WINAPI GetCharWidthFloatW(HDC hdc, UINT iFirstChar,
1653                                     UINT iLastChar, PFLOAT pxBuffer)
1654 {
1655        FIXME_(gdi)("GetCharWidthFloatW, stub\n");
1656        return 0;
1657 }
1658