objects/font.c

   1 /*
   2  * GDI font objects
   3  *
   4  * Copyright 1993 Alexandre Julliard
   5  *           1997 Alex Korobka
   6  */
   7
   8 #include <stdio.h>
   9 #include <stdlib.h>
  10 #include <string.h>
  11 #include "font.h"
  12 #include "heap.h"
  13 #include "metafile.h"
  14 #include "options.h"
  15 #include "stddebug.h"
  16 #include "debug.h"
  17 #include "debugstr.h"
  18
  19 #define ENUM_UNICODE    0x00000001
  20
  21 typedef struct
  22 {
  23   LPLOGFONT16           lpLogFontParam;
  24   FONTENUMPROCEX16      lpEnumFunc;
  25   LPARAM                lpData;
  26
  27   LPNEWTEXTMETRICEX16   lpTextMetric;
  28   LPENUMLOGFONTEX16     lpLogFont;
  29   SEGPTR                segTextMetric;
  30   SEGPTR                segLogFont;
  31 } fontEnum16;
  32
  33 typedef struct
  34 {
  35   LPLOGFONT32W          lpLogFontParam;
  36   FONTENUMPROC32W       lpEnumFunc;
  37   LPARAM                lpData;
  38
  39   LPNEWTEXTMETRICEX32W  lpTextMetric;
  40   LPENUMLOGFONTEX32W    lpLogFont;
  41   DWORD                 dwFlags;
  42 } fontEnum32;
  43
  44 /***********************************************************************
  45  *              LOGFONT conversion functions.
  46  */
  47 static void __logfont32to16( INT16* plf16, const INT32* plf32 )
  48 {
  49     int  i;
  50     for( i = 0; i < 5; i++ ) *plf16++ = *plf32++;
  51    *((INT32*)plf16)++ = *plf32++;
  52    *((INT32*)plf16)   = *plf32;
  53 }
  54
  55 static void __logfont16to32( INT32* plf32, const INT16* plf16 )
  56 {
  57     int i;
  58     for( i = 0; i < 5; i++ ) *plf32++ = *plf16++;
  59    *plf32++ = *((INT32*)plf16)++;
  60    *plf32   = *((INT32*)plf16);
  61 }
  62
  63 void FONT_LogFont32ATo16( const LOGFONT32A* font32, LPLOGFONT16 font16 )
  64 {
  65   __logfont32to16( (INT16*)font16, (const INT32*)font32 );
  66     lstrcpyn32A( font16->lfFaceName, font32->lfFaceName, LF_FACESIZE );
  67 }
  68
  69 void FONT_LogFont32WTo16( const LOGFONT32W* font32, LPLOGFONT16 font16 )
  70 {
  71   __logfont32to16( (INT16*)font16, (const INT32*)font32 );
  72     lstrcpynWtoA( font16->lfFaceName, font32->lfFaceName, LF_FACESIZE );
  73 }
  74
  75 void FONT_LogFont16To32A( const LPLOGFONT16 font16, LPLOGFONT32A font32 )
  76 {
  77   __logfont16to32( (INT32*)font32, (const INT16*)font16 );
  78     lstrcpyn32A( font32->lfFaceName, font16->lfFaceName, LF_FACESIZE );
  79 }
  80
  81 void FONT_LogFont16To32W( const LPLOGFONT16 font16, LPLOGFONT32W font32 )
  82 {
  83   __logfont16to32( (INT32*)font32, (const INT16*)font16 );
  84     lstrcpynAtoW( font32->lfFaceName, font16->lfFaceName, LF_FACESIZE );
  85 }
  86
  87 /***********************************************************************
  88  *              TEXTMETRIC conversion functions.
  89  */
  90 void FONT_TextMetric32Ato16(const LPTEXTMETRIC32A ptm32, LPTEXTMETRIC16 ptm16 )
  91 {
  92     ptm16->tmHeight = ptm32->tmHeight;
  93     ptm16->tmAscent = ptm32->tmAscent;
  94     ptm16->tmDescent = ptm32->tmDescent;
  95     ptm16->tmInternalLeading = ptm32->tmInternalLeading;
  96     ptm16->tmExternalLeading = ptm32->tmExternalLeading;
  97     ptm16->tmAveCharWidth = ptm32->tmAveCharWidth;
  98     ptm16->tmMaxCharWidth = ptm32->tmMaxCharWidth;
  99     ptm16->tmWeight = ptm32->tmWeight;
 100     ptm16->tmOverhang = ptm32->tmOverhang;
 101     ptm16->tmDigitizedAspectX = ptm32->tmDigitizedAspectX;
 102     ptm16->tmDigitizedAspectY = ptm32->tmDigitizedAspectY;
 103     ptm16->tmFirstChar = ptm32->tmFirstChar;
 104     ptm16->tmLastChar = ptm32->tmLastChar;
 105     ptm16->tmDefaultChar = ptm32->tmDefaultChar;
 106     ptm16->tmBreakChar = ptm32->tmBreakChar;
 107     ptm16->tmItalic = ptm32->tmItalic;
 108     ptm16->tmUnderlined = ptm32->tmUnderlined;
 109     ptm16->tmStruckOut = ptm32->tmStruckOut;
 110     ptm16->tmPitchAndFamily = ptm32->tmPitchAndFamily;
 111     ptm16->tmCharSet = ptm32->tmCharSet;
 112 }
 113
 114 void FONT_TextMetric32Wto16(const LPTEXTMETRIC32W ptm32, LPTEXTMETRIC16 ptm16 )
 115 {
 116     ptm16->tmHeight = ptm32->tmHeight;
 117     ptm16->tmAscent = ptm32->tmAscent;
 118     ptm16->tmDescent = ptm32->tmDescent;
 119     ptm16->tmInternalLeading = ptm32->tmInternalLeading;
 120     ptm16->tmExternalLeading = ptm32->tmExternalLeading;
 121     ptm16->tmAveCharWidth = ptm32->tmAveCharWidth;
 122     ptm16->tmMaxCharWidth = ptm32->tmMaxCharWidth;
 123     ptm16->tmWeight = ptm32->tmWeight;
 124     ptm16->tmOverhang = ptm32->tmOverhang;
 125     ptm16->tmDigitizedAspectX = ptm32->tmDigitizedAspectX;
 126     ptm16->tmDigitizedAspectY = ptm32->tmDigitizedAspectY;
 127     ptm16->tmFirstChar = ptm32->tmFirstChar;
 128     ptm16->tmLastChar = ptm32->tmLastChar;
 129     ptm16->tmDefaultChar = ptm32->tmDefaultChar;
 130     ptm16->tmBreakChar = ptm32->tmBreakChar;
 131     ptm16->tmItalic = ptm32->tmItalic;
 132     ptm16->tmUnderlined = ptm32->tmUnderlined;
 133     ptm16->tmStruckOut = ptm32->tmStruckOut;
 134     ptm16->tmPitchAndFamily = ptm32->tmPitchAndFamily;
 135     ptm16->tmCharSet = ptm32->tmCharSet;
 136 }
 137
 138 void FONT_TextMetric16to32A(const LPTEXTMETRIC16 ptm16, LPTEXTMETRIC32A ptm32 )
 139 {
 140     ptm32->tmHeight = ptm16->tmHeight;
 141     ptm32->tmAscent = ptm16->tmAscent;
 142     ptm32->tmDescent = ptm16->tmDescent;
 143     ptm32->tmInternalLeading = ptm16->tmInternalLeading;
 144     ptm32->tmExternalLeading = ptm16->tmExternalLeading;
 145     ptm32->tmAveCharWidth = ptm16->tmAveCharWidth;
 146     ptm32->tmMaxCharWidth = ptm16->tmMaxCharWidth;
 147     ptm32->tmWeight = ptm16->tmWeight;
 148     ptm32->tmOverhang = ptm16->tmOverhang;
 149     ptm32->tmDigitizedAspectX = ptm16->tmDigitizedAspectX;
 150     ptm32->tmDigitizedAspectY = ptm16->tmDigitizedAspectY;
 151     ptm32->tmFirstChar = ptm16->tmFirstChar;
 152     ptm32->tmLastChar = ptm16->tmLastChar;
 153     ptm32->tmDefaultChar = ptm16->tmDefaultChar;
 154     ptm32->tmBreakChar = ptm16->tmBreakChar;
 155     ptm32->tmItalic = ptm16->tmItalic;
 156     ptm32->tmUnderlined = ptm16->tmUnderlined;
 157     ptm32->tmStruckOut = ptm16->tmStruckOut;
 158     ptm32->tmPitchAndFamily = ptm16->tmPitchAndFamily;
 159     ptm32->tmCharSet = ptm16->tmCharSet;
 160 }
 161
 162 void FONT_TextMetric16to32W(const LPTEXTMETRIC16 ptm16, LPTEXTMETRIC32W ptm32 )
 163 {
 164     ptm32->tmHeight = ptm16->tmHeight;
 165     ptm32->tmAscent = ptm16->tmAscent;
 166     ptm32->tmDescent = ptm16->tmDescent;
 167     ptm32->tmInternalLeading = ptm16->tmInternalLeading;
 168     ptm32->tmExternalLeading = ptm16->tmExternalLeading;
 169     ptm32->tmAveCharWidth = ptm16->tmAveCharWidth;
 170     ptm32->tmMaxCharWidth = ptm16->tmMaxCharWidth;
 171     ptm32->tmWeight = ptm16->tmWeight;
 172     ptm32->tmOverhang = ptm16->tmOverhang;
 173     ptm32->tmDigitizedAspectX = ptm16->tmDigitizedAspectX;
 174     ptm32->tmDigitizedAspectY = ptm16->tmDigitizedAspectY;
 175     ptm32->tmFirstChar = ptm16->tmFirstChar;
 176     ptm32->tmLastChar = ptm16->tmLastChar;
 177     ptm32->tmDefaultChar = ptm16->tmDefaultChar;
 178     ptm32->tmBreakChar = ptm16->tmBreakChar;
 179     ptm32->tmItalic = ptm16->tmItalic;
 180     ptm32->tmUnderlined = ptm16->tmUnderlined;
 181     ptm32->tmStruckOut = ptm16->tmStruckOut;
 182     ptm32->tmPitchAndFamily = ptm16->tmPitchAndFamily;
 183     ptm32->tmCharSet = ptm16->tmCharSet;
 184 }
 185
 186 void FONT_TextMetric32Ato32W(const LPTEXTMETRIC32A ptm32A, LPTEXTMETRIC32W ptm32W )
 187 {
 188     ptm32W->tmHeight = ptm32A->tmHeight;
 189     ptm32W->tmAscent = ptm32A->tmAscent;
 190     ptm32W->tmDescent = ptm32A->tmDescent;
 191     ptm32W->tmInternalLeading = ptm32A->tmInternalLeading;
 192     ptm32W->tmExternalLeading = ptm32A->tmExternalLeading;
 193     ptm32W->tmAveCharWidth = ptm32A->tmAveCharWidth;
 194     ptm32W->tmMaxCharWidth = ptm32A->tmMaxCharWidth;
 195     ptm32W->tmWeight = ptm32A->tmWeight;
 196     ptm32W->tmOverhang = ptm32A->tmOverhang;
 197     ptm32W->tmDigitizedAspectX = ptm32A->tmDigitizedAspectX;
 198     ptm32W->tmDigitizedAspectY = ptm32A->tmDigitizedAspectY;
 199     ptm32W->tmFirstChar = ptm32A->tmFirstChar;
 200     ptm32W->tmLastChar = ptm32A->tmLastChar;
 201     ptm32W->tmDefaultChar = ptm32A->tmDefaultChar;
 202     ptm32W->tmBreakChar = ptm32A->tmBreakChar;
 203     ptm32W->tmItalic = ptm32A->tmItalic;
 204     ptm32W->tmUnderlined = ptm32A->tmUnderlined;
 205     ptm32W->tmStruckOut = ptm32A->tmStruckOut;
 206     ptm32W->tmPitchAndFamily = ptm32A->tmPitchAndFamily;
 207     ptm32W->tmCharSet = ptm32A->tmCharSet;
 208 }
 209
 210 /***********************************************************************
 211  *           CreateFontIndirect16   (GDI.57)
 212  */
 213 HFONT16 WINAPI CreateFontIndirect16( const LOGFONT16 *font )
 214 {
 215     HFONT16 hFont = 0;
 216
 217     if (font)
 218     {
 219         hFont = GDI_AllocObject( sizeof(FONTOBJ), FONT_MAGIC );
 220         if( hFont )
 221         {
 222             FONTOBJ* fontPtr;
 223             fontPtr = (FONTOBJ *) GDI_HEAP_LOCK( hFont );
 224             memcpy( &fontPtr->logfont, font, sizeof(LOGFONT16) );
 225
 226             dprintf_font(stddeb,"CreateFontIndirect(%i %i) '%s' %s %s => %04x\n",
 227                                  font->lfHeight, font->lfWidth,
 228                                  font->lfFaceName ? font->lfFaceName : "NULL",
 229                                  font->lfWeight > 400 ? "Bold" : "",
 230                                  font->lfItalic ? "Italic" : "",
 231                                  hFont);
 232             GDI_HEAP_UNLOCK( hFont );
 233         }
 234     }
 235     else fprintf(stderr,"CreateFontIndirect(NULL) => NULL\n");
 236
 237     return hFont;
 238 }
 239
 240 /***********************************************************************
 241  *           CreateFontIndirect32A   (GDI32.44)
 242  */
 243 HFONT32 WINAPI CreateFontIndirect32A( const LOGFONT32A *font )
 244 {
 245     LOGFONT16 font16;
 246
 247     FONT_LogFont32ATo16( font, &font16 );
 248     return CreateFontIndirect16( &font16 );
 249 }
 250
 251 /***********************************************************************
 252  *           CreateFontIndirect32W   (GDI32.45)
 253  */
 254 HFONT32 WINAPI CreateFontIndirect32W( const LOGFONT32W *font )
 255 {
 256     LOGFONT16 font16;
 257
 258     FONT_LogFont32WTo16( font, &font16 );
 259     return CreateFontIndirect16( &font16 );
 260 }
 261
 262 /***********************************************************************
 263  *           CreateFont16    (GDI.56)
 264  */
 265 HFONT16 WINAPI CreateFont16(INT16 height, INT16 width, INT16 esc, INT16 orient,
 266                             INT16 weight, BYTE italic, BYTE underline,
 267                             BYTE strikeout, BYTE charset, BYTE outpres,
 268                             BYTE clippres, BYTE quality, BYTE pitch,
 269                             LPCSTR name )
 270 {
 271     LOGFONT16 logfont = { height, width, esc, orient, weight, italic, underline,
 272                           strikeout, charset, outpres, clippres, quality, pitch, };
 273
 274     dprintf_font(stddeb,"CreateFont16('%s',%d,%d)\n",
 275                  (name ? name : "(null)") , height, width);
 276     if (name)
 277         lstrcpyn32A(logfont.lfFaceName,name,sizeof(logfont.lfFaceName));
 278     else
 279         logfont.lfFaceName[0] = '\0';
 280     return CreateFontIndirect16( &logfont );
 281 }
 282
 283 /*************************************************************************
 284  *           CreateFont32A    (GDI32.43)
 285  */
 286 HFONT32 WINAPI CreateFont32A( INT32 height, INT32 width, INT32 esc,
 287                               INT32 orient, INT32 weight, DWORD italic,
 288                               DWORD underline, DWORD strikeout, DWORD charset,
 289                               DWORD outpres, DWORD clippres, DWORD quality,
 290                               DWORD pitch, LPCSTR name )
 291 {
 292     return (HFONT32)CreateFont16( height, width, esc, orient, weight, italic,
 293                                   underline, strikeout, charset, outpres,
 294                                   clippres, quality, pitch, name );
 295 }
 296
 297 /*************************************************************************
 298  *           CreateFont32W    (GDI32.46)
 299  */
 300 HFONT32 WINAPI CreateFont32W( INT32 height, INT32 width, INT32 esc,
 301                               INT32 orient, INT32 weight, DWORD italic,
 302                               DWORD underline, DWORD strikeout, DWORD charset,
 303                               DWORD outpres, DWORD clippres, DWORD quality,
 304                               DWORD pitch, LPCWSTR name )
 305 {
 306     LPSTR namea = HEAP_strdupWtoA( GetProcessHeap(), 0, name );
 307     HFONT32 ret = (HFONT32)CreateFont16( height, width, esc, orient, weight,
 308                                          italic, underline, strikeout, charset,
 309                                          outpres, clippres, quality, pitch,
 310                                          namea );
 311     if (namea) HeapFree( GetProcessHeap(), 0, namea );
 312     return ret;
 313 }
 314
 315
 316 /***********************************************************************
 317  *           FONT_GetObject16
 318  */
 319 INT16 FONT_GetObject16( FONTOBJ * font, INT16 count, LPSTR buffer )
 320 {
 321     if (count > sizeof(LOGFONT16)) count = sizeof(LOGFONT16);
 322     memcpy( buffer, &font->logfont, count );
 323     return count;
 324 }
 325
 326 /***********************************************************************
 327  *           FONT_GetObject32A
 328  */
 329 INT32 FONT_GetObject32A( FONTOBJ *font, INT32 count, LPSTR buffer )
 330 {
 331     LOGFONT32A fnt32;
 332
 333     FONT_LogFont16To32A( &font->logfont, &fnt32 );
 334
 335     if (count > sizeof(fnt32)) count = sizeof(fnt32);
 336     memcpy( buffer, &fnt32, count );
 337     return count;
 338 }
 339
 340
 341 /***********************************************************************
 342  *              FONT_EnumInstance16
 343  *
 344  * Called by the device driver layer to pass font info
 345  * down to the application.
 346  */
 347 static INT32 FONT_EnumInstance16( LPENUMLOGFONT16 plf,
 348                                   LPNEWTEXTMETRIC16 ptm, UINT16 fType, LPARAM lp )
 349 {
 350 #define pfe ((fontEnum16*)lp)
 351     if( pfe->lpLogFontParam->lfCharSet == DEFAULT_CHARSET ||
 352         pfe->lpLogFontParam->lfCharSet == plf->elfLogFont.lfCharSet )
 353     {
 354         memcpy( pfe->lpLogFont, plf, sizeof(ENUMLOGFONT16) );
 355         memcpy( pfe->lpTextMetric, ptm, sizeof(NEWTEXTMETRIC16) );
 356
 357         return pfe->lpEnumFunc( pfe->segLogFont, pfe->segTextMetric, fType, (LPARAM)(pfe->lpData) );
 358     }
 359 #undef pfe
 360     return 1;
 361 }
 362
 363 /***********************************************************************
 364  *              FONT_EnumInstance32
 365  */
 366 static INT32 FONT_EnumInstance32( LPENUMLOGFONT16 plf,
 367                                   LPNEWTEXTMETRIC16 ptm, UINT16 fType, LPARAM lp )
 368 {
 369     /* lfCharSet is at the same offset in both LOGFONT32A and LOGFONT32W */
 370
 371 #define pfe ((fontEnum32*)lp)
 372     if( pfe->lpLogFontParam->lfCharSet == DEFAULT_CHARSET ||
 373         pfe->lpLogFontParam->lfCharSet == plf->elfLogFont.lfCharSet )
 374     {
 375         /* convert font metrics */
 376
 377         if( pfe->dwFlags & ENUM_UNICODE )
 378         {
 379             FONT_LogFont16To32W( &plf->elfLogFont, (LPLOGFONT32W)(pfe->lpLogFont) );
 380             FONT_TextMetric16to32W( (LPTEXTMETRIC16)ptm, (LPTEXTMETRIC32W)(pfe->lpTextMetric) );
 381         }
 382         else
 383         {
 384             FONT_LogFont16To32A( &plf->elfLogFont, (LPLOGFONT32A)pfe->lpLogFont );
 385             FONT_TextMetric16to32A( (LPTEXTMETRIC16)ptm, (LPTEXTMETRIC32A)pfe->lpTextMetric );
 386         }
 387
 388         return pfe->lpEnumFunc( (LPENUMLOGFONT32W)pfe->lpLogFont,
 389                                 (LPNEWTEXTMETRIC32W)pfe->lpTextMetric, fType, pfe->lpData );
 390     }
 391 #undef pfe
 392     return 1;
 393 }
 394
 395 /***********************************************************************
 396  *              EnumFontFamiliesEx16    (GDI.613)
 397  */
 398 INT16 WINAPI EnumFontFamiliesEx16( HDC16 hDC, LPLOGFONT16 plf,
 399                                    FONTENUMPROCEX16 efproc, LPARAM lParam,
 400                                    DWORD dwFlags)
 401 {
 402     INT16       retVal = 0;
 403     DC*         dc = (DC*) GDI_GetObjPtr( hDC, DC_MAGIC );
 404
 405     if( dc && dc->funcs->pEnumDeviceFonts )
 406     {
 407         LPNEWTEXTMETRICEX16     lptm16 = SEGPTR_ALLOC( sizeof(NEWTEXTMETRICEX16) );
 408         if( lptm16 )
 409         {
 410             LPENUMLOGFONTEX16   lplf16 = SEGPTR_ALLOC( sizeof(ENUMLOGFONTEX16) );
 411             if( lplf16 )
 412             {
 413                 fontEnum16      fe16 = { plf, efproc, lParam, lptm16, lplf16,
 414                                          SEGPTR_GET(lptm16), SEGPTR_GET(lplf16) };
 415
 416                 retVal = dc->funcs->pEnumDeviceFonts( dc, plf, FONT_EnumInstance16, (LPARAM)&fe16 );
 417
 418                 SEGPTR_FREE(lplf16);
 419             }
 420             SEGPTR_FREE(lptm16);
 421         }
 422     }
 423     return retVal;
 424 }
 425
 426 /***********************************************************************
 427  *              FONT_EnumFontFamiliesEx32
 428  */
 429 static INT32 FONT_EnumFontFamiliesEx32( HDC32 hDC, LPLOGFONT32W plf, FONTENUMPROC32W efproc,
 430                                                    LPARAM lParam, DWORD dwUnicode)
 431 {
 432     DC*         dc = (DC*) GDI_GetObjPtr( hDC, DC_MAGIC );
 433
 434     if( dc && dc->funcs->pEnumDeviceFonts )
 435     {
 436         LOGFONT16               lf16;
 437         NEWTEXTMETRICEX32W      tm32w;
 438         ENUMLOGFONTEX32W        lf32w;
 439         fontEnum32              fe32 = { plf, efproc, lParam, &tm32w, &lf32w, dwUnicode };
 440
 441         /* the only difference between LOGFONT32A and LOGFONT32W is in the lfFaceName */
 442
 443         if( plf->lfFaceName[0] )
 444         {
 445             if( dwUnicode )
 446                 lstrcpynWtoA( lf16.lfFaceName, plf->lfFaceName, LF_FACESIZE );
 447             else
 448                 lstrcpyn32A( lf16.lfFaceName, (LPCSTR)plf->lfFaceName, LF_FACESIZE );
 449         }
 450         else lf16.lfFaceName[0] = '\0';
 451         lf16.lfCharSet = plf->lfCharSet;
 452
 453         return dc->funcs->pEnumDeviceFonts( dc, &lf16, FONT_EnumInstance32, (LPARAM)&fe32 );
 454     }
 455     return 0;
 456 }
 457
 458 /***********************************************************************
 459  *              EnumFontFamiliesEx32W   (GDI32.82)
 460  */
 461 INT32 WINAPI EnumFontFamiliesEx32W( HDC32 hDC, LPLOGFONT32W plf,
 462                                     FONTENUMPROCEX32W efproc,
 463                                     LPARAM lParam, DWORD dwFlags )
 464 {
 465     return  FONT_EnumFontFamiliesEx32( hDC, plf, (FONTENUMPROC32W)efproc,
 466                                                   lParam, ENUM_UNICODE );
 467 }
 468
 469 /***********************************************************************
 470  *              EnumFontFamiliesEx32A   (GDI32.81)
 471  */
 472 INT32 WINAPI EnumFontFamiliesEx32A( HDC32 hDC, LPLOGFONT32A plf,
 473                                     FONTENUMPROCEX32A efproc,
 474                                     LPARAM lParam, DWORD dwFlags)
 475 {
 476     return  FONT_EnumFontFamiliesEx32( hDC, (LPLOGFONT32W)plf,
 477                                       (FONTENUMPROC32W)efproc, lParam, 0);
 478 }
 479
 480 /***********************************************************************
 481  *              EnumFontFamilies16      (GDI.330)
 482  */
 483 INT16 WINAPI EnumFontFamilies16( HDC16 hDC, LPCSTR lpFamily,
 484                                  FONTENUMPROC16 efproc, LPARAM lpData )
 485 {
 486     LOGFONT16   lf;
 487
 488     lf.lfCharSet = DEFAULT_CHARSET;
 489     if( lpFamily ) lstrcpyn32A( lf.lfFaceName, lpFamily, LF_FACESIZE );
 490     else lf.lfFaceName[0] = '\0';
 491
 492     return EnumFontFamiliesEx16( hDC, &lf, (FONTENUMPROCEX16)efproc, lpData, 0 );
 493 }
 494
 495 /***********************************************************************
 496  *              EnumFontFamilies32A     (GDI32.80)
 497  */
 498 INT32 WINAPI EnumFontFamilies32A( HDC32 hDC, LPCSTR lpFamily,
 499                                   FONTENUMPROC32A efproc, LPARAM lpData )
 500 {
 501     LOGFONT32A  lf;
 502
 503     lf.lfCharSet = DEFAULT_CHARSET;
 504     if( lpFamily ) lstrcpyn32A( lf.lfFaceName, lpFamily, LF_FACESIZE );
 505     else lf.lfFaceName[0] = lf.lfFaceName[1] = '\0';
 506
 507     return FONT_EnumFontFamiliesEx32( hDC, (LPLOGFONT32W)&lf,
 508                                            (FONTENUMPROC32W)efproc, lpData, 0 );
 509 }
 510
 511 /***********************************************************************
 512  *              EnumFontFamilies32W     (GDI32.83)
 513  */
 514 INT32 WINAPI EnumFontFamilies32W( HDC32 hDC, LPCWSTR lpFamily,
 515                                   FONTENUMPROC32W efproc, LPARAM lpData )
 516 {
 517     LOGFONT32W  lf;
 518
 519     lf.lfCharSet = DEFAULT_CHARSET;
 520     if( lpFamily ) lstrcpyn32W( lf.lfFaceName, lpFamily, LF_FACESIZE );
 521     else lf.lfFaceName[0] = 0;
 522
 523     return FONT_EnumFontFamiliesEx32( hDC, &lf, efproc, lpData, ENUM_UNICODE );
 524 }
 525
 526 /***********************************************************************
 527  *              EnumFonts16             (GDI.70)
 528  */
 529 INT16 WINAPI EnumFonts16( HDC16 hDC, LPCSTR lpName, FONTENUMPROC16 efproc,
 530                           LPARAM lpData )
 531 {
 532     return EnumFontFamilies16( hDC, lpName, (FONTENUMPROCEX16)efproc, lpData );
 533 }
 534
 535 /***********************************************************************
 536  *              EnumFonts32A            (GDI32.84)
 537  */
 538 INT32 WINAPI EnumFonts32A( HDC32 hDC, LPCSTR lpName, FONTENUMPROC32A efproc,
 539                            LPARAM lpData )
 540 {
 541     return EnumFontFamilies32A( hDC, lpName, efproc, lpData );
 542 }
 543
 544 /***********************************************************************
 545  *              EnumFonts32W            (GDI32.85)
 546  */
 547 INT32 WINAPI EnumFonts32W( HDC32 hDC, LPCWSTR lpName, FONTENUMPROC32W efproc,
 548                            LPARAM lpData )
 549 {
 550     return EnumFontFamilies32W( hDC, lpName, efproc, lpData );
 551 }
 552
 553
 554 /***********************************************************************
 555  *           GetTextCharacterExtra16    (GDI.89)
 556  */
 557 INT16 WINAPI GetTextCharacterExtra16( HDC16 hdc )
 558 {
 559     DC * dc = (DC *) GDI_GetObjPtr( hdc, DC_MAGIC );
 560     if (!dc) return 0;
 561     return abs( (dc->w.charExtra * dc->wndExtX + dc->vportExtX / 2)
 562                  / dc->vportExtX );
 563 }
 564
 565
 566 /***********************************************************************
 567  *           GetTextCharacterExtra32    (GDI32.225)
 568  */
 569 INT32 WINAPI GetTextCharacterExtra32( HDC32 hdc )
 570 {
 571     DC * dc = (DC *) GDI_GetObjPtr( hdc, DC_MAGIC );
 572     if (!dc) return 0;
 573     return abs( (dc->w.charExtra * dc->wndExtX + dc->vportExtX / 2)
 574                  / dc->vportExtX );
 575 }
 576
 577
 578 /***********************************************************************
 579  *           SetTextCharacterExtra16    (GDI.8)
 580  */
 581 INT16 WINAPI SetTextCharacterExtra16( HDC16 hdc, INT16 extra )
 582 {
 583     return (INT16)SetTextCharacterExtra32( hdc, extra );
 584 }
 585
 586
 587 /***********************************************************************
 588  *           SetTextCharacterExtra32    (GDI32.337)
 589  */
 590 INT32 WINAPI SetTextCharacterExtra32( HDC32 hdc, INT32 extra )
 591 {
 592     INT32 prev;
 593     DC * dc = (DC *) GDI_GetObjPtr( hdc, DC_MAGIC );
 594     if (!dc) return 0;
 595     extra = (extra * dc->vportExtX + dc->wndExtX / 2) / dc->wndExtX;
 596     prev = dc->w.charExtra;
 597     dc->w.charExtra = abs(extra);
 598     return (prev * dc->wndExtX + dc->vportExtX / 2) / dc->vportExtX;
 599 }
 600
 601
 602 /***********************************************************************
 603  *           SetTextJustification16    (GDI.10)
 604  */
 605 INT16 WINAPI SetTextJustification16( HDC16 hdc, INT16 extra, INT16 breaks )
 606 {
 607     return SetTextJustification32( hdc, extra, breaks );
 608 }
 609
 610
 611 /***********************************************************************
 612  *           SetTextJustification32    (GDI32.339)
 613  */
 614 BOOL32 WINAPI SetTextJustification32( HDC32 hdc, INT32 extra, INT32 breaks )
 615 {
 616     DC * dc = (DC *) GDI_GetObjPtr( hdc, DC_MAGIC );
 617     if (!dc) return 0;
 618
 619     extra = abs((extra * dc->vportExtX + dc->wndExtX / 2) / dc->wndExtX);
 620     if (!extra) breaks = 0;
 621     dc->w.breakTotalExtra = extra;
 622     dc->w.breakCount = breaks;
 623     if (breaks)
 624     {
 625         dc->w.breakExtra = extra / breaks;
 626         dc->w.breakRem   = extra - (dc->w.breakCount * dc->w.breakExtra);
 627     }
 628     else
 629     {
 630         dc->w.breakExtra = 0;
 631         dc->w.breakRem   = 0;
 632     }
 633     return 1;
 634 }
 635
 636
 637 /***********************************************************************
 638  *           GetTextFace16    (GDI.92)
 639  */
 640 INT16 WINAPI GetTextFace16( HDC16 hdc, INT16 count, LPSTR name )
 641 {
 642         return GetTextFace32A(hdc,count,name);
 643 }
 644
 645 /***********************************************************************
 646  *           GetTextFace32A    (GDI32.234)
 647  */
 648 INT32 WINAPI GetTextFace32A( HDC32 hdc, INT32 count, LPSTR name )
 649 {
 650     FONTOBJ *font;
 651
 652     DC * dc = (DC *) GDI_GetObjPtr( hdc, DC_MAGIC );
 653     if (!dc) return 0;
 654     if (!(font = (FONTOBJ *) GDI_GetObjPtr( dc->w.hFont, FONT_MAGIC )))
 655         return 0;
 656     lstrcpyn32A( name, font->logfont.lfFaceName, count );
 657     GDI_HEAP_UNLOCK( dc->w.hFont );
 658     return strlen(name);
 659 }
 660
 661 /***********************************************************************
 662  *           GetTextFace32W    (GDI32.235)
 663  */
 664 INT32 WINAPI GetTextFace32W( HDC32 hdc, INT32 count, LPWSTR name )
 665 {
 666     LPSTR nameA = HeapAlloc( GetProcessHeap(), 0, count );
 667     INT32 res = GetTextFace32A(hdc,count,nameA);
 668     lstrcpyAtoW( name, nameA );
 669     HeapFree( GetProcessHeap(), 0, nameA );
 670     return res;
 671 }
 672
 673
 674 /***********************************************************************
 675  *           GetTextExtent    (GDI.91)
 676  */
 677 DWORD WINAPI GetTextExtent( HDC16 hdc, LPCSTR str, INT16 count )
 678 {
 679     SIZE16 size;
 680     if (!GetTextExtentPoint16( hdc, str, count, &size )) return 0;
 681     return MAKELONG( size.cx, size.cy );
 682 }
 683
 684
 685 /***********************************************************************
 686  *           GetTextExtentPoint16    (GDI.471)
 687  *
 688  * FIXME: Should this have a bug for compatibility?
 689  * Original Windows versions of GetTextExtentPoint{A,W} have documented
 690  * bugs.
 691  */
 692 BOOL16 WINAPI GetTextExtentPoint16( HDC16 hdc, LPCSTR str, INT16 count,
 693                                     LPSIZE16 size )
 694 {
 695     SIZE32 size32;
 696     BOOL32 ret = GetTextExtentPoint32A( hdc, str, count, &size32 );
 697     CONV_SIZE32TO16( &size32, size );
 698     return (BOOL16)ret;
 699 }
 700
 701
 702 /***********************************************************************
 703  *           GetTextExtentPoint32A    (GDI32.230)
 704  */
 705 BOOL32 WINAPI GetTextExtentPoint32A( HDC32 hdc, LPCSTR str, INT32 count,
 706                                      LPSIZE32 size )
 707 {
 708     DC * dc = (DC *) GDI_GetObjPtr( hdc, DC_MAGIC );
 709     if (!dc)
 710     {
 711         if (!(dc = (DC *)GDI_GetObjPtr( hdc, METAFILE_DC_MAGIC )))
 712             return FALSE;
 713     }
 714
 715     if (!dc->funcs->pGetTextExtentPoint ||
 716         !dc->funcs->pGetTextExtentPoint( dc, str, count, size ))
 717         return FALSE;
 718
 719     dprintf_font(stddeb,"GetTextExtentPoint(%08x %s %d %p): returning %d,%d\n",
 720                  hdc, debugstr_an (str, count), count,
 721                  size, size->cx, size->cy );
 722     return TRUE;
 723 }
 724
 725
 726 /***********************************************************************
 727  *           GetTextExtentPoint32W    (GDI32.231)
 728  */
 729 BOOL32 WINAPI GetTextExtentPoint32W( HDC32 hdc, LPCWSTR str, INT32 count,
 730                                      LPSIZE32 size )
 731 {
 732     LPSTR p = HEAP_strdupWtoA( GetProcessHeap(), 0, str );
 733     BOOL32 ret = GetTextExtentPoint32A( hdc, p, count, size );
 734     HeapFree( GetProcessHeap(), 0, p );
 735     return ret;
 736 }
 737
 738
 739 /***********************************************************************
 740  *           GetTextExtentPoint32ABuggy    (GDI32.232)
 741  */
 742 BOOL32 WINAPI GetTextExtentPoint32ABuggy( HDC32 hdc, LPCSTR str, INT32 count,
 743                                           LPSIZE32 size )
 744 {
 745     dprintf_font( stddeb, "GetTextExtentPoint32ABuggy: not bug compatible.\n");
 746     return GetTextExtentPoint32A( hdc, str, count, size );
 747 }
 748
 749 /***********************************************************************
 750  *           GetTextExtentPoint32WBuggy    (GDI32.233)
 751  */
 752 BOOL32 WINAPI GetTextExtentPoint32WBuggy( HDC32 hdc, LPCWSTR str, INT32 count,
 753                                           LPSIZE32 size )
 754 {
 755     dprintf_font( stddeb, "GetTextExtentPoint32WBuggy: not bug compatible.\n");
 756     return GetTextExtentPoint32W( hdc, str, count, size );
 757 }
 758
 759
 760 /***********************************************************************
 761  *           GetTextExtentExPoint32A    (GDI32.228)
 762  */
 763 BOOL32 WINAPI GetTextExtentExPoint32A( HDC32 hdc, LPCSTR str, INT32 count,
 764                                        INT32 maxExt, LPINT32 lpnFit,
 765                                        LPINT32 alpDx, LPSIZE32 size )
 766 {
 767     int index, nFit, extent;
 768     SIZE32 tSize;
 769     DC * dc = (DC *) GDI_GetObjPtr( hdc, DC_MAGIC );
 770
 771     if (!dc)
 772     {
 773         if (!(dc = (DC *)GDI_GetObjPtr( hdc, METAFILE_DC_MAGIC )))
 774             return FALSE;
 775     }
 776     if (!dc->funcs->pGetTextExtentPoint) return FALSE;
 777
 778     size->cx = size->cy = nFit = extent = 0;
 779     for(index = 0; index < count; index++)
 780     {
 781         if(!dc->funcs->pGetTextExtentPoint( dc, str, 1, &tSize )) return FALSE;
 782         if( extent+tSize.cx < maxExt )
 783         {
 784             extent+=tSize.cx;
 785             nFit++;
 786             str++;
 787             if( alpDx ) alpDx[index] = extent;
 788             if( tSize.cy > size->cy ) size->cy = tSize.cy;
 789         }
 790         else break;
 791     }
 792     size->cx = extent;
 793    *lpnFit = nFit;
 794
 795     dprintf_font(stddeb,"GetTextExtentExPoint32A(%08x '%.*s' %d) returning %d %d %d\n",
 796                hdc,count,str,maxExt,nFit, size->cx,size->cy);
 797     return TRUE;
 798 }
 799
 800
 801 /***********************************************************************
 802  *           GetTextExtentExPoint32W    (GDI32.229)
 803  */
 804
 805 BOOL32 WINAPI GetTextExtentExPoint32W( HDC32 hdc, LPCWSTR str, INT32 count,
 806                                        INT32 maxExt, LPINT32 lpnFit,
 807                                        LPINT32 alpDx, LPSIZE32 size )
 808 {
 809     LPSTR p = HEAP_strdupWtoA( GetProcessHeap(), 0, str );
 810     BOOL32 ret = GetTextExtentExPoint32A( hdc, p, count, maxExt,
 811                                         lpnFit, alpDx, size);
 812     HeapFree( GetProcessHeap(), 0, p );
 813     return ret;
 814 }
 815
 816 /***********************************************************************
 817  *           GetTextMetrics16    (GDI.93)
 818  */
 819 BOOL16 WINAPI GetTextMetrics16( HDC16 hdc, TEXTMETRIC16 *metrics )
 820 {
 821     TEXTMETRIC32A tm32;
 822
 823     if (!GetTextMetrics32A( (HDC32)hdc, &tm32 )) return FALSE;
 824     FONT_TextMetric32Ato16( &tm32, metrics );
 825     return TRUE;
 826 }
 827
 828
 829 /***********************************************************************
 830  *           GetTextMetrics32A    (GDI32.236)
 831  */
 832 BOOL32 WINAPI GetTextMetrics32A( HDC32 hdc, TEXTMETRIC32A *metrics )
 833 {
 834     DC * dc = (DC *) GDI_GetObjPtr( hdc, DC_MAGIC );
 835     if (!dc)
 836     {
 837         if (!(dc = (DC *)GDI_GetObjPtr( hdc, METAFILE_DC_MAGIC )))
 838             return FALSE;
 839     }
 840
 841     if (!dc->funcs->pGetTextMetrics ||
 842         !dc->funcs->pGetTextMetrics( dc, metrics ))
 843         return FALSE;
 844
 845     /* device layer returns values in device units
 846      * therefore we have to convert them to logical */
 847
 848 #define WDPTOLP(x) ((x<0)?                                      \
 849                 (-abs((x)*dc->wndExtX/dc->vportExtX)):          \
 850                 (abs((x)*dc->wndExtX/dc->vportExtX)))
 851 #define HDPTOLP(y) ((y<0)?                                      \
 852                 (-abs((y)*dc->wndExtY/dc->vportExtY)):          \
 853                 (abs((y)*dc->wndExtY/dc->vportExtY)))
 854
 855     metrics->tmHeight           = HDPTOLP(metrics->tmHeight);
 856     metrics->tmAscent           = HDPTOLP(metrics->tmAscent);
 857     metrics->tmDescent          = HDPTOLP(metrics->tmDescent);
 858     metrics->tmInternalLeading  = HDPTOLP(metrics->tmInternalLeading);
 859     metrics->tmExternalLeading  = HDPTOLP(metrics->tmExternalLeading);
 860     metrics->tmAveCharWidth     = WDPTOLP(metrics->tmAveCharWidth);
 861     metrics->tmMaxCharWidth     = WDPTOLP(metrics->tmMaxCharWidth);
 862     metrics->tmOverhang         = WDPTOLP(metrics->tmOverhang);
 863
 864     dprintf_font(stddeb,"text metrics:
 865     Weight = %03i\t FirstChar = %03i\t AveCharWidth = %i
 866     Italic = % 3i\t LastChar = %03i\t\t MaxCharWidth = %i
 867     UnderLined = %01i\t DefaultChar = %03i\t Overhang = %i
 868     StruckOut = %01i\t BreakChar = %03i\t CharSet = %i
 869     PitchAndFamily = %02x
 870     --------------------
 871     InternalLeading = %i
 872     Ascent = %i
 873     Descent = %i
 874     Height = %i\n",
 875     metrics->tmWeight, metrics->tmFirstChar, metrics->tmAveCharWidth,
 876     metrics->tmItalic, metrics->tmLastChar, metrics->tmMaxCharWidth,
 877     metrics->tmUnderlined, metrics->tmDefaultChar, metrics->tmOverhang,
 878     metrics->tmStruckOut, metrics->tmBreakChar, metrics->tmCharSet,
 879     metrics->tmPitchAndFamily,
 880     metrics->tmInternalLeading,
 881     metrics->tmAscent,
 882     metrics->tmDescent,
 883     metrics->tmHeight );
 884     return TRUE;
 885 }
 886
 887
 888 /***********************************************************************
 889  *           GetTextMetrics32W    (GDI32.237)
 890  */
 891 BOOL32 WINAPI GetTextMetrics32W( HDC32 hdc, TEXTMETRIC32W *metrics )
 892 {
 893     TEXTMETRIC32A tm;
 894     if (!GetTextMetrics32A( (HDC16)hdc, &tm )) return FALSE;
 895     FONT_TextMetric32Ato32W( &tm, metrics );
 896     return TRUE;
 897 }
 898
 899
 900 /***********************************************************************
 901  *           GetCharWidth16    (GDI.350)
 902  */
 903 BOOL16 WINAPI GetCharWidth16( HDC16 hdc, UINT16 firstChar, UINT16 lastChar,
 904                               LPINT16 buffer )
 905 {
 906     BOOL32      retVal = FALSE;
 907
 908     if( firstChar != lastChar )
 909     {
 910         LPINT32 buf32 = (LPINT32)HeapAlloc(GetProcessHeap(), 0,
 911                                  sizeof(INT32)*(1 + (lastChar - firstChar)));
 912         if( buf32 )
 913         {
 914             LPINT32     obuf32 = buf32;
 915             int         i;
 916
 917             retVal = GetCharWidth32A(hdc, firstChar, lastChar, buf32);
 918             if (retVal)
 919             {
 920                 for (i = firstChar; i <= lastChar; i++)
 921                     *buffer++ = *buf32++;
 922             }
 923             HeapFree(GetProcessHeap(), 0, obuf32);
 924         }
 925     }
 926     else /* happens quite often to warrant a special treatment */
 927     {
 928         INT32 chWidth;
 929         retVal = GetCharWidth32A(hdc, firstChar, lastChar, &chWidth );
 930        *buffer = chWidth;
 931     }
 932     return retVal;
 933 }
 934
 935
 936 /***********************************************************************
 937  *           GetCharWidth32A    (GDI32.155)
 938  */
 939 BOOL32 WINAPI GetCharWidth32A( HDC32 hdc, UINT32 firstChar, UINT32 lastChar,
 940                                LPINT32 buffer )
 941 {
 942     UINT32 i, extra;
 943     DC * dc = (DC *) GDI_GetObjPtr( hdc, DC_MAGIC );
 944     if (!dc)
 945     {
 946         if (!(dc = (DC *)GDI_GetObjPtr( hdc, METAFILE_DC_MAGIC )))
 947             return FALSE;
 948     }
 949
 950     if (!dc->funcs->pGetCharWidth ||
 951         !dc->funcs->pGetCharWidth( dc, firstChar, lastChar, buffer))
 952         return FALSE;
 953
 954     /* convert device units to logical */
 955
 956     extra = dc->vportExtX >> 1;
 957     for( i = firstChar; i <= lastChar; i++, buffer++ )
 958          *buffer = (*buffer * dc->wndExtX + extra) / dc->vportExtX;
 959
 960     return TRUE;
 961 }
 962
 963
 964 /***********************************************************************
 965  *           GetCharWidth32W    (GDI32.158)
 966  */
 967 BOOL32 WINAPI GetCharWidth32W( HDC32 hdc, UINT32 firstChar, UINT32 lastChar,
 968                                LPINT32 buffer )
 969 {
 970     return GetCharWidth32A( hdc, firstChar, lastChar, buffer );
 971 }
 972
 973
 974
 975 /* FIXME: all following APIs *******************************************
 976  *
 977  *
 978  *           SetMapperFlags16    (GDI.349)
 979  */
 980 DWORD WINAPI SetMapperFlags16( HDC16 hDC, DWORD dwFlag )
 981 {
 982     return SetMapperFlags32( hDC, dwFlag );
 983 }
 984
 985
 986 /***********************************************************************
 987  *           SetMapperFlags32    (GDI32.322)
 988  */
 989 DWORD WINAPI SetMapperFlags32( HDC32 hDC, DWORD dwFlag )
 990 {
 991     dprintf_font(stdnimp,"SetMapperFlags(%04x, %08lX) // Empty Stub !\n",
 992                  hDC, dwFlag);
 993     return 0L;
 994 }
 995
 996 /***********************************************************************
 997  *          GetAspectRatioFilterEx16  (GDI.486)
 998  */
 999 BOOL16 GetAspectRatioFilterEx16( HDC16 hdc, LPVOID pAspectRatio )
1000 {
1001   dprintf_font(stdnimp,
1002       "GetAspectRatioFilterEx(%04x, %p): // Empty Stub !\n",
1003                hdc, pAspectRatio);
1004   return FALSE;
1005 }
1006
1007
1008 /***********************************************************************
1009  *           GetCharABCWidths16   (GDI.307)
1010  */
1011 BOOL16 WINAPI GetCharABCWidths16( HDC16 hdc, UINT16 firstChar, UINT16 lastChar,
1012                                   LPABC16 abc )
1013 {
1014     ABC32 abc32;
1015     if (!GetCharABCWidths32A( hdc, firstChar, lastChar, &abc32 )) return FALSE;
1016     abc->abcA = abc32.abcA;
1017     abc->abcB = abc32.abcB;
1018     abc->abcC = abc32.abcC;
1019     return TRUE;
1020 }
1021
1022
1023 /***********************************************************************
1024  *           GetCharABCWidths32A   (GDI32.149)
1025  */
1026 BOOL32 WINAPI GetCharABCWidths32A(HDC32 hdc, UINT32 firstChar, UINT32 lastChar,
1027                                   LPABC32 abc )
1028 {
1029     /* No TrueType fonts in Wine so far */
1030     fprintf( stdnimp, "STUB: GetCharABCWidths(%04x,%04x,%04x,%p)\n",
1031              hdc, firstChar, lastChar, abc );
1032     return FALSE;
1033 }
1034
1035
1036 /***********************************************************************
1037  *           GetCharABCWidths32W   (GDI32.152)
1038  */
1039 BOOL32 WINAPI GetCharABCWidths32W(HDC32 hdc, UINT32 firstChar, UINT32 lastChar,
1040                                   LPABC32 abc )
1041 {
1042     return GetCharABCWidths32A( hdc, firstChar, lastChar, abc );
1043 }
1044
1045
1046 /***********************************************************************
1047  *           GetGlyphOutline16    (GDI.309)
1048  */
1049 DWORD WINAPI GetGlyphOutline16( HDC16 hdc, UINT16 uChar, UINT16 fuFormat,
1050                                 LPGLYPHMETRICS16 lpgm, DWORD cbBuffer,
1051                                 LPVOID lpBuffer, const MAT2 *lpmat2 )
1052 {
1053     fprintf( stdnimp,"GetGlyphOutLine16(%04x, '%c', %04x, %p, %ld, %p, %p) // - empty stub!\n",
1054              hdc, uChar, fuFormat, lpgm, cbBuffer, lpBuffer, lpmat2 );
1055     return (DWORD)-1; /* failure */
1056 }
1057
1058
1059 /***********************************************************************
1060  *           GetGlyphOutline32A    (GDI32.186)
1061  */
1062 DWORD WINAPI GetGlyphOutline32A( HDC32 hdc, UINT32 uChar, UINT32 fuFormat,
1063                                  LPGLYPHMETRICS32 lpgm, DWORD cbBuffer,
1064                                  LPVOID lpBuffer, const MAT2 *lpmat2 )
1065 {
1066     fprintf( stdnimp,"GetGlyphOutLine32A(%04x, '%c', %04x, %p, %ld, %p, %p) // - empty stub!\n",
1067              hdc, uChar, fuFormat, lpgm, cbBuffer, lpBuffer, lpmat2 );
1068     return (DWORD)-1; /* failure */
1069 }
1070
1071 /***********************************************************************
1072  *           GetGlyphOutline32W    (GDI32.187)
1073  */
1074 DWORD WINAPI GetGlyphOutline32W( HDC32 hdc, UINT32 uChar, UINT32 fuFormat,
1075                                  LPGLYPHMETRICS32 lpgm, DWORD cbBuffer,
1076                                  LPVOID lpBuffer, const MAT2 *lpmat2 )
1077 {
1078     fprintf( stdnimp,"GetGlyphOutLine32W(%04x, '%c', %04x, %p, %ld, %p, %p) // - empty stub!\n",
1079              hdc, uChar, fuFormat, lpgm, cbBuffer, lpBuffer, lpmat2 );
1080     return (DWORD)-1; /* failure */
1081 }
1082
1083 /***********************************************************************
1084  *           CreateScalableFontResource16   (GDI.310)
1085  */
1086 BOOL16 WINAPI CreateScalableFontResource16( UINT16 fHidden,
1087                                             LPCSTR lpszResourceFile,
1088                                             LPCSTR fontFile, LPCSTR path )
1089 {
1090     return CreateScalableFontResource32A( fHidden, lpszResourceFile,
1091                                           fontFile, path );
1092 }
1093
1094 /***********************************************************************
1095  *           CreateScalableFontResource32A   (GDI32.62)
1096  */
1097 BOOL32 WINAPI CreateScalableFontResource32A( DWORD fHidden,
1098                                              LPCSTR lpszResourceFile,
1099                                              LPCSTR lpszFontFile,
1100                                              LPCSTR lpszCurrentPath )
1101 {
1102     /* fHidden=1 - only visible for the calling app, read-only, not
1103      * enumbered with EnumFonts/EnumFontFamilies
1104      * lpszCurrentPath can be NULL
1105      */
1106     fprintf(stdnimp,"CreateScalableFontResource(%ld,%s,%s,%s) // empty stub\n",
1107             fHidden, lpszResourceFile, lpszFontFile, lpszCurrentPath );
1108     return FALSE; /* create failed */
1109 }
1110
1111 /***********************************************************************
1112  *           CreateScalableFontResource32W   (GDI32.63)
1113  */
1114 BOOL32 WINAPI CreateScalableFontResource32W( DWORD fHidden,
1115                                              LPCWSTR lpszResourceFile,
1116                                              LPCWSTR lpszFontFile,
1117                                              LPCWSTR lpszCurrentPath )
1118 {
1119     fprintf(stdnimp,"CreateScalableFontResource32W(%ld,%p,%p,%p) // empty stub\n",
1120             fHidden, lpszResourceFile, lpszFontFile, lpszCurrentPath );
1121     return FALSE; /* create failed */
1122 }
1123
1124
1125 /*************************************************************************
1126  *             GetRasterizerCaps16   (GDI.313)
1127  */
1128 BOOL16 WINAPI GetRasterizerCaps16( LPRASTERIZER_STATUS lprs, UINT16 cbNumBytes)
1129 {
1130     return GetRasterizerCaps32( lprs, cbNumBytes );
1131 }
1132
1133
1134 /*************************************************************************
1135  *             GetRasterizerCaps32   (GDI32.216)
1136  */
1137 BOOL32 WINAPI GetRasterizerCaps32( LPRASTERIZER_STATUS lprs, UINT32 cbNumBytes)
1138 {
1139   lprs->nSize = sizeof(RASTERIZER_STATUS);
1140   lprs->wFlags = TT_AVAILABLE|TT_ENABLED;
1141   lprs->nLanguageID = 0;
1142   return TRUE;
1143 }
1144
1145
1146 /*************************************************************************
1147  *             GetKerningPairs16   (GDI.332)
1148  */
1149 INT16 WINAPI GetKerningPairs16( HDC16 hDC, INT16 cPairs,
1150                                 LPKERNINGPAIR16 lpKerningPairs )
1151 {
1152     /* At this time kerning is ignored (set to 0) */
1153     int i;
1154     fprintf(stdnimp,"GetKerningPairs16: almost empty stub!\n");
1155     for (i = 0; i < cPairs; i++) lpKerningPairs[i].iKernAmount = 0;
1156     return 0;
1157 }
1158
1159
1160
1161 /*************************************************************************
1162  *             GetKerningPairs32A   (GDI32.192)
1163  */
1164 DWORD WINAPI GetKerningPairs32A( HDC32 hDC, DWORD cPairs,
1165                                  LPKERNINGPAIR32 lpKerningPairs )
1166 {
1167     int i;
1168     fprintf(stdnimp,"GetKerningPairs32: almost empty stub!\n");
1169     for (i = 0; i < cPairs; i++) lpKerningPairs[i].iKernAmount = 0;
1170     return 0;
1171 }
1172
1173
1174 /*************************************************************************
1175  *             GetKerningPairs32W   (GDI32.193)
1176  */
1177 DWORD WINAPI GetKerningPairs32W( HDC32 hDC, DWORD cPairs,
1178                                  LPKERNINGPAIR32 lpKerningPairs )
1179 {
1180     return GetKerningPairs32A( hDC, cPairs, lpKerningPairs );
1181 }
1182
1183 BOOL32 WINAPI TranslateCharSetInfo(LPDWORD lpSrc,LPCHARSETINFO lpCs,DWORD dwFlags) {
1184     fprintf(stderr,"TranslateCharSetInfo(%p,%p,0x%08lx), stub.\n",
1185         lpSrc,lpCs,dwFlags
1186     );
1187     return TRUE;
1188 }
1189
1190
1191 /*************************************************************************
1192  *             GetFontLanguageInfo   (GDI32.182)
1193  */
1194 DWORD WINAPI GetFontLanguageInfo32(HDC32 hdc) {
1195         /* return value 0 is correct for most cases anyway */
1196         fprintf(stderr,"GetFontLanguageInfo:stub!\n");
1197         return 0;
1198 }
1199
1200 /*************************************************************************
1201  *             GetFontLanguageInfo   (GDI.616)
1202  */
1203 DWORD WINAPI GetFontLanguageInfo16(HDC16 hdc) {
1204         /* return value 0 is correct for most cases anyway */
1205         fprintf(stderr,"GetFontLanguageInfo:stub!\n");
1206         return 0;
1207 }