Release 961215

[wine/multimedia.git] / objects / font.c

/*
 * GDI font objects
 *
 * Copyright 1993 Alexandre Julliard
 *
 * Enhacements by Juergen Marquardt 1996
 *
 * Implementation of a second font cache which 
 * will be updated dynamically
 */

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <X11/Xatom.h>
#include "font.h"
#include "metafile.h"
#include "options.h"
#include "string32.h"
#include "xmalloc.h"
#include "stddebug.h"
#include "debug.h"

#define FONTCACHE       32      /* dynamic font cache size */
#define MAX_FONTS       256
static LPLOGFONT16 lpLogFontList[MAX_FONTS+1];

static int ParseFontParms(LPSTR lpFont, WORD wParmsNo, LPSTR lpRetStr, WORD wMaxSiz);

#define CI_NONEXISTCHAR(cs) (((cs)->width == 0) && \
                             (((cs)->rbearing|(cs)->lbearing| \
                               (cs)->ascent|(cs)->descent) == 0))

/* 
 * CI_GET_CHAR_INFO - return the charinfo struct for the indicated 8bit
 * character.  If the character is in the column and exists, then return the
 * appropriate metrics (note that fonts with common per-character metrics will
 * return min_bounds).  If none of these hold true, try again with the default
 * char.
 */
#define CI_GET_CHAR_INFO(fs,col,def,cs) \
{ \
    cs = def; \
    if (col >= fs->min_char_or_byte2 && col <= fs->max_char_or_byte2) { \
        if (fs->per_char == NULL) { \
            cs = &fs->min_bounds; \
        } else { \
            cs = &fs->per_char[(col - fs->min_char_or_byte2)]; \
            if (CI_NONEXISTCHAR(cs)) cs = def; \
        } \
    } \
}

#define CI_GET_DEFAULT_INFO(fs,cs) \
  CI_GET_CHAR_INFO(fs, fs->default_char, NULL, cs)

struct FontStructure {
        char *window;
        char *x11;
} FontNames[32];
int FontSize;


/***********************************************************************
 *           FONT_Init
 */
BOOL32 FONT_Init( void )
{
  char  temp[1024];
  LPSTR ptr;
  int i;

  if (PROFILE_GetWineIniString( "fonts", NULL, "*", temp, sizeof(temp) ) > 2 )
  {
    for( ptr = temp, i = 1; strlen(ptr) != 0; ptr += strlen(ptr) + 1 )
      if( strcmp( ptr, "default" ) )
        FontNames[i++].window = xstrdup( ptr );
    FontSize = i;

    for( i = 1; i < FontSize; i++ )
    {
        PROFILE_GetWineIniString( "fonts", FontNames[i].window, "*",
                                  temp, sizeof(temp) );
        FontNames[i].x11 = xstrdup( temp );
    }
    PROFILE_GetWineIniString( "fonts", "default", "*", temp, sizeof(temp) );
    FontNames[0].x11 = xstrdup( temp );

  } else {
    FontNames[0].window = NULL; FontNames[0].x11 = "*-helvetica";
    FontNames[1].window = "ms sans serif"; FontNames[1].x11 = "*-helvetica";
    FontNames[2].window = "ms serif"; FontNames[2].x11 = "*-times";
    FontNames[3].window = "fixedsys"; FontNames[3].x11 = "*-fixed";
    FontNames[4].window = "arial"; FontNames[4].x11 = "*-helvetica";
    FontNames[5].window = "helv"; FontNames[5].x11 = "*-helvetica";
    FontNames[6].window = "roman"; FontNames[6].x11 = "*-times";
    FontNames[7].window = "system"; FontNames[7].x11 = "*-helvetica";
    FontSize = 8;
  }
  return TRUE;
}

/***********************************************************************
 *           FONT_ChkX11Family
 *
 * returns a valid X11 equivalent if a Windows face name 
 * is like a X11 family  - or NULL if translation is needed
 */
static char *FONT_ChkX11Family(char *winFaceName )
{
  static char x11fam[32+2];   /* will be returned */
  int i;

  for(i = 0; lpLogFontList[i] != NULL; i++)
    if( !lstrcmpi32A(winFaceName, lpLogFontList[i]->lfFaceName) )
    {
        strcpy(x11fam,"*-");
        return strcat(x11fam,winFaceName);
    }    
  return NULL;               /* a FONT_TranslateName() call is needed */
}



/***********************************************************************
 *           FONT_TranslateName
 *
 * Translate a Windows face name to its X11 equivalent.
 * This will probably have to be customizable.
 */
static const char *FONT_TranslateName( char *winFaceName )
{
  int i;

  for (i = 1; i < FontSize; i ++)
    if( !strcmp( winFaceName, FontNames[i].window ) ) {
      dprintf_font(stddeb, "---- Mapped %s to %s\n", winFaceName, FontNames[i].x11 );
      return FontNames[i].x11;
    }
  return FontNames[0].x11;
}


/***********************************************************************
 *           FONT_MatchFont
 *
 * Find a X font matching the logical font.
 */
static XFontStruct * FONT_MatchFont( LOGFONT16 * font, DC * dc )
{
    char pattern[100];
    const char *family, *weight, *charset;
    char **names;
    char slant, oldspacing, spacing;
    int width, height, oldheight, count;
    XFontStruct * fontStruct;
    
    dprintf_font(stddeb,
        "FONT_MatchFont(H,W = %d,%d; Weight = %d; Italic = %d; FaceName = '%s'\n",
        font->lfHeight, font->lfWidth, font->lfWeight, font->lfItalic, font->lfFaceName);
    weight = (font->lfWeight > 550) ? "bold" : "medium";
    slant = font->lfItalic ? 'i' : 'r';
    if (font->lfHeight == -1)
        height = 0;
    else
        height = font->lfHeight * dc->w.VportExtX / dc->w.WndExtX;
    if (height == 0) height = 120;  /* Default height = 12 */
    else if (height < 0)
    {
        /* If height is negative, it means the height of the characters */
        /* *without* the internal leading. So we adjust it a bit to     */
        /* compensate. 5/4 seems to give good results for small fonts.  */
        /* 
         * J.M.: This causes wrong font size for bigger fonts e.g. in Winword & Write 
        height = 10 * (-height * 9 / 8);
         * may be we have to use an non linear function
        */
        /* assume internal leading is 2 pixels. Else small fonts will become
         * very small. */
        height = (height-2) * -10; 
    }
    else height *= 10;
    width  = 10 * (font->lfWidth * dc->w.VportExtY / dc->w.WndExtY);
    if (width < 0) {
        dprintf_font( stddeb, "FONT_MatchFont: negative width %d(%d)\n",
                      width, font->lfWidth );
        width = -width;
    }

    spacing = (font->lfPitchAndFamily & FIXED_PITCH) ? 'm' :
              (font->lfPitchAndFamily & VARIABLE_PITCH) ? 'p' : '*';
    
  
    charset = (font->lfCharSet == ANSI_CHARSET) ? "iso8859-1" : "*-*";
    if (*font->lfFaceName) {
        family = FONT_ChkX11Family(font->lfFaceName);
        /*--do _not_ translate if lfFaceName is family from X11  A.K.*/
        if (!family) 
          family = FONT_TranslateName( font->lfFaceName );
        /* FIX ME: I don't if that's correct but it works J.M. */
        spacing = '*';
        }
    else switch(font->lfPitchAndFamily & 0xf0)
    {
    case FF_ROMAN:
      family = FONT_TranslateName( "roman" );
      break;
    case FF_SWISS:
      family = FONT_TranslateName( "swiss" );
      break;
    case FF_MODERN:
      family = FONT_TranslateName( "modern" );
      break;
    case FF_SCRIPT:
      family = FONT_TranslateName( "script" );
      break;
    case FF_DECORATIVE:
      family = FONT_TranslateName( "decorative" );
      break;
    default:
      family = "*-*";
      break;
    }
    sprintf( pattern, "-%s-%s-*-normal-*-*-*-*-*-*-*-%s",
            family, weight, charset);
    dprintf_font(stddeb, "FONT_MatchFont: '%s'\n", pattern );
    names = XListFonts( display, pattern, 1, &count );
    if (names) XFreeFontNames( names );
    else
    {
        if (strcmp(family, "*-*") == 0)
        {
            fprintf(stderr, "FONT_MatchFont(%s) : returning NULL\n", pattern);
            return NULL;
        }
        else family = "*-*";
    }
    oldheight = height;
    oldspacing = spacing;
    while (TRUE) {
            /* Width==0 seems not to be a valid wildcard on SGI's, using * instead */
            if ( width == 0 )
              sprintf( pattern, "-%s-%s-%c-normal-*-*-%d-*-*-%c-*-%s",
                      family, weight, slant, height, spacing, charset);
            else
              sprintf( pattern, "-%s-%s-%c-normal-*-*-%d-*-*-%c-%d-%s",
                      family, weight, slant, height, spacing, width, charset);
            dprintf_font(stddeb, "FONT_MatchFont: '%s'\n", pattern );
            names = XListFonts( display, pattern, 1, &count );
            if (count > 0) break;
            if (spacing == 'm') /* try 'c' if no 'm' found */ {

                spacing = 'c';
                continue;
            } else if (spacing == 'p') /* try '*' if no 'p' found */ {
                spacing = '*';
                continue;
            }
            spacing = oldspacing;
            height -= 10;               
            if (height < 10) {
                if (slant == 'i') {
                    /* try oblique if no italic font */
                    slant = 'o';
                    height = oldheight;
                    continue;
                }
                if (spacing == 'm' && strcmp(family, "*-*") != 0) {
                    /* If a fixed spacing font could not be found, ignore
                     * the family */
                    family = "*-*";
                    height = oldheight;
                    continue;
                }
                fprintf(stderr, "FONT_MatchFont(%s) : returning NULL\n", pattern);
                return NULL;
            }
    }
    dprintf_font(stddeb,"        Found '%s'\n", *names );
    if (!*font->lfFaceName)
      ParseFontParms(*names, 2, font->lfFaceName , LF_FACESIZE-1);
      /* we need a font name for function GetTextFace() even if there isn't one ;-) */  
    AnsiUpper(font->lfFaceName);

    fontStruct = XLoadQueryFont( display, *names );
    XFreeFontNames( names );
    return fontStruct;
}


/***********************************************************************
 *           FONT_GetMetrics
 */
void FONT_GetMetrics( LOGFONT16 * logfont, XFontStruct * xfont,
                      TEXTMETRIC16 * metrics )
{    
    int average, i, count;
    unsigned long prop;
        
    metrics->tmAscent  = xfont->ascent;
    metrics->tmDescent = xfont->descent;
    metrics->tmHeight  = xfont->ascent + xfont->descent;

    metrics->tmInternalLeading  = 0;
    if (XGetFontProperty( xfont, XA_CAP_HEIGHT, &prop ))
        metrics->tmInternalLeading = xfont->ascent+xfont->descent-(INT16)prop;

    metrics->tmExternalLeading  = 0;
    metrics->tmMaxCharWidth     = xfont->max_bounds.width;
    metrics->tmWeight           = logfont->lfWeight;
    metrics->tmItalic           = logfont->lfItalic;
    metrics->tmUnderlined       = logfont->lfUnderline;
    metrics->tmStruckOut        = logfont->lfStrikeOut;
    metrics->tmFirstChar        = xfont->min_char_or_byte2;
    metrics->tmLastChar         = xfont->max_char_or_byte2;
    metrics->tmDefaultChar      = xfont->default_char;
    metrics->tmBreakChar        = ' ';
    metrics->tmCharSet          = logfont->lfCharSet;
    metrics->tmOverhang         = 0;
    metrics->tmDigitizedAspectX = 1;
    metrics->tmDigitizedAspectY = 1;
    metrics->tmPitchAndFamily   = (logfont->lfPitchAndFamily&0xf0)|TMPF_DEVICE;

    /* TMPF_FIXED_PITCH bit means variable pitch...Don't you love Microsoft? */
    if (xfont->min_bounds.width != xfont->max_bounds.width)
        metrics->tmPitchAndFamily |= TMPF_FIXED_PITCH;

    if (!xfont->per_char) average = metrics->tmMaxCharWidth;
    else
    {
        XCharStruct * charPtr = xfont->per_char;
        average = count = 0;
        for (i = metrics->tmFirstChar; i <= metrics->tmLastChar; i++)
        {
            if (!CI_NONEXISTCHAR( charPtr ))
            {
                average += charPtr->width;
                count++;
            }
            charPtr++;
        }
        if (count) average = (average + count/2) / count;
    }
    metrics->tmAveCharWidth = average;
}

/***********************************************************************
 *           GetGlyphOutLine    (GDI.309)
 */
DWORD GetGlyphOutLine( HDC16 hdc, UINT uChar, UINT fuFormat,
                       LPGLYPHMETRICS lpgm, DWORD cbBuffer, LPSTR lpBuffer,
                       LPMAT2 lpmat2) 
{
    fprintf( stdnimp,"GetGlyphOutLine(%04x, '%c', %04x, %p, %ld, %p, %p) // - empty stub!\n",
             hdc, uChar, fuFormat, lpgm, cbBuffer, lpBuffer, lpmat2 );
    return (DWORD)-1; /* failure */
}

void
FONT_LOGFONT32AToLOGFONT16(const LOGFONT32A *font,LPLOGFONT16 font16) {
    font16->lfHeight         = (INT16)font->lfHeight;
    font16->lfWidth          = (INT16)font->lfWidth;
    font16->lfEscapement     = (INT16)font->lfEscapement;
    font16->lfOrientation    = (INT16)font->lfOrientation;
    font16->lfWeight         = (INT16)font->lfWeight;
    font16->lfItalic         = font->lfItalic;
    font16->lfUnderline      = font->lfUnderline;
    font16->lfStrikeOut      = font->lfStrikeOut;
    font16->lfCharSet        = font->lfCharSet;
    font16->lfOutPrecision   = font->lfOutPrecision;
    font16->lfClipPrecision  = font->lfClipPrecision;
    font16->lfQuality        = font->lfQuality;
    font16->lfPitchAndFamily = font->lfPitchAndFamily;
    lstrcpyn32A( font16->lfFaceName, font->lfFaceName, LF_FACESIZE );
}

void
FONT_LOGFONT32WToLOGFONT16(const LOGFONT32W *font,LPLOGFONT16 font16) {
    font16->lfHeight         = (INT16)font->lfHeight;
    font16->lfWidth          = (INT16)font->lfWidth;
    font16->lfEscapement     = (INT16)font->lfEscapement;
    font16->lfOrientation    = (INT16)font->lfOrientation;
    font16->lfWeight         = (INT16)font->lfWeight;
    font16->lfItalic         = font->lfItalic;
    font16->lfUnderline      = font->lfUnderline;
    font16->lfStrikeOut      = font->lfStrikeOut;
    font16->lfCharSet        = font->lfCharSet;
    font16->lfOutPrecision   = font->lfOutPrecision;
    font16->lfClipPrecision  = font->lfClipPrecision;
    font16->lfQuality        = font->lfQuality;
    font16->lfPitchAndFamily = font->lfPitchAndFamily;
    lstrcpynWtoA( font16->lfFaceName, font->lfFaceName, LF_FACESIZE );
}

void
FONT_LOGFONT16ToLOGFONT32A(LPLOGFONT16 font,LPLOGFONT32A font32A) {
    font32A->lfHeight         = (INT32)font->lfHeight;
    font32A->lfWidth          = (INT32)font->lfWidth;
    font32A->lfEscapement     = (INT32)font->lfEscapement;
    font32A->lfOrientation    = (INT32)font->lfOrientation;
    font32A->lfWeight         = (INT32)font->lfWeight;
    font32A->lfItalic         = font->lfItalic;
    font32A->lfUnderline      = font->lfUnderline;
    font32A->lfStrikeOut      = font->lfStrikeOut;
    font32A->lfCharSet        = font->lfCharSet;
    font32A->lfOutPrecision   = font->lfOutPrecision;
    font32A->lfClipPrecision  = font->lfClipPrecision;
    font32A->lfQuality        = font->lfQuality;
    font32A->lfPitchAndFamily = font->lfPitchAndFamily;
    lstrcpyn32A( font32A->lfFaceName, font->lfFaceName, LF_FACESIZE );
}

void
FONT_LOGFONT16ToLOGFONT32W(LPLOGFONT16 font,LPLOGFONT32W font32W) {
    font32W->lfHeight         = (INT32)font->lfHeight;
    font32W->lfWidth          = (INT32)font->lfWidth;
    font32W->lfEscapement     = (INT32)font->lfEscapement;
    font32W->lfOrientation    = (INT32)font->lfOrientation;
    font32W->lfWeight         = (INT32)font->lfWeight;
    font32W->lfItalic         = font->lfItalic;
    font32W->lfUnderline      = font->lfUnderline;
    font32W->lfStrikeOut      = font->lfStrikeOut;
    font32W->lfCharSet        = font->lfCharSet;
    font32W->lfOutPrecision   = font->lfOutPrecision;
    font32W->lfClipPrecision  = font->lfClipPrecision;
    font32W->lfQuality        = font->lfQuality;
    font32W->lfPitchAndFamily = font->lfPitchAndFamily;
    lstrcpynAtoW( font32W->lfFaceName, font->lfFaceName, LF_FACESIZE );
}


/***********************************************************************
 *           CreateScalableFontResource    (GDI.310)
 */
BOOL CreateScalableFontResource( UINT fHidden,LPSTR lpszResourceFile,
                                 LPSTR lpszFontFile, LPSTR lpszCurrentPath )
{
    /* fHidden=1 - only visible for the calling app, read-only, not
     * enumbered with EnumFonts/EnumFontFamilies
     * lpszCurrentPath can be NULL
     */
    fprintf(stdnimp,"CreateScalableFontResource(%d,%s,%s,%s) // empty stub!\n",
            fHidden, lpszResourceFile, lpszFontFile, lpszCurrentPath );
    return FALSE; /* create failed */
}


/***********************************************************************
 *           CreateFontIndirect16   (GDI.57)
 */
HFONT16 CreateFontIndirect16( const LOGFONT16 *font )
{
    FONTOBJ * fontPtr;
    HFONT16 hfont;

    if (!font)
    {
        fprintf(stderr,"CreateFontIndirect: font is NULL : returning NULL\n");
        return 0;
    }
    hfont = GDI_AllocObject( sizeof(FONTOBJ), FONT_MAGIC );
    if (!hfont) return 0;
    fontPtr = (FONTOBJ *) GDI_HEAP_LIN_ADDR( hfont );
    memcpy( &fontPtr->logfont, font, sizeof(LOGFONT16) );
    AnsiLower( fontPtr->logfont.lfFaceName );
    dprintf_font(stddeb,"CreateFontIndirect(%p (%d,%d)); return %04x\n",
        font, font->lfHeight, font->lfWidth, hfont);
    return hfont;
}


/***********************************************************************
 *           CreateFontIndirect32A   (GDI32.44)
 */
HFONT32 CreateFontIndirect32A( const LOGFONT32A *font )
{
    LOGFONT16 font16;

    FONT_LOGFONT32AToLOGFONT16(font,&font16);

    return CreateFontIndirect16( &font16 );
}


/***********************************************************************
 *           CreateFontIndirect32W   (GDI32.45)
 */
HFONT32 CreateFontIndirect32W( const LOGFONT32W *font )
{
    LOGFONT16 font16;

    FONT_LOGFONT32WToLOGFONT16(font,&font16);
    return CreateFontIndirect16( &font16 );
}


/***********************************************************************
 *           CreateFont16    (GDI.56)
 */
HFONT16 CreateFont16( INT16 height, INT16 width, INT16 esc, INT16 orient,
                      INT16 weight, BYTE italic, BYTE underline,
                      BYTE strikeout, BYTE charset, BYTE outpres,
                      BYTE clippres, BYTE quality, BYTE pitch, LPCSTR name )
{
    LOGFONT16 logfont = {height, width, esc, orient, weight, italic, underline,
                      strikeout, charset, outpres, clippres, quality, pitch, };
    dprintf_font(stddeb,"CreateFont16(%d,%d)\n", height, width);
    if (name) lstrcpyn32A(logfont.lfFaceName,name,sizeof(logfont.lfFaceName));
    else logfont.lfFaceName[0] = '\0';
    return CreateFontIndirect16( &logfont );
}



/*************************************************************************
 *           CreateFont32A    (GDI32.43)
 */
HFONT32 CreateFont32A( INT32 height, INT32 width, INT32 esc, INT32 orient,
                       INT32 weight, DWORD italic, DWORD underline,
                       DWORD strikeout, DWORD charset, DWORD outpres,
                       DWORD clippres, DWORD quality, DWORD pitch, LPCSTR name)
{
    return (HFONT32)CreateFont16( height, width, esc, orient, weight, italic,
                                  underline, strikeout, charset, outpres,
                                  clippres, quality, pitch, name );
}


/*************************************************************************
 *           CreateFont32W    (GDI32.46)
 */
HFONT32 CreateFont32W( INT32 height, INT32 width, INT32 esc, INT32 orient,
                       INT32 weight, DWORD italic, DWORD underline,
                       DWORD strikeout, DWORD charset, DWORD outpres,
                       DWORD clippres, DWORD quality, DWORD pitch,
                       LPCWSTR name )
{
    LPSTR namea = name ? STRING32_DupUniToAnsi(name) : NULL;
    HFONT32 ret = (HFONT32)CreateFont16( height, width, esc, orient, weight,
                                         italic, underline, strikeout, charset,
                                         outpres, clippres, quality, pitch,
                                         namea );
    free(namea);
    return ret;
}


/***********************************************************************
 *           FONT_GetObject16
 */
INT16 FONT_GetObject16( FONTOBJ * font, INT16 count, LPSTR buffer )
{
    if (count > sizeof(LOGFONT16)) count = sizeof(LOGFONT16);
    memcpy( buffer, &font->logfont, count );
    return count;
}


/***********************************************************************
 *           FONT_GetObject32A
 */
INT32 FONT_GetObject32A( FONTOBJ *font, INT32 count, LPSTR buffer )
{
    LOGFONT32A fnt32;

    memset(&fnt32, 0, sizeof(fnt32));
    fnt32.lfHeight         = font->logfont.lfHeight;
    fnt32.lfWidth          = font->logfont.lfWidth;
    fnt32.lfEscapement     = font->logfont.lfEscapement;
    fnt32.lfOrientation    = font->logfont.lfOrientation;
    fnt32.lfWeight         = font->logfont.lfWeight;
    fnt32.lfItalic         = font->logfont.lfItalic;
    fnt32.lfUnderline      = font->logfont.lfUnderline;
    fnt32.lfStrikeOut      = font->logfont.lfStrikeOut;
    fnt32.lfCharSet        = font->logfont.lfCharSet;
    fnt32.lfOutPrecision   = font->logfont.lfOutPrecision;
    fnt32.lfClipPrecision  = font->logfont.lfClipPrecision;
    fnt32.lfQuality        = font->logfont.lfQuality;
    fnt32.lfPitchAndFamily = font->logfont.lfPitchAndFamily;
    strncpy( fnt32.lfFaceName, font->logfont.lfFaceName,
             sizeof(fnt32.lfFaceName) );

    if (count > sizeof(fnt32)) count = sizeof(fnt32);
    memcpy( buffer, &fnt32, count );
    return count;
}


/***********************************************************************
 *           FONT_SelectObject
 */
HFONT16 FONT_SelectObject( DC * dc, HFONT16 hfont, FONTOBJ * font )
{
    static X_PHYSFONT stockFonts[LAST_STOCK_FONT-FIRST_STOCK_FONT+1];

    static struct {
                HFONT16         id;
                LOGFONT16       logfont;
                int             access;
                int             used;
                X_PHYSFONT      cacheFont; } cacheFonts[FONTCACHE], *cacheFontsMin;
    int         i;

    X_PHYSFONT * stockPtr;
    HFONT16 prevHandle = dc->w.hFont;
    XFontStruct * fontStruct;
    dprintf_font(stddeb,"FONT_SelectObject(%p, %04x, %p)\n", dc, hfont, font);

#if 0 /* From the code in SelectObject, this can not happen */
      /* Load font if necessary */
    if (!font)
    {
        HFONT16 hnewfont;

        hnewfont = CreateFont16(10, 7, 0, 0, FW_DONTCARE,
                              FALSE, FALSE, FALSE, DEFAULT_CHARSET, 0, 0,
                              DEFAULT_QUALITY, FF_DONTCARE, "*" );
        font = (FONTOBJ *) GDI_HEAP_LIN_ADDR( hnewfont );
    }
#endif

    if (dc->header.wMagic == METAFILE_DC_MAGIC)
      if (MF_CreateFontIndirect(dc, hfont, &(font->logfont)))
        return prevHandle;
      else
        return 0;

    if ((hfont >= FIRST_STOCK_FONT) && (hfont <= LAST_STOCK_FONT))
        stockPtr = &stockFonts[hfont - FIRST_STOCK_FONT];
    else {
        stockPtr = NULL;
        /*
         * Ok, It's not a stock font but 
         * may be it's cached in dynamic cache
         */
        for(i=0; i<FONTCACHE; i++) /* search for same handle */
             if (cacheFonts[i].id==hfont) { /* Got the handle */
                /*
                 * Check if Handle matches the font 
                 */
                if(memcmp(&cacheFonts[i].logfont,&(font->logfont), sizeof(LOGFONT16))) {
                        /* No: remove handle id from dynamic font cache */
                        cacheFonts[i].access=0;
                        cacheFonts[i].used=0;
                        cacheFonts[i].id=0;
                        /* may be there is an unused handle which contains the font */
                        for(i=0; i<FONTCACHE; i++) {
                                if((cacheFonts[i].used == 0) &&
                                  (memcmp(&cacheFonts[i].logfont,&(font->logfont), sizeof(LOGFONT16)))== 0) {
                                        /* got it load from cache and set new handle id */
                                        stockPtr = &cacheFonts[i].cacheFont;
                                        cacheFonts[i].access=1;
                                        cacheFonts[i].used=1;
                                        cacheFonts[i].id=hfont;
                                        dprintf_font(stddeb,"FONT_SelectObject: got font from unused handle\n");
                                        break;
                                        }
                                }
        
                        }
                else {
                        /* Yes: load from dynamic font cache */
                        stockPtr = &cacheFonts[i].cacheFont;
                        cacheFonts[i].access++;
                        cacheFonts[i].used++;
                        }
                break;
                }
        }
    if (!stockPtr || !stockPtr->fstruct)
    {
        if (!(fontStruct = FONT_MatchFont( &font->logfont, dc )))
        {
              /* If it is not a stock font, we can simply return 0 */
            if (!stockPtr) return 0;
              /* Otherwise we must try to find a substitute */
            dprintf_font(stddeb,"Loading font 'fixed' for %04x\n", hfont );
            font->logfont.lfPitchAndFamily &= ~VARIABLE_PITCH;
            font->logfont.lfPitchAndFamily |= FIXED_PITCH;
            fontStruct = XLoadQueryFont( display, "fixed" );
            if (!fontStruct)
            {
                fprintf( stderr, "No system font could be found. Please check your font path.\n" );
                exit( 1 );
            }
        }
    }
    else
    {
        fontStruct = stockPtr->fstruct;
        dprintf_font(stddeb,
                     "FONT_SelectObject: Loaded font from cache %04x %p\n",
                     hfont, fontStruct );
    }   

      /* Unuse previous font */
        for (i=0; i < FONTCACHE; i++) {
                if (cacheFonts[i].id == prevHandle) {
                        if(cacheFonts[i].used == 0)
                                fprintf(stderr, "Trying to decrement a use count of 0.\n");
                        else 
                                cacheFonts[i].used--;
                }
        }

      /* Store font */
    dc->w.hFont = hfont;
    if (stockPtr)
    {
        if (!stockPtr->fstruct)
        {
            stockPtr->fstruct = fontStruct;
            FONT_GetMetrics( &font->logfont, fontStruct, &stockPtr->metrics );
        }
        memcpy( &dc->u.x.font, stockPtr, sizeof(*stockPtr) );
    }
    else
    {
        /* 
         * Check in cacheFont
         */
        cacheFontsMin=NULL;
        for (i=0; i < FONTCACHE; i++) {
                if (cacheFonts[i].used==0) 
                        if ((!cacheFontsMin) || ((cacheFontsMin) && (cacheFontsMin->access > cacheFonts[i].access)))
                                cacheFontsMin=&cacheFonts[i];
                }
        if (!cacheFontsMin) {
                fprintf(stderr,"No unused font cache entry !!!!\n" );
                return prevHandle;
        }
        if (cacheFontsMin->id!=0) {
                dprintf_font(stddeb,
                        "FONT_SelectObject: Freeing %04x \n",cacheFontsMin->id );
                XFreeFont( display, cacheFontsMin->cacheFont.fstruct );
                }
        cacheFontsMin->cacheFont.fstruct = fontStruct;
        FONT_GetMetrics( &font->logfont, fontStruct, &cacheFontsMin->cacheFont.metrics );
        cacheFontsMin->access=1;
        cacheFontsMin->used=1;
        cacheFontsMin->id=hfont;
        memcpy( &dc->u.x.font, &(cacheFontsMin->cacheFont), sizeof(cacheFontsMin->cacheFont) );
        memcpy(&cacheFontsMin->logfont,&(font->logfont), sizeof(LOGFONT16));

    }
    return prevHandle;
}


/***********************************************************************
 *           GetTextCharacterExtra    (GDI.89)
 */
short GetTextCharacterExtra( HDC16 hdc )
{
    DC * dc = (DC *) GDI_GetObjPtr( hdc, DC_MAGIC );
    if (!dc) return 0;
    return abs( (dc->w.charExtra * dc->w.WndExtX + dc->w.VportExtX / 2)
                 / dc->w.VportExtX );
}


/***********************************************************************
 *           SetTextCharacterExtra    (GDI.8)
 */
short SetTextCharacterExtra( HDC16 hdc, short extra )
{
    short prev;
    DC * dc = (DC *) GDI_GetObjPtr( hdc, DC_MAGIC );
    if (!dc) return 0;
    extra = (extra * dc->w.VportExtX + dc->w.WndExtX / 2) / dc->w.WndExtX;    
    prev = dc->w.charExtra;
    dc->w.charExtra = abs(extra);
    return (prev * dc->w.WndExtX + dc->w.VportExtX / 2) / dc->w.VportExtX;
}


/***********************************************************************
 *           SetTextJustification    (GDI.10)
 */
short SetTextJustification( HDC16 hdc, short extra, short breaks )
{
    DC * dc = (DC *) GDI_GetObjPtr( hdc, DC_MAGIC );
    if (!dc) return 0;

    extra = abs((extra * dc->w.VportExtX + dc->w.WndExtX / 2) / dc->w.WndExtX);
    if (!extra) breaks = 0;
    dc->w.breakTotalExtra = extra;
    dc->w.breakCount = breaks;
    if (breaks)
    {   
        dc->w.breakExtra = extra / breaks;
        dc->w.breakRem   = extra - (dc->w.breakCount * dc->w.breakExtra);
    }
    else
    {
        dc->w.breakExtra = 0;
        dc->w.breakRem   = 0;
    }
    return 1;
}

/***********************************************************************
 *           GetTextFace16    (GDI.92)
 */
INT16 GetTextFace16( HDC16 hdc, INT16 count, LPSTR name )
{
        return GetTextFace32A(hdc,count,name);
}

/***********************************************************************
 *           GetTextFace32A    (GDI32.234)
 */
INT32 GetTextFace32A( HDC32 hdc, INT32 count, LPSTR name )
{
    FONTOBJ *font;

    DC * dc = (DC *) GDI_GetObjPtr( hdc, DC_MAGIC );
    if (!dc) return 0;
    if (!(font = (FONTOBJ *) GDI_GetObjPtr( dc->w.hFont, FONT_MAGIC )))
        return 0;
    lstrcpyn32A( name, font->logfont.lfFaceName, count );
    return strlen(name);
}

/***********************************************************************
 *           GetTextFace32W    (GDI32.235)
 */
INT32 GetTextFace32W( HDC32 hdc, INT32 count, LPWSTR name )
{
    LPSTR nameA = (LPSTR)xmalloc(count);
    INT32 res = GetTextFace32A(hdc,count,nameA);

    lstrcpynAtoW(name,nameA,count);
    free(nameA);
    return res;
}


/***********************************************************************
 *           GetTextExtent    (GDI.91)
 */
DWORD GetTextExtent( HDC16 hdc, LPCSTR str, short count )
{
    SIZE16 size;
    if (!GetTextExtentPoint16( hdc, str, count, &size )) return 0;
    return MAKELONG( size.cx, size.cy );
}


/***********************************************************************
 *           GetTextExtentPoint16    (GDI.471)
 *
 * FIXME: Should this have a bug for compatibility?
 * Original Windows versions of GetTextExtentPoint{A,W} have documented
 * bugs.
 */
BOOL16 GetTextExtentPoint16( HDC16 hdc, LPCSTR str, INT16 count, LPSIZE16 size)
{
    SIZE32 size32;
    BOOL32 ret = GetTextExtentPoint32A( hdc, str, count, &size32 );
    CONV_SIZE32TO16( &size32, size );
    return (BOOL16)ret;
}


/***********************************************************************
 *           GetTextExtentPoint32A    (GDI32.230)
 */
BOOL32 GetTextExtentPoint32A( HDC32 hdc, LPCSTR str, INT32 count,
                              LPSIZE32 size )
{
    DC * dc = (DC *) GDI_GetObjPtr( hdc, DC_MAGIC );
    if (!dc)
    {
        if (!(dc = (DC *)GDI_GetObjPtr( hdc, METAFILE_DC_MAGIC )))
            return FALSE;
    }

    if (!dc->funcs->pGetTextExtentPoint ||
        !dc->funcs->pGetTextExtentPoint( dc, str, count, size ))
        return FALSE;

    dprintf_font(stddeb,"GetTextExtentPoint(%08x '%.*s' %d %p): returning %d,%d\n",
                 hdc, count, str, count, size, size->cx, size->cy );
    return TRUE;
}


/***********************************************************************
 *           GetTextExtentPoint32W    (GDI32.231)
 */
BOOL32 GetTextExtentPoint32W( HDC32 hdc, LPCWSTR str, INT32 count,
                              LPSIZE32 size )
{
    char *p = STRING32_DupUniToAnsi( str );
    BOOL32 ret = GetTextExtentPoint32A( hdc, p, count, size );
    free( p );
    return ret;
}

/***********************************************************************
 *           GetTextExtentPoint32ABuggy    (GDI32.232)
 */
BOOL32 GetTextExtentPoint32ABuggy( HDC32 hdc, LPCSTR str, INT32 count,
                                   LPSIZE32 size )
{
    dprintf_font( stddeb, "GetTextExtentPoint32ABuggy: not bug compatible.\n");
    return GetTextExtentPoint32A( hdc, str, count, size );
}

/***********************************************************************
 *           GetTextExtentPoint32WBuggy    (GDI32.233)
 */
BOOL32 GetTextExtentPoint32WBuggy( HDC32 hdc, LPCWSTR str, INT32 count,
                                   LPSIZE32 size )
{
    dprintf_font( stddeb, "GetTextExtentPoint32WBuggy: not bug compatible.\n");
    return GetTextExtentPoint32W( hdc, str, count, size );
}


/***********************************************************************
 *           GetTextExtentExPoint32A    (GDI32.228)
 */
BOOL32 GetTextExtentExPoint32A( HDC32 hdc, LPCSTR str, INT32 count,
                                INT32 maxExt,LPINT32 lpnFit, LPINT32 alpDx,
                                LPSIZE32 size )
{
  int index;
  SIZE32 tSize;
  int nFit=0;
  int extent=0;
  DC * dc = (DC *) GDI_GetObjPtr( hdc, DC_MAGIC );
  if (!dc)
    {
      if (!(dc = (DC *)GDI_GetObjPtr( hdc, METAFILE_DC_MAGIC )))
        return FALSE;
    }
  if (!dc->funcs->pGetTextExtentPoint) return FALSE;

  size->cx=0; size->cy=0;
  for(index=0;index<count;index++)
    {
      if(!dc->funcs->pGetTextExtentPoint( dc, str, 1, &tSize )) return FALSE;
      if(extent+tSize.cx<maxExt)
        {
          extent+=tSize.cx;
          nFit++;
          str++;
          if(alpDx) alpDx[index]=extent;
          if(tSize.cy > size->cy) size->cy=tSize.cy;
        }
      else break;
    }
  size->cx=extent;
  *lpnFit=nFit;
  dprintf_font(stddeb,"GetTextExtentExPoint32A(%08x '%.*s' %d) returning %d %d %d\n",
               hdc,count,str,maxExt,nFit, size->cx,size->cy);
  return TRUE;
}

/***********************************************************************
 *           GetTextExtentExPoint32W    (GDI32.229)
 */

BOOL32 GetTextExtentExPoint32W( HDC32 hdc, LPCWSTR str, INT32 count,
                                INT32 maxExt, LPINT32 lpnFit, LPINT32 alpDx,
                                LPSIZE32 size )
{
    char *p = STRING32_DupUniToAnsi( str );
    BOOL32 ret = GetTextExtentExPoint32A( hdc, p, count, maxExt,
                                        lpnFit, alpDx, size);
    free( p );
    return ret;
}

/***********************************************************************
 *           GetTextMetrics16    (GDI.93)
 */
BOOL16 GetTextMetrics16( HDC16 hdc, TEXTMETRIC16 *metrics )
{
    DC * dc = (DC *) GDI_GetObjPtr( hdc, DC_MAGIC );
    if (!dc) return FALSE;
    memcpy( metrics, &dc->u.x.font.metrics, sizeof(*metrics) );

    metrics->tmAscent  = abs( metrics->tmAscent
                              * dc->w.WndExtY / dc->w.VportExtY );
    metrics->tmDescent = abs( metrics->tmDescent
                              * dc->w.WndExtY / dc->w.VportExtY );
    metrics->tmHeight  = metrics->tmAscent + metrics->tmDescent;
    metrics->tmInternalLeading = abs( metrics->tmInternalLeading
                                      * dc->w.WndExtY / dc->w.VportExtY );
    metrics->tmExternalLeading = abs( metrics->tmExternalLeading
                                      * dc->w.WndExtY / dc->w.VportExtY );
    metrics->tmMaxCharWidth    = abs( metrics->tmMaxCharWidth 
                                      * dc->w.WndExtX / dc->w.VportExtX );
    metrics->tmAveCharWidth    = abs( metrics->tmAveCharWidth
                                      * dc->w.WndExtX / dc->w.VportExtX );

    dprintf_font(stdnimp,"text metrics:\n
        InternalLeading = %i
        ExternalLeading = %i
        MaxCharWidth = %i
        Weight = %i
        Italic = %i
        Underlined = %i
        StruckOut = %i
        FirstChar = %i
        LastChar = %i
        DefaultChar = %i
        BreakChar = %i
        CharSet = %i
        Overhang = %i
        DigitizedAspectX = %i
        DigitizedAspectY = %i
        AveCharWidth = %i
        MaxCharWidth = %i
        Ascent = %i
        Descent = %i
        Height = %i\n",
    metrics->tmInternalLeading,
    metrics->tmExternalLeading,
    metrics->tmMaxCharWidth,
    metrics->tmWeight,
    metrics->tmItalic,
    metrics->tmUnderlined,
    metrics->tmStruckOut,
    metrics->tmFirstChar,
    metrics->tmLastChar,
    metrics->tmDefaultChar,
    metrics->tmBreakChar,
    metrics->tmCharSet,
    metrics->tmOverhang,
    metrics->tmDigitizedAspectX,
    metrics->tmDigitizedAspectY,
    metrics->tmAveCharWidth,
    metrics->tmMaxCharWidth,
    metrics->tmAscent,
    metrics->tmDescent,
    metrics->tmHeight);

    return TRUE;
}


/***********************************************************************
 *           GetTextMetrics32A    (GDI32.236)
 */
BOOL32 GetTextMetrics32A( HDC32 hdc, TEXTMETRIC32A *metrics )
{
    TEXTMETRIC16 tm;
    if (!GetTextMetrics16( (HDC16)hdc, &tm )) return FALSE;
    metrics->tmHeight           = tm.tmHeight;
    metrics->tmAscent           = tm.tmAscent;
    metrics->tmDescent          = tm.tmDescent;
    metrics->tmInternalLeading  = tm.tmInternalLeading;
    metrics->tmExternalLeading  = tm.tmExternalLeading;
    metrics->tmAveCharWidth     = tm.tmAveCharWidth;
    metrics->tmMaxCharWidth     = tm.tmMaxCharWidth;
    metrics->tmWeight           = tm.tmWeight;
    metrics->tmOverhang         = tm.tmOverhang;
    metrics->tmDigitizedAspectX = tm.tmDigitizedAspectX;
    metrics->tmDigitizedAspectY = tm.tmDigitizedAspectY;
    metrics->tmFirstChar        = tm.tmFirstChar;
    metrics->tmLastChar         = tm.tmLastChar;
    metrics->tmDefaultChar      = tm.tmDefaultChar;
    metrics->tmBreakChar        = tm.tmBreakChar;
    metrics->tmItalic           = tm.tmItalic;
    metrics->tmUnderlined       = tm.tmUnderlined;
    metrics->tmStruckOut        = tm.tmStruckOut;
    metrics->tmPitchAndFamily   = tm.tmPitchAndFamily;
    metrics->tmCharSet          = tm.tmCharSet;
    return TRUE;
}


/***********************************************************************
 *           GetTextMetrics32W    (GDI32.237)
 */
BOOL32 GetTextMetrics32W( HDC32 hdc, TEXTMETRIC32W *metrics )
{
    TEXTMETRIC16 tm;
    if (!GetTextMetrics16( (HDC16)hdc, &tm )) return FALSE;
    metrics->tmHeight           = tm.tmHeight;
    metrics->tmAscent           = tm.tmAscent;
    metrics->tmDescent          = tm.tmDescent;
    metrics->tmInternalLeading  = tm.tmInternalLeading;
    metrics->tmExternalLeading  = tm.tmExternalLeading;
    metrics->tmAveCharWidth     = tm.tmAveCharWidth;
    metrics->tmMaxCharWidth     = tm.tmMaxCharWidth;
    metrics->tmWeight           = tm.tmWeight;
    metrics->tmOverhang         = tm.tmOverhang;
    metrics->tmDigitizedAspectX = tm.tmDigitizedAspectX;
    metrics->tmDigitizedAspectY = tm.tmDigitizedAspectY;
    metrics->tmFirstChar        = tm.tmFirstChar;
    metrics->tmLastChar         = tm.tmLastChar;
    metrics->tmDefaultChar      = tm.tmDefaultChar;
    metrics->tmBreakChar        = tm.tmBreakChar;
    metrics->tmItalic           = tm.tmItalic;
    metrics->tmUnderlined       = tm.tmUnderlined;
    metrics->tmStruckOut        = tm.tmStruckOut;
    metrics->tmPitchAndFamily   = tm.tmPitchAndFamily;
    metrics->tmCharSet          = tm.tmCharSet;
    return TRUE;
}


/***********************************************************************
 *           SetMapperFlags    (GDI.349)
 */
DWORD SetMapperFlags(HDC16 hDC, DWORD dwFlag)
{
    dprintf_font(stdnimp,"SetmapperFlags(%04x, %08lX) // Empty Stub !\n", 
                 hDC, dwFlag); 
    return 0L;
}

 
/***********************************************************************
 *           GetCharABCWidths   (GDI.307)
 */
BOOL GetCharABCWidths(HDC16 hdc, UINT wFirstChar, UINT wLastChar, LPABC16 lpABC)
{

    /* No TrueType fonts in Wine so far */

    fprintf(stdnimp,"STUB: GetCharABCWidths(%04x,%04x,%04x,%08x)\n",
                           hdc,wFirstChar,wLastChar,(unsigned)lpABC);
  
    return FALSE;
}


/***********************************************************************
 *           GetCharWidth    (GDI.350)
 */
BOOL GetCharWidth(HDC16 hdc, WORD wFirstChar, WORD wLastChar, LPINT16 lpBuffer)
{
    int i, j;
    XFontStruct *xfont;
    XCharStruct *cs, *def;

    DC *dc = (DC *)GDI_GetObjPtr(hdc, DC_MAGIC);
    if (!dc) return FALSE;
    xfont = dc->u.x.font.fstruct;
    
    /* fixed font? */
    if (xfont->per_char == NULL)
    {
        for (i = wFirstChar, j = 0; i <= wLastChar; i++, j++)
            *(lpBuffer + j) = xfont->max_bounds.width;
        return TRUE;
    }

    CI_GET_DEFAULT_INFO(xfont, def);
        
    for (i = wFirstChar, j = 0; i <= wLastChar; i++, j++)
    {
        CI_GET_CHAR_INFO(xfont, i, def, cs);
        *(lpBuffer + j) = cs ? cs->width : xfont->max_bounds.width;
        if (*(lpBuffer + j) < 0)
            *(lpBuffer + j) = 0;
    }
    return TRUE;
}


/***********************************************************************
 *           AddFontResource    (GDI.119)
 */
INT AddFontResource( LPCSTR str )
{
    fprintf( stdnimp, "STUB: AddFontResource('%s')\n", str );
    return 1;
}


/***********************************************************************
 *           RemoveFontResource    (GDI.136)
 */
BOOL RemoveFontResource( LPSTR str )
{
    fprintf( stdnimp, "STUB: RemoveFontResource('%s')\n", str );
    return TRUE;
}


/*************************************************************************
 *                              ParseFontParms          [internal]
 */
int ParseFontParms(LPSTR lpFont, WORD wParmsNo, LPSTR lpRetStr, WORD wMaxSiz)
{
        int     i;
        if (lpFont == NULL) return 0;
        if (lpRetStr == NULL) return 0;
        for (i = 0; (*lpFont != '\0' && i != wParmsNo); ) {
                if (*lpFont == '-') i++;
                lpFont++;
                }
        if (i == wParmsNo) {
                if (*lpFont == '-') lpFont++;
                wMaxSiz--;
                for (i = 0; (*lpFont != '\0' && *lpFont != '-' && i < wMaxSiz); i++)
                        *(lpRetStr + i) = *lpFont++;
                *(lpRetStr + i) = '\0';
                return i;
                }
        else
                lpRetStr[0] = '\0';
        return 0;
}


/*************************************************************************
 *                              InitFontsList           [internal]
 */

static int logfcmp(const void *a,const void *b) 
{
  return strcmp( (*(LPLOGFONT16 *)a)->lfFaceName,
                 (*(LPLOGFONT16 *)b)->lfFaceName );
}

void InitFontsList(void)
{
  char  str[32];
  char  pattern[100];
  char  *family, *weight, *charset;
  char  **names;
  char  slant, spacing;
  int   i, count;
  LPLOGFONT16 lpNewFont;

  dprintf_font(stddeb,"InitFontsList !\n");

  weight = "medium";
  slant = 'r';
  spacing = '*';
  charset = "*";
  family = "*-*";

  sprintf( pattern, "-%s-%s-%c-normal-*-*-*-*-*-%c-*-%s",
          family, weight, slant, spacing, charset);
  names = XListFonts( display, pattern, MAX_FONTS, &count );
  dprintf_font(stddeb,"InitFontsList // count=%d \n", count);

  lpNewFont = malloc((sizeof(LOGFONT16)+LF_FACESIZE)*count);
  if (lpNewFont == NULL) {
      dprintf_font(stddeb,
                   "InitFontsList // Error alloc new font structure !\n");
      XFreeFontNames(names);
      return;
  }

  for (i = 0; i < count; i++) {
    dprintf_font(stddeb,"InitFontsList // names[%d]='%s' \n", i, names[i]);

    ParseFontParms(names[i], 2, str, sizeof(str));
#if 0
    /* not necessary because new function FONT_ChkX11Family() */
    if (strcmp(str, "fixed") == 0) strcat(str, "sys");
#endif    
    AnsiUpper(str);
    strcpy(lpNewFont->lfFaceName, str);
    ParseFontParms(names[i], 8, str, sizeof(str));
    lpNewFont->lfHeight = atoi(str) / 10;
    ParseFontParms(names[i], 12, str, sizeof(str));
    lpNewFont->lfWidth = atoi(str) / 10;
    lpNewFont->lfEscapement = 0;
    lpNewFont->lfOrientation = 0;
    lpNewFont->lfWeight = FW_REGULAR;
    lpNewFont->lfItalic = 0;
    lpNewFont->lfUnderline = 0;
    lpNewFont->lfStrikeOut = 0;
    ParseFontParms(names[i], 13, str, sizeof(str));
    if (strcmp(str, "iso8859") == 0)  {
      lpNewFont->lfCharSet = ANSI_CHARSET;
    } else  {
      lpNewFont->lfCharSet = OEM_CHARSET;
    }
    lpNewFont->lfOutPrecision = OUT_DEFAULT_PRECIS;
    lpNewFont->lfClipPrecision = CLIP_DEFAULT_PRECIS;
    lpNewFont->lfQuality = DEFAULT_QUALITY;
    ParseFontParms(names[i], 11, str, sizeof(str));
    switch(str[0]) {
     case 'p':
      lpNewFont->lfPitchAndFamily = VARIABLE_PITCH | FF_SWISS;
      break;
     case 'm':
     case 'c':
      lpNewFont->lfPitchAndFamily = FIXED_PITCH | FF_MODERN;
      break;
     default:
      lpNewFont->lfPitchAndFamily = DEFAULT_PITCH | FF_DONTCARE;
      break;
    }
    dprintf_font( stddeb,
                  "InitFontsList // lpNewFont->lfHeight=%d\n",
                  lpNewFont->lfHeight );
    dprintf_font( stddeb,
                  "InitFontsList // lpNewFont->lfWidth=%d\n",
                  lpNewFont->lfWidth );
    dprintf_font( stddeb,
                  "InitFontsList // lfFaceName='%s'\n",
                  lpNewFont->lfFaceName );
    lpLogFontList[i] = lpNewFont;
    lpNewFont = (LPLOGFONT16)
      ((char *)lpNewFont + sizeof(LOGFONT16)+LF_FACESIZE);
  }
  lpLogFontList[i] = NULL;

  qsort(lpLogFontList,count,sizeof(*lpLogFontList),logfcmp);
  XFreeFontNames(names);
}

/*************************************************************************
 *                              EnumFonts                       [GDI.70]
 * We reuse EnumFontFamilies* for the callback function get the same
 * structs (+ extra stuff at the end which will be ignored by the enum funcs)
 */
INT16 EnumFonts16(HDC16 hDC, LPCSTR lpFaceName, FONTENUMPROC16 lpEnumFunc, LPARAM lpData)
{
  return EnumFontFamilies16(hDC,lpFaceName,lpEnumFunc,lpData);
}

/*************************************************************************
 *                              EnumFontsA                      [GDI32.84]
 */
INT32 EnumFonts32A(HDC32 hDC, LPCSTR lpFaceName, FONTENUMPROC32A lpEnumFunc, LPARAM lpData)
{
  return EnumFontFamilies32A(hDC,lpFaceName,lpEnumFunc,lpData);
}

/*************************************************************************
 *                              EnumFontsA                      [GDI32.84]
 */
INT32 EnumFonts32W(HDC32 hDC, LPCWSTR lpFaceName, FONTENUMPROC32W lpEnumFunc, LPARAM lpData)
{
  return EnumFontFamilies32W(hDC,lpFaceName,lpEnumFunc,lpData);
}

/*************************************************************************
 *                              EnumFontFamilies        [GDI.330]
 */
INT16 EnumFontFamilies16(HDC16 hDC, LPCSTR lpszFamily, FONTENUMPROC16 lpEnumFunc, LPARAM lpData)
{
  LOGFONT16     LF;

  if (lpszFamily)
     strcpy(LF.lfFaceName,lpszFamily);
  else
     LF.lfFaceName[0]='\0';
  LF.lfCharSet = DEFAULT_CHARSET;

  return EnumFontFamiliesEx16(hDC,&LF,(FONTENUMPROCEX16)lpEnumFunc,lpData,0);
}

/*************************************************************************
 *                              EnumFontFamiliesA       [GDI32.80]
 */
INT32 EnumFontFamilies32A(HDC32 hDC, LPCSTR lpszFamily, FONTENUMPROC32A lpEnumFunc, LPARAM lpData)
{
  LOGFONT32A    LF;

  if (lpszFamily)
     strcpy(LF.lfFaceName,lpszFamily);
  else
     LF.lfFaceName[0]='\0';
  LF.lfCharSet = DEFAULT_CHARSET;

  return EnumFontFamiliesEx32A(hDC,&LF,(FONTENUMPROCEX32A)lpEnumFunc,lpData,0);
}

/*************************************************************************
 *                              EnumFontFamiliesW       [GDI32.83]
 */
INT32 EnumFontFamilies32W(HDC32 hDC, LPCWSTR lpszFamilyW, FONTENUMPROC32W lpEnumFunc, LPARAM lpData)
{
  LOGFONT32W    LF;

  if (lpszFamilyW)
        lstrcpy32W(LF.lfFaceName,lpszFamilyW);
  else
        LF.lfFaceName[0]=0;
  LF.lfCharSet = DEFAULT_CHARSET;
  return EnumFontFamiliesEx32W(hDC,&LF,(FONTENUMPROCEX32W)lpEnumFunc,lpData,0);
}

/*************************************************************************
 *                              EnumFontFamiliesEx      [GDI.618]
 * FIXME: fill the rest of the NEWTEXTMETRICEX and ENUMLOGFONTEX structures.
 *        (applies to all EnumFontFamiliesEx*)
 *        winelib/16 support.
 */
INT16 EnumFontFamiliesEx16(HDC16 hDC, LPLOGFONT16 lpLF, FONTENUMPROCEX16 lpEnumFunc, LPARAM lpData,DWORD reserved)
{
  HLOCAL16      hLog;
  HLOCAL16      hMet;
  HFONT16 hFont;
  HFONT16 hOldFont;
  LPENUMLOGFONTEX16 lpEnumLogFont;
  LPNEWTEXTMETRICEX16 lptm;
  LPSTR         lpOldName;
  char          FaceName[LF_FACESIZE];
  int           nRet = 0;
  int           i;
  
  dprintf_font(stddeb,"EnumFontFamiliesEx(%04x, '%s', %08lx, %08lx, %08lx)\n",
               hDC, lpLF->lfFaceName, (DWORD)lpEnumFunc, lpData, reserved);
  if (lpEnumFunc == 0) return 0;
  hLog = GDI_HEAP_ALLOC( sizeof(ENUMLOGFONTEX16) );
  lpEnumLogFont = (LPENUMLOGFONTEX16) GDI_HEAP_LIN_ADDR(hLog);
  if (lpEnumLogFont == NULL) {
    fprintf(stderr,"EnumFontFamiliesEx // can't alloc LOGFONT struct !\n");
    return 0;
  }
  hMet = GDI_HEAP_ALLOC( sizeof(NEWTEXTMETRICEX16) );
  lptm = (LPNEWTEXTMETRICEX16) GDI_HEAP_LIN_ADDR(hMet);
  if (lptm == NULL) {
    GDI_HEAP_FREE(hLog);
    fprintf(stderr,"EnumFontFamiliesEx // can't alloc TEXTMETRIC struct !\n");
    return 0;
  }
  lpOldName = NULL;
  strcpy(FaceName,lpLF->lfFaceName);
  AnsiUpper(lpLF->lfFaceName);

  if (lpLogFontList[0] == NULL) InitFontsList();
  for(i = 0; lpLogFontList[i] != NULL; i++) {
    /* lfCharSet */
    if (lpLF->lfCharSet!=DEFAULT_CHARSET)
        if (lpLogFontList[i]->lfCharSet != lpLF->lfCharSet)
           continue;

    /* lfPitchAndFamily only of importance in Hebrew and Arabic versions. */
    /* lfFaceName */
    if (FaceName[0]) {
        if (strcmp(FaceName,lpLogFontList[i]->lfFaceName))
           continue;
    } else {
        if ((lpOldName!=NULL)&&!strcmp(lpOldName,lpLogFontList[i]->lfFaceName))
           continue;
        lpOldName=lpLogFontList[i]->lfFaceName;
    }

    memcpy(lpEnumLogFont, lpLogFontList[i], sizeof(LOGFONT16));
    strcpy(lpEnumLogFont->elfFullName,"");
    strcpy(lpEnumLogFont->elfStyle,"");
    hFont = CreateFontIndirect16((LPLOGFONT16)lpEnumLogFont);
    hOldFont = SelectObject32(hDC, hFont);
    GetTextMetrics16(hDC, (LPTEXTMETRIC16)lptm);
    SelectObject32(hDC, hOldFont);
    DeleteObject32(hFont);
    dprintf_font(stddeb, "EnumFontFamiliesEx // i=%d lpLogFont=%p lptm=%p\n", i, lpEnumLogFont, lptm);
    
    nRet = lpEnumFunc( GDI_HEAP_SEG_ADDR(hLog), GDI_HEAP_SEG_ADDR(hMet),
                       0, lpData );
    if (nRet == 0) {
      dprintf_font(stddeb,"EnumFontFamilies // EnumEnd requested by application !\n");
      break;
    }
  }
  GDI_HEAP_FREE(hMet);
  GDI_HEAP_FREE(hLog);
  return nRet;
}

/*************************************************************************
 *                              EnumFontFamiliesExA     [GDI32.81]
 * FIXME: Don't use 16 bit GDI heap functions (applies to EnumFontFamiliesEx32*)
 */
INT32 EnumFontFamiliesEx32A(HDC32 hDC, LPLOGFONT32A lpLF,FONTENUMPROCEX32A lpEnumFunc, LPARAM lpData,DWORD reserved)
{
  HLOCAL16      hLog;
  HLOCAL16      hMet;
  HFONT32       hFont;
  HFONT32       hOldFont;
  LPENUMLOGFONTEX32A    lpEnumLogFont;
  LPNEWTEXTMETRICEX32A  lptm;
  LPSTR         lpOldName;
  char          FaceName[LF_FACESIZE];
  int           nRet = 0;
  int           i;
  
  dprintf_font(stddeb,"EnumFontFamilies32A(%04x, %p, %08lx, %08lx, %08lx)\n",
               hDC, lpLF->lfFaceName, (DWORD)lpEnumFunc, lpData,reserved);
  if (lpEnumFunc == 0) return 0;
  hLog = GDI_HEAP_ALLOC( sizeof(ENUMLOGFONTEX32A) );
  lpEnumLogFont = (LPENUMLOGFONTEX32A) GDI_HEAP_LIN_ADDR(hLog);
  if (lpEnumLogFont == NULL) {
    fprintf(stderr,"EnumFontFamilies // can't alloc LOGFONT struct !\n");
    return 0;
  }
  hMet = GDI_HEAP_ALLOC( sizeof(NEWTEXTMETRICEX32A) );
  lptm = (LPNEWTEXTMETRICEX32A) GDI_HEAP_LIN_ADDR(hMet);
  if (lptm == NULL) {
    GDI_HEAP_FREE(hLog);
    fprintf(stderr,"EnumFontFamilies32A // can't alloc TEXTMETRIC struct !\n");
    return 0;
  }
  lpOldName = NULL;
  strcpy(FaceName,lpLF->lfFaceName);
  AnsiUpper(lpLF->lfFaceName);

  if (lpLogFontList[0] == NULL) InitFontsList();
  for(i = 0; lpLogFontList[i] != NULL; i++) {
    /* lfCharSet */
    if (lpLF->lfCharSet!=DEFAULT_CHARSET)
        if (lpLogFontList[i]->lfCharSet != lpLF->lfCharSet)
           continue;

    /* lfPitchAndFamily only of importance in Hebrew and Arabic versions. */
    /* lfFaceName */
    if (FaceName[0]) {
        if (strcmp(FaceName,lpLogFontList[i]->lfFaceName))
           continue;
    } else {
        if ((lpOldName!=NULL)&&!strcmp(lpOldName,lpLogFontList[i]->lfFaceName))
           continue;
        lpOldName=lpLogFontList[i]->lfFaceName;
    }

    FONT_LOGFONT16ToLOGFONT32A(lpLogFontList[i],&(lpEnumLogFont->elfLogFont));
    strcpy(lpEnumLogFont->elfFullName,"");
    strcpy(lpEnumLogFont->elfStyle,"");
    strcpy(lpEnumLogFont->elfScript,"");
    hFont = CreateFontIndirect32A((LPLOGFONT32A)lpEnumLogFont);
    hOldFont = SelectObject32(hDC, hFont);
    GetTextMetrics32A(hDC, (LPTEXTMETRIC32A)lptm);
    SelectObject32(hDC, hOldFont);
    DeleteObject32(hFont);
    dprintf_font(stddeb, "EnumFontFamiliesEx32A // i=%d lpLogFont=%p lptm=%p\n", i, lpEnumLogFont, lptm);
    
    nRet = lpEnumFunc(lpEnumLogFont,lptm,0,lpData);
    if (nRet == 0) {
      dprintf_font(stddeb,"EnumFontFamiliesEx32A // EnumEnd requested by application !\n");
      break;
    }
  }
  GDI_HEAP_FREE(hMet);
  GDI_HEAP_FREE(hLog);
  return nRet;
}


/*************************************************************************
 *                              EnumFontFamiliesW       [GDI32.82]
 */
INT32 EnumFontFamiliesEx32W(HDC32 hDC, LPLOGFONT32W lpLF, FONTENUMPROCEX32W lpEnumFunc, LPARAM lpData, DWORD reserved)
{
  HLOCAL16      hLog;
  HLOCAL16      hMet;
  HFONT32       hFont;
  HFONT32       hOldFont;
  LPENUMLOGFONTEX32W    lpEnumLogFont;
  LPNEWTEXTMETRICEX32W  lptm;
  LPSTR         lpOldName;
  int           nRet = 0;
  int           i;
  LPSTR lpszFamily=STRING32_DupUniToAnsi(lpLF->lfFaceName);
  
  dprintf_font(stddeb,"EnumFontFamiliesEx32W(%04x, %p, %08lx, %08lx, %08lx)\n",
               hDC, lpLF, (DWORD)lpEnumFunc, lpData,reserved);
  if (lpEnumFunc == 0) {
    free(lpszFamily);
    return 0;
  }
  hLog = GDI_HEAP_ALLOC( sizeof(ENUMLOGFONTEX32W) );
  lpEnumLogFont = (LPENUMLOGFONTEX32W) GDI_HEAP_LIN_ADDR(hLog);
  if (lpEnumLogFont == NULL) {
    fprintf(stderr,"EnumFontFamilies32W // can't alloc LOGFONT struct !\n");
    free(lpszFamily);
    return 0;
  }
  hMet = GDI_HEAP_ALLOC( sizeof(NEWTEXTMETRICEX32W) );
  lptm = (LPNEWTEXTMETRICEX32W) GDI_HEAP_LIN_ADDR(hMet);
  if (lptm == NULL) {
    GDI_HEAP_FREE(hLog);
    fprintf(stderr,"EnumFontFamilies32W // can't alloc TEXTMETRIC struct !\n");
    free(lpszFamily);
    return 0;
  }
  lpOldName = NULL;
  AnsiUpper(lpszFamily);
  if (lpLogFontList[0] == NULL) InitFontsList();
  for(i = 0; lpLogFontList[i] != NULL; i++) {
    /* lfCharSet */
    if (lpLF->lfCharSet!=DEFAULT_CHARSET)
        if (lpLogFontList[i]->lfCharSet != lpLF->lfCharSet)
           continue;

    /* lfPitchAndFamily only of importance in Hebrew and Arabic versions. */
    /* lfFaceName */
    if (lpszFamily[0]) {
        if (strcmp(lpszFamily,lpLogFontList[i]->lfFaceName))
           continue;
    } else {
        if ((lpOldName!=NULL)&&!strcmp(lpOldName,lpLogFontList[i]->lfFaceName))
           continue;
        lpOldName=lpLogFontList[i]->lfFaceName;
    }

    FONT_LOGFONT16ToLOGFONT32W(lpLogFontList[i],&(lpEnumLogFont->elfLogFont));
    lstrcpynAtoW(lpEnumLogFont->elfFullName,"",1);
    lstrcpynAtoW(lpEnumLogFont->elfStyle,"",1);
    lstrcpynAtoW(lpEnumLogFont->elfScript,"",1);
    hFont = CreateFontIndirect32W((LPLOGFONT32W)lpEnumLogFont);
    hOldFont = SelectObject32(hDC, hFont);
    GetTextMetrics32W(hDC, (LPTEXTMETRIC32W)lptm);
    SelectObject32(hDC, hOldFont);
    DeleteObject32(hFont);
    dprintf_font(stddeb, "EnumFontFamilies32W // i=%d lpLogFont=%p lptm=%p\n", i, lpEnumLogFont, lptm);
    
    nRet = lpEnumFunc(lpEnumLogFont,lptm,0,lpData);
    if (nRet == 0) {
      dprintf_font(stddeb,"EnumFontFamilies32W // EnumEnd requested by application !\n");
      break;
    }
  }
  GDI_HEAP_FREE(hMet);
  GDI_HEAP_FREE(hLog);
  free(lpszFamily);
  return nRet;
}


/*************************************************************************
 *                              GetRasterizerCaps       [GDI.313]
 */

BOOL GetRasterizerCaps(LPRASTERIZER_STATUS lprs, UINT cbNumBytes)
{
  /* This is not much more than a dummy */
  RASTERIZER_STATUS rs;
  
  rs.nSize = sizeof(rs);
  rs.wFlags = 0;
  rs.nLanguageID = 0;
  return True;
}

/*************************************************************************
 *             GetKerningPairs      [GDI.332]
 */
int GetKerningPairs(HDC16 hDC,int cPairs,LPKERNINGPAIR16 lpKerningPairs)
{
    /* This has to be dealt with when proper font handling is in place 
     *
     * At this time kerning is ignored (set to 0)
     */

    int i;
    fprintf(stdnimp,"GetKerningPairs: almost empty stub!\n");
    for (i = 0; i < cPairs; i++) lpKerningPairs[i].iKernAmount = 0;
    return 0;
}