objects/font.c

   1 /*
   2  * GDI font objects
   3  *
   4  * Copyright 1993 Alexandre Julliard
   5  *
   6  * Enhacements by Juergen Marquardt 1996
   7  *
   8  * Implementation of a second font cache which
   9  * will be updated dynamically
  10  */
  11
  12 #include <stdio.h>
  13 #include <stdlib.h>
  14 #include <string.h>
  15 #include <X11/Xatom.h>
  16 #include "font.h"
  17 #include "metafile.h"
  18 #include "callback.h"
  19 #include "options.h"
  20 #include "string32.h"
  21 #include "xmalloc.h"
  22 #include "stddebug.h"
  23 #include "debug.h"
  24
  25 #define FONTCACHE       32      /* dynamic font cache size */
  26 #define MAX_FONTS       256
  27 static LPLOGFONT16 lpLogFontList[MAX_FONTS+1];
  28
  29 static int ParseFontParms(LPSTR lpFont, WORD wParmsNo, LPSTR lpRetStr, WORD wMaxSiz);
  30
  31 #define CI_NONEXISTCHAR(cs) (((cs)->width == 0) && \
  32                              (((cs)->rbearing|(cs)->lbearing| \
  33                                (cs)->ascent|(cs)->descent) == 0))
  34
  35 /*
  36  * CI_GET_CHAR_INFO - return the charinfo struct for the indicated 8bit
  37  * character.  If the character is in the column and exists, then return the
  38  * appropriate metrics (note that fonts with common per-character metrics will
  39  * return min_bounds).  If none of these hold true, try again with the default
  40  * char.
  41  */
  42 #define CI_GET_CHAR_INFO(fs,col,def,cs) \
  43 { \
  44     cs = def; \
  45     if (col >= fs->min_char_or_byte2 && col <= fs->max_char_or_byte2) { \
  46         if (fs->per_char == NULL) { \
  47             cs = &fs->min_bounds; \
  48         } else { \
  49             cs = &fs->per_char[(col - fs->min_char_or_byte2)]; \
  50             if (CI_NONEXISTCHAR(cs)) cs = def; \
  51         } \
  52     } \
  53 }
  54
  55 #define CI_GET_DEFAULT_INFO(fs,cs) \
  56   CI_GET_CHAR_INFO(fs, fs->default_char, NULL, cs)
  57
  58 struct FontStructure {
  59         char *window;
  60         char *x11;
  61 } FontNames[32];
  62 int FontSize;
  63
  64
  65 /***********************************************************************
  66  *           FONT_Init
  67  */
  68 BOOL FONT_Init( void )
  69 {
  70   char  temp[1024];
  71   LPSTR ptr;
  72   int i;
  73
  74   if (PROFILE_GetWineIniString( "fonts", NULL, "*", temp, sizeof(temp) ) > 2 )
  75   {
  76     for( ptr = temp, i = 1; strlen(ptr) != 0; ptr += strlen(ptr) + 1 )
  77       if( strcmp( ptr, "default" ) )
  78         FontNames[i++].window = xstrdup( ptr );
  79     FontSize = i;
  80
  81     for( i = 1; i < FontSize; i++ )
  82     {
  83         PROFILE_GetWineIniString( "fonts", FontNames[i].window, "*",
  84                                   temp, sizeof(temp) );
  85         FontNames[i].x11 = xstrdup( temp );
  86     }
  87     PROFILE_GetWineIniString( "fonts", "default", "*", temp, sizeof(temp) );
  88     FontNames[0].x11 = xstrdup( temp );
  89
  90   } else {
  91     FontNames[0].window = NULL; FontNames[0].x11 = "*-helvetica";
  92     FontNames[1].window = "ms sans serif"; FontNames[1].x11 = "*-helvetica";
  93     FontNames[2].window = "ms serif"; FontNames[2].x11 = "*-times";
  94     FontNames[3].window = "fixedsys"; FontNames[3].x11 = "*-fixed";
  95     FontNames[4].window = "arial"; FontNames[4].x11 = "*-helvetica";
  96     FontNames[5].window = "helv"; FontNames[5].x11 = "*-helvetica";
  97     FontNames[6].window = "roman"; FontNames[6].x11 = "*-times";
  98     FontSize = 7;
  99   }
 100   return TRUE;
 101 }
 102
 103 /***********************************************************************
 104  *           FONT_ChkX11Family
 105  *
 106  * returns a valid X11 equivalent if a Windows face name
 107  * is like a X11 family  - or NULL if translation is needed
 108  */
 109 static char *FONT_ChkX11Family(char *winFaceName )
 110 {
 111   static char x11fam[32+2];   /* will be returned */
 112   int i;
 113
 114   for(i = 0; lpLogFontList[i] != NULL; i++)
 115     if( !lstrcmpi32A(winFaceName, lpLogFontList[i]->lfFaceName) )
 116     {
 117         strcpy(x11fam,"*-");
 118         return strcat(x11fam,winFaceName);
 119     }
 120   return NULL;               /* a FONT_TranslateName() call is needed */
 121 }
 122
 123
 124
 125 /***********************************************************************
 126  *           FONT_TranslateName
 127  *
 128  * Translate a Windows face name to its X11 equivalent.
 129  * This will probably have to be customizable.
 130  */
 131 static const char *FONT_TranslateName( char *winFaceName )
 132 {
 133   int i;
 134
 135   for (i = 1; i < FontSize; i ++)
 136     if( !strcmp( winFaceName, FontNames[i].window ) ) {
 137       dprintf_font(stddeb, "---- Mapped %s to %s\n", winFaceName, FontNames[i].x11 );
 138       return FontNames[i].x11;
 139     }
 140   return FontNames[0].x11;
 141 }
 142
 143
 144 /***********************************************************************
 145  *           FONT_MatchFont
 146  *
 147  * Find a X font matching the logical font.
 148  */
 149 static XFontStruct * FONT_MatchFont( LOGFONT16 * font, DC * dc )
 150 {
 151     char pattern[100];
 152     const char *family, *weight, *charset;
 153     char **names;
 154     char slant, oldspacing, spacing;
 155     int width, height, oldheight, count;
 156     XFontStruct * fontStruct;
 157
 158     dprintf_font(stddeb,
 159         "FONT_MatchFont(H,W = %d,%d; Weight = %d; Italic = %d; FaceName = '%s'\n",
 160         font->lfHeight, font->lfWidth, font->lfWeight, font->lfItalic, font->lfFaceName);
 161     weight = (font->lfWeight > 550) ? "bold" : "medium";
 162     slant = font->lfItalic ? 'i' : 'r';
 163     if (font->lfHeight == -1)
 164         height = 0;
 165     else
 166         height = font->lfHeight * dc->w.VportExtX / dc->w.WndExtX;
 167     if (height == 0) height = 120;  /* Default height = 12 */
 168     else if (height < 0)
 169     {
 170         /* If height is negative, it means the height of the characters */
 171         /* *without* the internal leading. So we adjust it a bit to     */
 172         /* compensate. 5/4 seems to give good results for small fonts.  */
 173         /*
 174          * J.M.: This causes wrong font size for bigger fonts e.g. in Winword & Write
 175         height = 10 * (-height * 9 / 8);
 176          * may be we have to use an non linear function
 177         */
 178         /* assume internal leading is 2 pixels. Else small fonts will become
 179          * very small. */
 180         height = (height-2) * -10;
 181     }
 182     else height *= 10;
 183     width  = 10 * (font->lfWidth * dc->w.VportExtY / dc->w.WndExtY);
 184     if (width < 0) {
 185         dprintf_font( stddeb, "FONT_MatchFont: negative width %d(%d)\n",
 186                       width, font->lfWidth );
 187         width = -width;
 188     }
 189
 190     spacing = (font->lfPitchAndFamily & FIXED_PITCH) ? 'm' :
 191               (font->lfPitchAndFamily & VARIABLE_PITCH) ? 'p' : '*';
 192
 193
 194     charset = (font->lfCharSet == ANSI_CHARSET) ? "iso8859-1" : "*-*";
 195     if (*font->lfFaceName) {
 196         family = FONT_ChkX11Family(font->lfFaceName);
 197         /*--do _not_ translate if lfFaceName is family from X11  A.K.*/
 198         if (!family)
 199           family = FONT_TranslateName( font->lfFaceName );
 200         /* FIX ME: I don't if that's correct but it works J.M. */
 201         spacing = '*';
 202         }
 203     else switch(font->lfPitchAndFamily & 0xf0)
 204     {
 205     case FF_ROMAN:
 206       family = FONT_TranslateName( "roman" );
 207       break;
 208     case FF_SWISS:
 209       family = FONT_TranslateName( "swiss" );
 210       break;
 211     case FF_MODERN:
 212       family = FONT_TranslateName( "modern" );
 213       break;
 214     case FF_SCRIPT:
 215       family = FONT_TranslateName( "script" );
 216       break;
 217     case FF_DECORATIVE:
 218       family = FONT_TranslateName( "decorative" );
 219       break;
 220     default:
 221       family = "*-*";
 222       break;
 223     }
 224     oldheight = height;
 225     oldspacing = spacing;
 226     while (TRUE) {
 227             /* Width==0 seems not to be a valid wildcard on SGI's, using * instead */
 228             if ( width == 0 )
 229               sprintf( pattern, "-%s-%s-%c-normal-*-*-%d-*-*-%c-*-%s",
 230                       family, weight, slant, height, spacing, charset);
 231             else
 232               sprintf( pattern, "-%s-%s-%c-normal-*-*-%d-*-*-%c-%d-%s",
 233                       family, weight, slant, height, spacing, width, charset);
 234             dprintf_font(stddeb, "FONT_MatchFont: '%s'\n", pattern );
 235             names = XListFonts( display, pattern, 1, &count );
 236             if (count > 0) break;
 237             if (spacing == 'm') /* try 'c' if no 'm' found */ {
 238
 239                 spacing = 'c';
 240                 continue;
 241             } else if (spacing == 'p') /* try '*' if no 'p' found */ {
 242                 spacing = '*';
 243                 continue;
 244             }
 245             spacing = oldspacing;
 246             height -= 10;
 247             if (height < 10) {
 248                 if (slant == 'i') {
 249                     /* try oblique if no italic font */
 250                     slant = 'o';
 251                     height = oldheight;
 252                     continue;
 253                 }
 254                 if (spacing == 'm' && strcmp(family, "*-*") != 0) {
 255                     /* If a fixed spacing font could not be found, ignore
 256                      * the family */
 257                     family = "*-*";
 258                     height = oldheight;
 259                     continue;
 260                 }
 261                 fprintf(stderr, "FONT_MatchFont(%s) : returning NULL\n", pattern);
 262                 return NULL;
 263             }
 264     }
 265     dprintf_font(stddeb,"        Found '%s'\n", *names );
 266     if (!*font->lfFaceName)
 267       ParseFontParms(*names, 2, font->lfFaceName , LF_FACESIZE-1);
 268       /* we need a font name for function GetTextFace() even if there isn't one ;-) */
 269     AnsiUpper(font->lfFaceName);
 270
 271     fontStruct = XLoadQueryFont( display, *names );
 272     XFreeFontNames( names );
 273     return fontStruct;
 274 }
 275
 276
 277 /***********************************************************************
 278  *           FONT_GetMetrics
 279  */
 280 void FONT_GetMetrics( LOGFONT16 * logfont, XFontStruct * xfont,
 281                       TEXTMETRIC16 * metrics )
 282 {
 283     int average, i, count;
 284     unsigned long prop;
 285
 286     metrics->tmAscent  = xfont->ascent;
 287     metrics->tmDescent = xfont->descent;
 288     metrics->tmHeight  = xfont->ascent + xfont->descent;
 289
 290     metrics->tmInternalLeading  = 0;
 291     if (XGetFontProperty( xfont, XA_X_HEIGHT, &prop ))
 292         metrics->tmInternalLeading = xfont->ascent - (short)prop;
 293     metrics->tmExternalLeading  = 0;
 294     metrics->tmMaxCharWidth     = xfont->max_bounds.width;
 295     metrics->tmWeight           = logfont->lfWeight;
 296     metrics->tmItalic           = logfont->lfItalic;
 297     metrics->tmUnderlined       = logfont->lfUnderline;
 298     metrics->tmStruckOut        = logfont->lfStrikeOut;
 299     metrics->tmFirstChar        = xfont->min_char_or_byte2;
 300     metrics->tmLastChar         = xfont->max_char_or_byte2;
 301     metrics->tmDefaultChar      = xfont->default_char;
 302     metrics->tmBreakChar        = ' ';
 303     metrics->tmCharSet          = logfont->lfCharSet;
 304     metrics->tmOverhang         = 0;
 305     metrics->tmDigitizedAspectX = 1;
 306     metrics->tmDigitizedAspectY = 1;
 307     metrics->tmPitchAndFamily   = (logfont->lfPitchAndFamily&0xf0)|TMPF_DEVICE;
 308     if (logfont->lfPitchAndFamily & FIXED_PITCH)
 309         metrics->tmPitchAndFamily |= TMPF_FIXED_PITCH;
 310
 311     if (!xfont->per_char) average = metrics->tmMaxCharWidth;
 312     else
 313     {
 314         XCharStruct * charPtr = xfont->per_char;
 315         average = count = 0;
 316         for (i = metrics->tmFirstChar; i <= metrics->tmLastChar; i++)
 317         {
 318             if (!CI_NONEXISTCHAR( charPtr ))
 319             {
 320                 average += charPtr->width;
 321                 count++;
 322             }
 323             charPtr++;
 324         }
 325         if (count) average = (average + count/2) / count;
 326     }
 327     metrics->tmAveCharWidth = average;
 328 }
 329
 330 /***********************************************************************
 331  *           GetGlyphOutLine    (GDI.309)
 332  */
 333 DWORD GetGlyphOutLine(HDC hdc, UINT uChar, UINT fuFormat, LPGLYPHMETRICS lpgm,
 334                       DWORD cbBuffer, LPSTR lpBuffer, LPMAT2 lpmat2)
 335 {
 336     fprintf( stdnimp,"GetGlyphOutLine(%04x, '%c', %04x, %p, %ld, %p, %p) // - empty stub!\n",
 337              hdc, uChar, fuFormat, lpgm, cbBuffer, lpBuffer, lpmat2 );
 338     return (DWORD)-1; /* failure */
 339 }
 340
 341
 342 /***********************************************************************
 343  *           CreateScalableFontResource    (GDI.310)
 344  */
 345 BOOL CreateScalableFontResource( UINT fHidden,LPSTR lpszResourceFile,
 346                                  LPSTR lpszFontFile, LPSTR lpszCurrentPath )
 347 {
 348     /* fHidden=1 - only visible for the calling app, read-only, not
 349      * enumbered with EnumFonts/EnumFontFamilies
 350      * lpszCurrentPath can be NULL
 351      */
 352     fprintf(stdnimp,"CreateScalableFontResource(%d,%s,%s,%s) // empty stub!\n",
 353             fHidden, lpszResourceFile, lpszFontFile, lpszCurrentPath );
 354     return FALSE; /* create failed */
 355 }
 356
 357
 358 /***********************************************************************
 359  *           CreateFontIndirect16   (GDI.57)
 360  */
 361 HFONT16 CreateFontIndirect16( const LOGFONT16 *font )
 362 {
 363     FONTOBJ * fontPtr;
 364     HFONT16 hfont;
 365
 366     if (!font)
 367     {
 368         fprintf(stderr,"CreateFontIndirect: font is NULL : returning NULL\n");
 369         return 0;
 370     }
 371     hfont = GDI_AllocObject( sizeof(FONTOBJ), FONT_MAGIC );
 372     if (!hfont) return 0;
 373     fontPtr = (FONTOBJ *) GDI_HEAP_LIN_ADDR( hfont );
 374     memcpy( &fontPtr->logfont, font, sizeof(LOGFONT16) );
 375     AnsiLower( fontPtr->logfont.lfFaceName );
 376     dprintf_font(stddeb,"CreateFontIndirect(%p (%d,%d)); return %04x\n",
 377         font, font->lfHeight, font->lfWidth, hfont);
 378     return hfont;
 379 }
 380
 381
 382 /***********************************************************************
 383  *           CreateFontIndirect32A   (GDI32.44)
 384  */
 385 HFONT32 CreateFontIndirect32A( const LOGFONT32A *font )
 386 {
 387     LOGFONT16 font16;
 388
 389     font16.lfHeight         = (INT16)font->lfHeight;
 390     font16.lfWidth          = (INT16)font->lfWidth;
 391     font16.lfEscapement     = (INT16)font->lfEscapement;
 392     font16.lfOrientation    = (INT16)font->lfOrientation;
 393     font16.lfWeight         = (INT16)font->lfWeight;
 394     font16.lfItalic         = font->lfItalic;
 395     font16.lfUnderline      = font->lfUnderline;
 396     font16.lfStrikeOut      = font->lfStrikeOut;
 397     font16.lfCharSet        = font->lfCharSet;
 398     font16.lfOutPrecision   = font->lfOutPrecision;
 399     font16.lfClipPrecision  = font->lfClipPrecision;
 400     font16.lfQuality        = font->lfQuality;
 401     font16.lfPitchAndFamily = font->lfPitchAndFamily;
 402     lstrcpyn32A( font16.lfFaceName, font->lfFaceName, LF_FACESIZE );
 403     return CreateFontIndirect16( &font16 );
 404 }
 405
 406
 407 /***********************************************************************
 408  *           CreateFontIndirect32W   (GDI32.45)
 409  */
 410 HFONT32 CreateFontIndirect32W( const LOGFONT32W *font )
 411 {
 412     LOGFONT16 font16;
 413
 414     font16.lfHeight         = (INT16)font->lfHeight;
 415     font16.lfWidth          = (INT16)font->lfWidth;
 416     font16.lfEscapement     = (INT16)font->lfEscapement;
 417     font16.lfOrientation    = (INT16)font->lfOrientation;
 418     font16.lfWeight         = (INT16)font->lfWeight;
 419     font16.lfItalic         = font->lfItalic;
 420     font16.lfUnderline      = font->lfUnderline;
 421     font16.lfStrikeOut      = font->lfStrikeOut;
 422     font16.lfCharSet        = font->lfCharSet;
 423     font16.lfOutPrecision   = font->lfOutPrecision;
 424     font16.lfClipPrecision  = font->lfClipPrecision;
 425     font16.lfQuality        = font->lfQuality;
 426     font16.lfPitchAndFamily = font->lfPitchAndFamily;
 427     lstrcpynWtoA( font16.lfFaceName, font->lfFaceName, LF_FACESIZE );
 428     return CreateFontIndirect16( &font16 );
 429 }
 430
 431
 432 /***********************************************************************
 433  *           CreateFont    (GDI.56)
 434  */
 435 HFONT CreateFont( INT height, INT width, INT esc, INT orient, INT weight,
 436                   BYTE italic, BYTE underline, BYTE strikeout, BYTE charset,
 437                   BYTE outpres, BYTE clippres, BYTE quality, BYTE pitch,
 438                   LPCSTR name )
 439 {
 440     LOGFONT16 logfont = {height, width, esc, orient, weight, italic, underline,
 441                       strikeout, charset, outpres, clippres, quality, pitch, };
 442     dprintf_font(stddeb,"CreateFont(%d,%d)\n", height, width);
 443     if (name) lstrcpyn32A(logfont.lfFaceName,name,sizeof(logfont.lfFaceName));
 444     else logfont.lfFaceName[0] = '\0';
 445     return CreateFontIndirect16( &logfont );
 446 }
 447
 448
 449 /***********************************************************************
 450  *           FONT_GetObject
 451  */
 452 int FONT_GetObject( FONTOBJ * font, int count, LPSTR buffer )
 453 {
 454     if (count > sizeof(LOGFONT16)) count = sizeof(LOGFONT16);
 455     memcpy( buffer, &font->logfont, count );
 456     return count;
 457 }
 458
 459
 460 /***********************************************************************
 461  *           FONT_SelectObject
 462  */
 463 HFONT FONT_SelectObject( DC * dc, HFONT hfont, FONTOBJ * font )
 464 {
 465     static X_PHYSFONT stockFonts[LAST_STOCK_FONT-FIRST_STOCK_FONT+1];
 466
 467     static struct {
 468                 HFONT           id;
 469                 LOGFONT16       logfont;
 470                 int             access;
 471                 int             used;
 472                 X_PHYSFONT      cacheFont; } cacheFonts[FONTCACHE], *cacheFontsMin;
 473     int         i;
 474
 475     X_PHYSFONT * stockPtr;
 476     HFONT prevHandle = dc->w.hFont;
 477     XFontStruct * fontStruct;
 478     dprintf_font(stddeb,"FONT_SelectObject(%p, %04x, %p)\n", dc, hfont, font);
 479
 480 #if 0 /* From the code in SelectObject, this can not happen */
 481       /* Load font if necessary */
 482     if (!font)
 483     {
 484         HFONT hnewfont;
 485
 486         hnewfont = CreateFont(10, 7, 0, 0, FW_DONTCARE,
 487                               FALSE, FALSE, FALSE, DEFAULT_CHARSET, 0, 0,
 488                               DEFAULT_QUALITY, FF_DONTCARE, "*" );
 489         font = (FONTOBJ *) GDI_HEAP_LIN_ADDR( hnewfont );
 490     }
 491 #endif
 492
 493     if (dc->header.wMagic == METAFILE_DC_MAGIC)
 494       if (MF_CreateFontIndirect(dc, hfont, &(font->logfont)))
 495         return prevHandle;
 496       else
 497         return 0;
 498
 499     if ((hfont >= FIRST_STOCK_FONT) && (hfont <= LAST_STOCK_FONT))
 500         stockPtr = &stockFonts[hfont - FIRST_STOCK_FONT];
 501     else {
 502         stockPtr = NULL;
 503         /*
 504          * Ok, It's not a stock font but
 505          * may be it's cached in dynamic cache
 506          */
 507         for(i=0; i<FONTCACHE; i++) /* search for same handle */
 508              if (cacheFonts[i].id==hfont) { /* Got the handle */
 509                 /*
 510                  * Check if Handle matches the font
 511                  */
 512                 if(memcmp(&cacheFonts[i].logfont,&(font->logfont), sizeof(LOGFONT16))) {
 513                         /* No: remove handle id from dynamic font cache */
 514                         cacheFonts[i].access=0;
 515                         cacheFonts[i].used=0;
 516                         cacheFonts[i].id=0;
 517                         /* may be there is an unused handle which contains the font */
 518                         for(i=0; i<FONTCACHE; i++) {
 519                                 if((cacheFonts[i].used == 0) &&
 520                                   (memcmp(&cacheFonts[i].logfont,&(font->logfont), sizeof(LOGFONT16)))== 0) {
 521                                         /* got it load from cache and set new handle id */
 522                                         stockPtr = &cacheFonts[i].cacheFont;
 523                                         cacheFonts[i].access=1;
 524                                         cacheFonts[i].used=1;
 525                                         cacheFonts[i].id=hfont;
 526                                         dprintf_font(stddeb,"FONT_SelectObject: got font from unused handle\n");
 527                                         break;
 528                                         }
 529                                 }
 530
 531                         }
 532                 else {
 533                         /* Yes: load from dynamic font cache */
 534                         stockPtr = &cacheFonts[i].cacheFont;
 535                         cacheFonts[i].access++;
 536                         cacheFonts[i].used++;
 537                         }
 538                 break;
 539                 }
 540         }
 541     if (!stockPtr || !stockPtr->fstruct)
 542     {
 543         if (!(fontStruct = FONT_MatchFont( &font->logfont, dc )))
 544         {
 545               /* If it is not a stock font, we can simply return 0 */
 546             if (!stockPtr) return 0;
 547               /* Otherwise we must try to find a substitute */
 548             dprintf_font(stddeb,"Loading font 'fixed' for %04x\n", hfont );
 549             font->logfont.lfPitchAndFamily &= ~VARIABLE_PITCH;
 550             font->logfont.lfPitchAndFamily |= FIXED_PITCH;
 551             fontStruct = XLoadQueryFont( display, "fixed" );
 552             if (!fontStruct)
 553             {
 554                 fprintf( stderr, "No system font could be found. Please check your font path.\n" );
 555                 exit( 1 );
 556             }
 557         }
 558     }
 559     else
 560     {
 561         fontStruct = stockPtr->fstruct;
 562         dprintf_font(stddeb,
 563                      "FONT_SelectObject: Loaded font from cache %04x %p\n",
 564                      hfont, fontStruct );
 565     }
 566
 567       /* Unuse previous font */
 568         for (i=0; i < FONTCACHE; i++) {
 569                 if (cacheFonts[i].id == prevHandle) {
 570                         if(cacheFonts[i].used == 0)
 571                                 fprintf(stderr, "Trying to decrement a use count of 0.\n");
 572                         else
 573                                 cacheFonts[i].used--;
 574                 }
 575         }
 576
 577       /* Store font */
 578     dc->w.hFont = hfont;
 579     if (stockPtr)
 580     {
 581         if (!stockPtr->fstruct)
 582         {
 583             stockPtr->fstruct = fontStruct;
 584             FONT_GetMetrics( &font->logfont, fontStruct, &stockPtr->metrics );
 585         }
 586         memcpy( &dc->u.x.font, stockPtr, sizeof(*stockPtr) );
 587     }
 588     else
 589     {
 590         /*
 591          * Check in cacheFont
 592          */
 593         cacheFontsMin=NULL;
 594         for (i=0; i < FONTCACHE; i++) {
 595                 if (cacheFonts[i].used==0)
 596                         if ((!cacheFontsMin) || ((cacheFontsMin) && (cacheFontsMin->access > cacheFonts[i].access)))
 597                                 cacheFontsMin=&cacheFonts[i];
 598                 }
 599         if (!cacheFontsMin) {
 600                 fprintf(stderr,"No unused font cache entry !!!!\n" );
 601                 return prevHandle;
 602         }
 603         if (cacheFontsMin->id!=0) {
 604                 dprintf_font(stddeb,
 605                         "FONT_SelectObject: Freeing %04x \n",cacheFontsMin->id );
 606                 XFreeFont( display, cacheFontsMin->cacheFont.fstruct );
 607                 }
 608         cacheFontsMin->cacheFont.fstruct = fontStruct;
 609         FONT_GetMetrics( &font->logfont, fontStruct, &cacheFontsMin->cacheFont.metrics );
 610         cacheFontsMin->access=1;
 611         cacheFontsMin->used=1;
 612         cacheFontsMin->id=hfont;
 613         memcpy( &dc->u.x.font, &(cacheFontsMin->cacheFont), sizeof(cacheFontsMin->cacheFont) );
 614         memcpy(&cacheFontsMin->logfont,&(font->logfont), sizeof(LOGFONT16));
 615
 616     }
 617     return prevHandle;
 618 }
 619
 620
 621 /***********************************************************************
 622  *           GetTextCharacterExtra    (GDI.89)
 623  */
 624 short GetTextCharacterExtra( HDC hdc )
 625 {
 626     DC * dc = (DC *) GDI_GetObjPtr( hdc, DC_MAGIC );
 627     if (!dc) return 0;
 628     return abs( (dc->w.charExtra * dc->w.WndExtX + dc->w.VportExtX / 2)
 629                  / dc->w.VportExtX );
 630 }
 631
 632
 633 /***********************************************************************
 634  *           SetTextCharacterExtra    (GDI.8)
 635  */
 636 short SetTextCharacterExtra( HDC hdc, short extra )
 637 {
 638     short prev;
 639     DC * dc = (DC *) GDI_GetObjPtr( hdc, DC_MAGIC );
 640     if (!dc) return 0;
 641     extra = (extra * dc->w.VportExtX + dc->w.WndExtX / 2) / dc->w.WndExtX;
 642     prev = dc->w.charExtra;
 643     dc->w.charExtra = abs(extra);
 644     return (prev * dc->w.WndExtX + dc->w.VportExtX / 2) / dc->w.VportExtX;
 645 }
 646
 647
 648 /***********************************************************************
 649  *           SetTextJustification    (GDI.10)
 650  */
 651 short SetTextJustification( HDC hdc, short extra, short breaks )
 652 {
 653     DC * dc = (DC *) GDI_GetObjPtr( hdc, DC_MAGIC );
 654     if (!dc) return 0;
 655
 656     extra = abs((extra * dc->w.VportExtX + dc->w.WndExtX / 2) / dc->w.WndExtX);
 657     if (!extra) breaks = 0;
 658     dc->w.breakTotalExtra = extra;
 659     dc->w.breakCount = breaks;
 660     if (breaks)
 661     {
 662         dc->w.breakExtra = extra / breaks;
 663         dc->w.breakRem   = extra - (dc->w.breakCount * dc->w.breakExtra);
 664     }
 665     else
 666     {
 667         dc->w.breakExtra = 0;
 668         dc->w.breakRem   = 0;
 669     }
 670     return 1;
 671 }
 672
 673
 674 /***********************************************************************
 675  *           GetTextFace    (GDI.92)
 676  */
 677 INT GetTextFace( HDC hdc, INT count, LPSTR name )
 678 {
 679     FONTOBJ *font;
 680
 681     DC * dc = (DC *) GDI_GetObjPtr( hdc, DC_MAGIC );
 682     if (!dc) return 0;
 683     if (!(font = (FONTOBJ *) GDI_GetObjPtr( dc->w.hFont, FONT_MAGIC )))
 684         return 0;
 685     lstrcpyn32A( name, font->logfont.lfFaceName, count );
 686     return strlen(name);
 687 }
 688
 689
 690 /***********************************************************************
 691  *           GetTextExtent    (GDI.91)
 692  */
 693 DWORD GetTextExtent( HDC hdc, LPCSTR str, short count )
 694 {
 695     SIZE16 size;
 696     if (!GetTextExtentPoint16( hdc, str, count, &size )) return 0;
 697     return MAKELONG( size.cx, size.cy );
 698 }
 699
 700
 701 /***********************************************************************
 702  *           GetTextExtentPoint16    (GDI.471)
 703  */
 704 BOOL16 GetTextExtentPoint16( HDC16 hdc, LPCSTR str, INT16 count, LPSIZE16 size)
 705 {
 706     SIZE32 size32;
 707     BOOL32 ret = GetTextExtentPoint32A( hdc, str, count, &size32 );
 708     CONV_SIZE32TO16( &size32, size );
 709     return (BOOL16)ret;
 710 }
 711
 712
 713 /***********************************************************************
 714  *           GetTextExtentPoint32A    (GDI32.232)
 715  */
 716 BOOL32 GetTextExtentPoint32A( HDC32 hdc, LPCSTR str, INT32 count,
 717                               LPSIZE32 size )
 718 {
 719     int dir, ascent, descent;
 720     XCharStruct info;
 721
 722     DC * dc = (DC *) GDI_GetObjPtr( hdc, DC_MAGIC );
 723     if (!dc) return FALSE;
 724     XTextExtents( dc->u.x.font.fstruct, str, count, &dir,
 725                   &ascent, &descent, &info );
 726     size->cx = abs((info.width + dc->w.breakRem + count * dc->w.charExtra)
 727                     * dc->w.WndExtX / dc->w.VportExtX);
 728     size->cy = abs((dc->u.x.font.fstruct->ascent+dc->u.x.font.fstruct->descent)
 729                     * dc->w.WndExtY / dc->w.VportExtY);
 730
 731     dprintf_font(stddeb,"GetTextExtentPoint(%08x '%*.*s' %d %p): returning %d,%d\n",
 732                  hdc, count, count, str, count, size, size->cx, size->cy );
 733     return TRUE;
 734 }
 735
 736
 737 /***********************************************************************
 738  *           GetTextExtentPoint32W    (GDI32.233)
 739  */
 740 BOOL32 GetTextExtentPoint32W( HDC32 hdc, LPCWSTR str, INT32 count,
 741                               LPSIZE32 size )
 742 {
 743     char *p = STRING32_DupUniToAnsi( str );
 744     BOOL32 ret = GetTextExtentPoint32A( hdc, p, count, size );
 745     free( p );
 746     return ret;
 747 }
 748
 749
 750 /***********************************************************************
 751  *           GetTextMetrics16    (GDI.93)
 752  */
 753 BOOL16 GetTextMetrics16( HDC16 hdc, TEXTMETRIC16 *metrics )
 754 {
 755     DC * dc = (DC *) GDI_GetObjPtr( hdc, DC_MAGIC );
 756     if (!dc) return FALSE;
 757     memcpy( metrics, &dc->u.x.font.metrics, sizeof(*metrics) );
 758
 759     metrics->tmAscent  = abs( metrics->tmAscent
 760                               * dc->w.WndExtY / dc->w.VportExtY );
 761     metrics->tmDescent = abs( metrics->tmDescent
 762                               * dc->w.WndExtY / dc->w.VportExtY );
 763     metrics->tmHeight  = metrics->tmAscent + metrics->tmDescent;
 764     metrics->tmInternalLeading = abs( metrics->tmInternalLeading
 765                                       * dc->w.WndExtY / dc->w.VportExtY );
 766     metrics->tmExternalLeading = abs( metrics->tmExternalLeading
 767                                       * dc->w.WndExtY / dc->w.VportExtY );
 768     metrics->tmMaxCharWidth    = abs( metrics->tmMaxCharWidth
 769                                       * dc->w.WndExtX / dc->w.VportExtX );
 770     metrics->tmAveCharWidth    = abs( metrics->tmAveCharWidth
 771                                       * dc->w.WndExtX / dc->w.VportExtX );
 772
 773     dprintf_font(stdnimp,"text metrics:\n
 774         InternalLeading = %i
 775         ExternalLeading = %i
 776         MaxCharWidth = %i
 777         Weight = %i
 778         Italic = %i
 779         Underlined = %i
 780         StruckOut = %i
 781         FirstChar = %i
 782         LastChar = %i
 783         DefaultChar = %i
 784         BreakChar = %i
 785         CharSet = %i
 786         Overhang = %i
 787         DigitizedAspectX = %i
 788         DigitizedAspectY = %i
 789         AveCharWidth = %i
 790         MaxCharWidth = %i
 791         Ascent = %i
 792         Descent = %i
 793         Height = %i\n",
 794     metrics->tmInternalLeading,
 795     metrics->tmExternalLeading,
 796     metrics->tmMaxCharWidth,
 797     metrics->tmWeight,
 798     metrics->tmItalic,
 799     metrics->tmUnderlined,
 800     metrics->tmStruckOut,
 801     metrics->tmFirstChar,
 802     metrics->tmLastChar,
 803     metrics->tmDefaultChar,
 804     metrics->tmBreakChar,
 805     metrics->tmCharSet,
 806     metrics->tmOverhang,
 807     metrics->tmDigitizedAspectX,
 808     metrics->tmDigitizedAspectY,
 809     metrics->tmAveCharWidth,
 810     metrics->tmMaxCharWidth,
 811     metrics->tmAscent,
 812     metrics->tmDescent,
 813     metrics->tmHeight);
 814
 815     return TRUE;
 816 }
 817
 818
 819 /***********************************************************************
 820  *           GetTextMetrics32A    (GDI32.236)
 821  */
 822 BOOL32 GetTextMetrics32A( HDC32 hdc, TEXTMETRIC32A *metrics )
 823 {
 824     TEXTMETRIC16 tm;
 825     if (!GetTextMetrics16( (HDC16)hdc, &tm )) return FALSE;
 826     metrics->tmHeight           = tm.tmHeight;
 827     metrics->tmAscent           = tm.tmAscent;
 828     metrics->tmDescent          = tm.tmDescent;
 829     metrics->tmInternalLeading  = tm.tmInternalLeading;
 830     metrics->tmExternalLeading  = tm.tmExternalLeading;
 831     metrics->tmAveCharWidth     = tm.tmAveCharWidth;
 832     metrics->tmMaxCharWidth     = tm.tmMaxCharWidth;
 833     metrics->tmWeight           = tm.tmWeight;
 834     metrics->tmOverhang         = tm.tmOverhang;
 835     metrics->tmDigitizedAspectX = tm.tmDigitizedAspectX;
 836     metrics->tmDigitizedAspectY = tm.tmDigitizedAspectY;
 837     metrics->tmFirstChar        = tm.tmFirstChar;
 838     metrics->tmLastChar         = tm.tmLastChar;
 839     metrics->tmDefaultChar      = tm.tmDefaultChar;
 840     metrics->tmBreakChar        = tm.tmBreakChar;
 841     metrics->tmItalic           = tm.tmItalic;
 842     metrics->tmUnderlined       = tm.tmUnderlined;
 843     metrics->tmStruckOut        = tm.tmStruckOut;
 844     metrics->tmPitchAndFamily   = tm.tmPitchAndFamily;
 845     metrics->tmCharSet          = tm.tmCharSet;
 846     return TRUE;
 847 }
 848
 849
 850 /***********************************************************************
 851  *           GetTextMetrics32W    (GDI32.237)
 852  */
 853 BOOL32 GetTextMetrics32W( HDC32 hdc, TEXTMETRIC32W *metrics )
 854 {
 855     TEXTMETRIC16 tm;
 856     if (!GetTextMetrics16( (HDC16)hdc, &tm )) return FALSE;
 857     metrics->tmHeight           = tm.tmHeight;
 858     metrics->tmAscent           = tm.tmAscent;
 859     metrics->tmDescent          = tm.tmDescent;
 860     metrics->tmInternalLeading  = tm.tmInternalLeading;
 861     metrics->tmExternalLeading  = tm.tmExternalLeading;
 862     metrics->tmAveCharWidth     = tm.tmAveCharWidth;
 863     metrics->tmMaxCharWidth     = tm.tmMaxCharWidth;
 864     metrics->tmWeight           = tm.tmWeight;
 865     metrics->tmOverhang         = tm.tmOverhang;
 866     metrics->tmDigitizedAspectX = tm.tmDigitizedAspectX;
 867     metrics->tmDigitizedAspectY = tm.tmDigitizedAspectY;
 868     metrics->tmFirstChar        = tm.tmFirstChar;
 869     metrics->tmLastChar         = tm.tmLastChar;
 870     metrics->tmDefaultChar      = tm.tmDefaultChar;
 871     metrics->tmBreakChar        = tm.tmBreakChar;
 872     metrics->tmItalic           = tm.tmItalic;
 873     metrics->tmUnderlined       = tm.tmUnderlined;
 874     metrics->tmStruckOut        = tm.tmStruckOut;
 875     metrics->tmPitchAndFamily   = tm.tmPitchAndFamily;
 876     metrics->tmCharSet          = tm.tmCharSet;
 877     return TRUE;
 878 }
 879
 880
 881 /***********************************************************************
 882  *           SetMapperFlags    (GDI.349)
 883  */
 884 DWORD SetMapperFlags(HDC hDC, DWORD dwFlag)
 885 {
 886     dprintf_font(stdnimp,"SetmapperFlags(%04x, %08lX) // Empty Stub !\n",
 887                  hDC, dwFlag);
 888     return 0L;
 889 }
 890
 891
 892 /***********************************************************************
 893  *           GetCharABCWidths   (GDI.307)
 894  */
 895 BOOL GetCharABCWidths(HDC hdc, UINT wFirstChar, UINT wLastChar, LPABC16 lpABC)
 896 {
 897
 898     /* No TrueType fonts in Wine so far */
 899
 900     fprintf(stdnimp,"STUB: GetCharABCWidths(%04x,%04x,%04x,%08x)\n",
 901                            hdc,wFirstChar,wLastChar,(unsigned)lpABC);
 902
 903     return FALSE;
 904 }
 905
 906
 907 /***********************************************************************
 908  *           GetCharWidth    (GDI.350)
 909  */
 910 BOOL GetCharWidth(HDC hdc, WORD wFirstChar, WORD wLastChar, LPINT16 lpBuffer)
 911 {
 912     int i, j;
 913     XFontStruct *xfont;
 914     XCharStruct *cs, *def;
 915
 916     DC *dc = (DC *)GDI_GetObjPtr(hdc, DC_MAGIC);
 917     if (!dc) return FALSE;
 918     xfont = dc->u.x.font.fstruct;
 919
 920     /* fixed font? */
 921     if (xfont->per_char == NULL)
 922     {
 923         for (i = wFirstChar, j = 0; i <= wLastChar; i++, j++)
 924             *(lpBuffer + j) = xfont->max_bounds.width;
 925         return TRUE;
 926     }
 927
 928     CI_GET_DEFAULT_INFO(xfont, def);
 929
 930     for (i = wFirstChar, j = 0; i <= wLastChar; i++, j++)
 931     {
 932         CI_GET_CHAR_INFO(xfont, i, def, cs);
 933         *(lpBuffer + j) = cs ? cs->width : xfont->max_bounds.width;
 934         if (*(lpBuffer + j) < 0)
 935             *(lpBuffer + j) = 0;
 936     }
 937     return TRUE;
 938 }
 939
 940
 941 /***********************************************************************
 942  *           AddFontResource    (GDI.119)
 943  */
 944 INT AddFontResource( LPCSTR str )
 945 {
 946     fprintf( stdnimp, "STUB: AddFontResource('%s')\n", str );
 947     return 1;
 948 }
 949
 950
 951 /***********************************************************************
 952  *           RemoveFontResource    (GDI.136)
 953  */
 954 BOOL RemoveFontResource( LPSTR str )
 955 {
 956     fprintf( stdnimp, "STUB: RemoveFontResource('%s')\n", str );
 957     return TRUE;
 958 }
 959
 960
 961 /*************************************************************************
 962  *                              ParseFontParms          [internal]
 963  */
 964 int ParseFontParms(LPSTR lpFont, WORD wParmsNo, LPSTR lpRetStr, WORD wMaxSiz)
 965 {
 966         int     i;
 967         if (lpFont == NULL) return 0;
 968         if (lpRetStr == NULL) return 0;
 969         for (i = 0; (*lpFont != '\0' && i != wParmsNo); ) {
 970                 if (*lpFont == '-') i++;
 971                 lpFont++;
 972                 }
 973         if (i == wParmsNo) {
 974                 if (*lpFont == '-') lpFont++;
 975                 wMaxSiz--;
 976                 for (i = 0; (*lpFont != '\0' && *lpFont != '-' && i < wMaxSiz); i++)
 977                         *(lpRetStr + i) = *lpFont++;
 978                 *(lpRetStr + i) = '\0';
 979                 return i;
 980                 }
 981         else
 982                 lpRetStr[0] = '\0';
 983         return 0;
 984 }
 985
 986
 987 /*************************************************************************
 988  *                              InitFontsList           [internal]
 989  */
 990
 991 static int logfcmp(const void *a,const void *b)
 992 {
 993   return strcmp( (*(LPLOGFONT16 *)a)->lfFaceName,
 994                  (*(LPLOGFONT16 *)b)->lfFaceName );
 995 }
 996
 997 void InitFontsList(void)
 998 {
 999   char  str[32];
1000   char  pattern[100];
1001   char  *family, *weight, *charset;
1002   char  **names;
1003   char  slant, spacing;
1004   int   i, count;
1005   LPLOGFONT16 lpNewFont;
1006
1007   dprintf_font(stddeb,"InitFontsList !\n");
1008
1009   weight = "medium";
1010   slant = 'r';
1011   spacing = '*';
1012   charset = "*";
1013   family = "*-*";
1014
1015   sprintf( pattern, "-%s-%s-%c-normal-*-*-*-*-*-%c-*-%s",
1016           family, weight, slant, spacing, charset);
1017   names = XListFonts( display, pattern, MAX_FONTS, &count );
1018   dprintf_font(stddeb,"InitFontsList // count=%d \n", count);
1019
1020   lpNewFont = malloc((sizeof(LOGFONT16)+LF_FACESIZE)*count);
1021   if (lpNewFont == NULL) {
1022       dprintf_font(stddeb,
1023                    "InitFontsList // Error alloc new font structure !\n");
1024       XFreeFontNames(names);
1025       return;
1026   }
1027
1028   for (i = 0; i < count; i++) {
1029     dprintf_font(stddeb,"InitFontsList // names[%d]='%s' \n", i, names[i]);
1030
1031     ParseFontParms(names[i], 2, str, sizeof(str));
1032 #if 0
1033     /* not necessary because new function FONT_ChkX11Family() */
1034     if (strcmp(str, "fixed") == 0) strcat(str, "sys");
1035 #endif
1036     AnsiUpper(str);
1037     strcpy(lpNewFont->lfFaceName, str);
1038     ParseFontParms(names[i], 8, str, sizeof(str));
1039     lpNewFont->lfHeight = atoi(str) / 10;
1040     ParseFontParms(names[i], 12, str, sizeof(str));
1041     lpNewFont->lfWidth = atoi(str) / 10;
1042     lpNewFont->lfEscapement = 0;
1043     lpNewFont->lfOrientation = 0;
1044     lpNewFont->lfWeight = FW_REGULAR;
1045     lpNewFont->lfItalic = 0;
1046     lpNewFont->lfUnderline = 0;
1047     lpNewFont->lfStrikeOut = 0;
1048     ParseFontParms(names[i], 13, str, sizeof(str));
1049     if (strcmp(str, "iso8859") == 0)  {
1050       lpNewFont->lfCharSet = ANSI_CHARSET;
1051     } else  {
1052       lpNewFont->lfCharSet = OEM_CHARSET;
1053     }
1054     lpNewFont->lfOutPrecision = OUT_DEFAULT_PRECIS;
1055     lpNewFont->lfClipPrecision = CLIP_DEFAULT_PRECIS;
1056     lpNewFont->lfQuality = DEFAULT_QUALITY;
1057     ParseFontParms(names[i], 11, str, sizeof(str));
1058     switch(str[0]) {
1059      case 'p':
1060       lpNewFont->lfPitchAndFamily = VARIABLE_PITCH | FF_SWISS;
1061       break;
1062      case 'm':
1063      case 'c':
1064       lpNewFont->lfPitchAndFamily = FIXED_PITCH | FF_MODERN;
1065       break;
1066      default:
1067       lpNewFont->lfPitchAndFamily = DEFAULT_PITCH | FF_DONTCARE;
1068       break;
1069     }
1070     dprintf_font( stddeb,
1071                   "InitFontsList // lpNewFont->lfHeight=%d\n",
1072                   lpNewFont->lfHeight );
1073     dprintf_font( stddeb,
1074                   "InitFontsList // lpNewFont->lfWidth=%d\n",
1075                   lpNewFont->lfWidth );
1076     dprintf_font( stddeb,
1077                   "InitFontsList // lfFaceName='%s'\n",
1078                   lpNewFont->lfFaceName );
1079     lpLogFontList[i] = lpNewFont;
1080     lpNewFont = (LPLOGFONT16)
1081       ((char *)lpNewFont + sizeof(LOGFONT16)+LF_FACESIZE);
1082   }
1083   lpLogFontList[i] = NULL;
1084
1085   qsort(lpLogFontList,count,sizeof(*lpLogFontList),logfcmp);
1086   XFreeFontNames(names);
1087 }
1088
1089
1090 /*************************************************************************
1091  *                              EnumFonts                       [GDI.70]
1092  */
1093 INT EnumFonts(HDC hDC, LPCSTR lpFaceName, FONTENUMPROC lpEnumFunc, LPARAM lpData)
1094 {
1095   HANDLE       hLog;
1096   HANDLE       hMet;
1097   HFONT        hFont;
1098   HFONT        hOldFont;
1099   LPLOGFONT16  lpLogFont;
1100   LPTEXTMETRIC16 lptm;
1101   LPSTR        lpOldName;
1102   char         FaceName[LF_FACESIZE];
1103   int          nRet = 0;
1104   int          i;
1105
1106   dprintf_font(stddeb,"EnumFonts(%04x, %p='%s', %08lx, %08lx)\n",
1107                hDC, lpFaceName, lpFaceName, (LONG)lpEnumFunc, lpData);
1108   if (lpEnumFunc == 0) return 0;
1109   hLog = GDI_HEAP_ALLOC( sizeof(LOGFONT16) + LF_FACESIZE );
1110   lpLogFont = (LPLOGFONT16) GDI_HEAP_LIN_ADDR(hLog);
1111   if (lpLogFont == NULL) {
1112     fprintf(stderr,"EnumFonts // can't alloc LOGFONT struct !\n");
1113     return 0;
1114   }
1115   hMet = GDI_HEAP_ALLOC( sizeof(TEXTMETRIC16) );
1116   lptm = (LPTEXTMETRIC16) GDI_HEAP_LIN_ADDR(hMet);
1117   if (lptm == NULL) {
1118     GDI_HEAP_FREE(hLog);
1119     fprintf(stderr, "EnumFonts // can't alloc TEXTMETRIC struct !\n");
1120     return 0;
1121   }
1122   if (lpFaceName != NULL) {
1123     strcpy(FaceName, lpFaceName);
1124     AnsiUpper(FaceName);
1125   }
1126   lpOldName = NULL;
1127
1128   if (lpLogFontList[0] == NULL) InitFontsList();
1129   for(i = 0; lpLogFontList[i] != NULL; i++) {
1130     if (lpFaceName == NULL) {
1131       if (lpOldName != NULL) {
1132         if (strcmp(lpOldName,lpLogFontList[i]->lfFaceName) == 0) continue;
1133       }
1134       lpOldName = lpLogFontList[i]->lfFaceName;
1135     } else {
1136       if (strcmp(FaceName, lpLogFontList[i]->lfFaceName) != 0) continue;
1137     }
1138     dprintf_font(stddeb,"EnumFonts // enum '%s' !\n", lpLogFontList[i]->lfFaceName);
1139     dprintf_font(stddeb,"EnumFonts // %p !\n", lpLogFontList[i]);
1140     memcpy(lpLogFont, lpLogFontList[i], sizeof(LOGFONT16) + LF_FACESIZE);
1141     hFont = CreateFontIndirect16(lpLogFont);
1142     hOldFont = SelectObject(hDC, hFont);
1143     GetTextMetrics16(hDC, lptm);
1144     SelectObject(hDC, hOldFont);
1145     DeleteObject(hFont);
1146     dprintf_font(stddeb,"EnumFonts // i=%d lpLogFont=%p lptm=%p\n", i, lpLogFont, lptm);
1147     nRet = CallEnumFontsProc((FARPROC16)lpEnumFunc, GDI_HEAP_SEG_ADDR(hLog),
1148                              GDI_HEAP_SEG_ADDR(hMet), 0, (LONG)lpData );
1149     if (nRet == 0) {
1150       dprintf_font(stddeb,"EnumFonts // EnumEnd requested by application !\n");
1151       break;
1152     }
1153   }
1154   GDI_HEAP_FREE(hMet);
1155   GDI_HEAP_FREE(hLog);
1156   return nRet;
1157 }
1158
1159
1160 /*************************************************************************
1161  *                              EnumFontFamilies        [GDI.330]
1162  */
1163 INT EnumFontFamilies(HDC hDC, LPCSTR lpszFamily, FONTENUMPROC lpEnumFunc, LPARAM lpData)
1164 {
1165   HANDLE        hLog;
1166   HANDLE        hMet;
1167   HFONT         hFont;
1168   HFONT         hOldFont;
1169   LPENUMLOGFONT16 lpEnumLogFont;
1170   LPTEXTMETRIC16 lptm;
1171   LPSTR         lpOldName;
1172   char          FaceName[LF_FACESIZE];
1173   int           nRet = 0;
1174   int           i;
1175
1176   dprintf_font(stddeb,"EnumFontFamilies(%04x, %p, %08lx, %08lx)\n",
1177                hDC, lpszFamily, (DWORD)lpEnumFunc, lpData);
1178   if (lpEnumFunc == 0) return 0;
1179   hLog = GDI_HEAP_ALLOC( sizeof(ENUMLOGFONT16) );
1180   lpEnumLogFont = (LPENUMLOGFONT16) GDI_HEAP_LIN_ADDR(hLog);
1181   if (lpEnumLogFont == NULL) {
1182     fprintf(stderr,"EnumFontFamilies // can't alloc LOGFONT struct !\n");
1183     return 0;
1184   }
1185   hMet = GDI_HEAP_ALLOC( sizeof(TEXTMETRIC16) );
1186   lptm = (LPTEXTMETRIC16) GDI_HEAP_LIN_ADDR(hMet);
1187   if (lptm == NULL) {
1188     GDI_HEAP_FREE(hLog);
1189     fprintf(stderr,"EnumFontFamilies // can't alloc TEXTMETRIC struct !\n");
1190     return 0;
1191   }
1192   lpOldName = NULL;
1193   if (lpszFamily != NULL) {
1194     strcpy(FaceName, lpszFamily);
1195     AnsiUpper(FaceName);
1196   }
1197   if (lpLogFontList[0] == NULL) InitFontsList();
1198   for(i = 0; lpLogFontList[i] != NULL; i++) {
1199     if (lpszFamily == NULL) {
1200       if (lpOldName != NULL) {
1201         if (strcmp(lpOldName,lpLogFontList[i]->lfFaceName) == 0) continue;
1202       }
1203       lpOldName = lpLogFontList[i]->lfFaceName;
1204     } else {
1205       if (strcmp(FaceName, lpLogFontList[i]->lfFaceName) != 0) continue;
1206     }
1207     memcpy(lpEnumLogFont, lpLogFontList[i], sizeof(LOGFONT16));
1208     strcpy(lpEnumLogFont->elfFullName,"");
1209     strcpy(lpEnumLogFont->elfStyle,"");
1210     hFont = CreateFontIndirect16((LPLOGFONT16)lpEnumLogFont);
1211     hOldFont = SelectObject(hDC, hFont);
1212     GetTextMetrics16(hDC, lptm);
1213     SelectObject(hDC, hOldFont);
1214     DeleteObject(hFont);
1215     dprintf_font(stddeb, "EnumFontFamilies // i=%d lpLogFont=%p lptm=%p\n", i, lpEnumLogFont, lptm);
1216
1217     nRet = CallEnumFontFamProc( (FARPROC16)lpEnumFunc,
1218                                GDI_HEAP_SEG_ADDR(hLog),
1219                                GDI_HEAP_SEG_ADDR(hMet),
1220                                0, lpData );
1221     if (nRet == 0) {
1222       dprintf_font(stddeb,"EnumFontFamilies // EnumEnd requested by application !\n");
1223       break;
1224     }
1225   }
1226   GDI_HEAP_FREE(hMet);
1227   GDI_HEAP_FREE(hLog);
1228   return nRet;
1229 }
1230
1231 /*************************************************************************
1232  *                              GetRasterizerCaps       [GDI.313]
1233  */
1234
1235 BOOL GetRasterizerCaps(LPRASTERIZER_STATUS lprs, UINT cbNumBytes)
1236 {
1237   /* This is not much more than a dummy */
1238   RASTERIZER_STATUS rs;
1239
1240   rs.nSize = sizeof(rs);
1241   rs.wFlags = 0;
1242   rs.nLanguageID = 0;
1243   return True;
1244 }
1245
1246 /*************************************************************************
1247  *             GetKerningPairs      [GDI.332]
1248  */
1249 int GetKerningPairs(HDC hDC,int cPairs,LPKERNINGPAIR16 lpKerningPairs)
1250 {
1251     /* This has to be dealt with when proper font handling is in place
1252      *
1253      * At this time kerning is ignored (set to 0)
1254      */
1255
1256     int i;
1257     fprintf(stdnimp,"GetKerningPairs: almost empty stub!\n");
1258     for (i = 0; i < cPairs; i++) lpKerningPairs[i].iKernAmount = 0;
1259     return 0;
1260 }