/*
 * 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 "heap.h"
#include "metafile.h"
#include "options.h"
#include "xmalloc.h"
#include "stddebug.h"
#include "debug.h"

LPLOGFONT16 lpLogFontList[MAX_FONTS+1];


#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)


/***********************************************************************
 *           FONT_LOGFONT32AToLOGFONT16
 */
static 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 );
}


/***********************************************************************
 *           FONT_LOGFONT32WToLOGFONT16
 */
static 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 );
}


/***********************************************************************
 *           FONT_LOGFONT16ToLOGFONT32A
 */
static 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 );
}


/***********************************************************************
 *           FONT_LOGFONT16ToLOGFONT32W
 */
static 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 );
}


/***********************************************************************
 *           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 */
}


/***********************************************************************
 *           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) );
    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 = HEAP_strdupWtoA( GetProcessHeap(), 0, name );
    HFONT32 ret = (HFONT32)CreateFont16( height, width, esc, orient, weight,
                                         italic, underline, strikeout, charset,
                                         outpres, clippres, quality, pitch,
                                         namea );
    HeapFree( GetProcessHeap(), 0, 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;
}


/***********************************************************************
 *           GetTextCharacterExtra16    (GDI.89)
 */
INT16 GetTextCharacterExtra16( HDC16 hdc )
{
    DC * dc = (DC *) GDI_GetObjPtr( hdc, DC_MAGIC );
    if (!dc) return 0;
    return abs( (dc->w.charExtra * dc->wndExtX + dc->vportExtX / 2)
	         / dc->vportExtX );
}


/***********************************************************************
 *           GetTextCharacterExtra32    (GDI32.225)
 */
INT32 GetTextCharacterExtra32( HDC32 hdc )
{
    DC * dc = (DC *) GDI_GetObjPtr( hdc, DC_MAGIC );
    if (!dc) return 0;
    return abs( (dc->w.charExtra * dc->wndExtX + dc->vportExtX / 2)
	         / dc->vportExtX );
}


/***********************************************************************
 *           SetTextCharacterExtra16    (GDI.8)
 */
INT16 SetTextCharacterExtra16( HDC16 hdc, INT16 extra )
{
    return (INT16)SetTextCharacterExtra32( hdc, extra );
}


/***********************************************************************
 *           SetTextCharacterExtra32    (GDI32.337)
 */
INT32 SetTextCharacterExtra32( HDC32 hdc, INT32 extra )
{
    INT32 prev;
    DC * dc = (DC *) GDI_GetObjPtr( hdc, DC_MAGIC );
    if (!dc) return 0;
    extra = (extra * dc->vportExtX + dc->wndExtX / 2) / dc->wndExtX;    
    prev = dc->w.charExtra;
    dc->w.charExtra = abs(extra);
    return (prev * dc->wndExtX + dc->vportExtX / 2) / dc->vportExtX;
}


/***********************************************************************
 *           SetTextJustification16    (GDI.10)
 */
INT16 SetTextJustification16( HDC16 hdc, INT16 extra, INT16 breaks )
{
    return SetTextJustification32( hdc, extra, breaks );
}


/***********************************************************************
 *           SetTextJustification32    (GDI32.339)
 */
BOOL32 SetTextJustification32( HDC32 hdc, INT32 extra, INT32 breaks )
{
    DC * dc = (DC *) GDI_GetObjPtr( hdc, DC_MAGIC );
    if (!dc) return 0;

    extra = abs((extra * dc->vportExtX + dc->wndExtX / 2) / dc->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 = HeapAlloc( GetProcessHeap(), 0, count );
    INT32 res = GetTextFace32A(hdc,count,nameA);
    lstrcpyAtoW( name, nameA );
    HeapFree( GetProcessHeap(), 0, nameA );
    return res;
}


/***********************************************************************
 *           GetTextExtent    (GDI.91)
 */
DWORD GetTextExtent( HDC16 hdc, LPCSTR str, INT16 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 )
{
    LPSTR p = HEAP_strdupWtoA( GetProcessHeap(), 0, str );
    BOOL32 ret = GetTextExtentPoint32A( hdc, p, count, size );
    HeapFree( GetProcessHeap(), 0, 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 )
{
    LPSTR p = HEAP_strdupWtoA( GetProcessHeap(), 0, str );
    BOOL32 ret = GetTextExtentExPoint32A( hdc, p, count, maxExt,
					lpnFit, alpDx, size);
    HeapFree( GetProcessHeap(), 0, p );
    return ret;
}

/***********************************************************************
 *           GetTextMetrics16    (GDI.93)
 */
BOOL16 GetTextMetrics16( HDC16 hdc, TEXTMETRIC16 *metrics )
{
    TEXTMETRIC32A tm;
    
    if (!GetTextMetrics32A( (HDC32)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;
}


/***********************************************************************
 *           GetTextMetrics32A    (GDI32.236)
 */
BOOL32 GetTextMetrics32A( HDC32 hdc, TEXTMETRIC32A *metrics )
{
DC * dc = (DC *) GDI_GetObjPtr( hdc, DC_MAGIC );
    if (!dc)
    {
	if (!(dc = (DC *)GDI_GetObjPtr( hdc, METAFILE_DC_MAGIC )))
            return FALSE;
    }

    if (!dc->funcs->pGetTextMetrics ||
        !dc->funcs->pGetTextMetrics( dc,metrics ))
        return FALSE;
    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;
}


/***********************************************************************
 *           GetTextMetrics32W    (GDI32.237)
 */
BOOL32 GetTextMetrics32W( HDC32 hdc, TEXTMETRIC32W *metrics )
{
    TEXTMETRIC32A tm;
    if (!GetTextMetrics32A( (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;
}

 
/***********************************************************************
 *           GetCharABCWidths16   (GDI.307)
 */
BOOL16 GetCharABCWidths16( HDC16 hdc, UINT16 firstChar, UINT16 lastChar,
                           LPABC16 abc )
{
    ABC32 abc32;
    if (!GetCharABCWidths32A( hdc, firstChar, lastChar, &abc32 )) return FALSE;
    abc->abcA = abc32.abcA;
    abc->abcB = abc32.abcB;
    abc->abcC = abc32.abcC;
    return TRUE;
}


/***********************************************************************
 *           GetCharABCWidths32A   (GDI32.149)
 */
BOOL32 GetCharABCWidths32A( HDC32 hdc, UINT32 firstChar, UINT32 lastChar,
                            LPABC32 abc )
{
    /* No TrueType fonts in Wine so far */
    fprintf( stdnimp, "STUB: GetCharABCWidths(%04x,%04x,%04x,%p)\n",
             hdc, firstChar, lastChar, abc );
    return FALSE;
}


/***********************************************************************
 *           GetCharABCWidths32W   (GDI32.152)
 */
BOOL32 GetCharABCWidths32W( HDC32 hdc, UINT32 firstChar, UINT32 lastChar,
                            LPABC32 abc )
{
    return GetCharABCWidths32A( hdc, firstChar, lastChar, abc );
}


/***********************************************************************
 *           GetCharWidth16    (GDI.350)
 */
BOOL16 GetCharWidth16( HDC16 hdc, UINT16 firstChar, UINT16 lastChar,
                       LPINT16 buffer )
{
    int i, width;
    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 = firstChar; i <= lastChar; i++)
	    *buffer++ = xfont->max_bounds.width;
	return TRUE;
    }

    CI_GET_DEFAULT_INFO(xfont, def);
	
    for (i = firstChar; i <= lastChar; i++)
    {
	CI_GET_CHAR_INFO( xfont, i, def, cs );
        width = cs ? cs->width : xfont->max_bounds.width;
        *buffer++ = MAX( width, 0 );
    }
    return TRUE;
}


/***********************************************************************
 *           GetCharWidth32A    (GDI32.155)
 */
BOOL32 GetCharWidth32A( HDC32 hdc, UINT32 firstChar, UINT32 lastChar,
                        LPINT32 buffer )
{
    int i, width;
    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 = firstChar; i <= lastChar; i++)
	    *buffer++ = xfont->max_bounds.width;
	return TRUE;
    }

    CI_GET_DEFAULT_INFO(xfont, def);
	
    for (i = firstChar; i <= lastChar; i++)
    {
	CI_GET_CHAR_INFO( xfont, i, def, cs );
        width = cs ? cs->width : xfont->max_bounds.width;
        *buffer++ = MAX( width, 0 );
    }
    return TRUE;
}


/***********************************************************************
 *           GetCharWidth32W    (GDI32.158)
 */
BOOL32 GetCharWidth32W( HDC32 hdc, UINT32 firstChar, UINT32 lastChar,
                        LPINT32 buffer )
{
    return GetCharWidth32A( hdc, firstChar, lastChar, buffer );
}


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


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

/*************************************************************************
 *				FONT_ParseFontParms		[internal]
 */
int FONT_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 lstrcmpi32A( (*(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]);

    FONT_ParseFontParms(names[i], 2, str, sizeof(str));
    strcpy(lpNewFont->lfFaceName, str);
    FONT_ParseFontParms(names[i], 8, str, sizeof(str));
    lpNewFont->lfHeight = atoi(str) / 10;
    FONT_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;
    FONT_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;
    FONT_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);

  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 (lstrcmpi32A(FaceName,lpLogFontList[i]->lfFaceName))
	   continue;
    }
    else
    {
    	if ((lpOldName!=NULL) &&
            !lstrcmpi32A(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);

  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 (lstrcmpi32A(FaceName,lpLogFontList[i]->lfFaceName))
	   continue;
    } else {
    	if ((lpOldName!=NULL) &&
            !lstrcmpi32A(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;
  
  dprintf_font(stddeb,"EnumFontFamiliesEx32W(%04x, %p, %08lx, %08lx, %08lx)\n",
	       hDC, lpLF, (DWORD)lpEnumFunc, lpData,reserved);
  if (lpEnumFunc == 0) 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");
    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");
    return 0;
  }
  lpOldName = NULL;
  lpszFamily = HEAP_strdupWtoA( GetProcessHeap(), 0, 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 (lpszFamily[0]) {
    	if (lstrcmpi32A(lpszFamily,lpLogFontList[i]->lfFaceName))
	   continue;
    } else {
    	if ((lpOldName!=NULL) &&
            !lstrcmpi32A(lpOldName,lpLogFontList[i]->lfFaceName))
	   continue;
	lpOldName=lpLogFontList[i]->lfFaceName;
    }

    FONT_LOGFONT16ToLOGFONT32W(lpLogFontList[i],&(lpEnumLogFont->elfLogFont));
    lpEnumLogFont->elfFullName[0] = 0;
    lpEnumLogFont->elfStyle[0] = 0;
    lpEnumLogFont->elfScript[0] = 0;
    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);
  HeapFree( GetProcessHeap(), 0, 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;
}