/************************************************************************/
/*									*/
/*  List the fonts in a document.					*/
/*  Manage resources for layout.					*/
/*									*/
/************************************************************************/

#   include	"tedConfig.h"

#   include	<stddef.h>
#   include	<stdio.h>
#   include	<stdlib.h>
#   define	y0	math_y0
#   define	y1	math_y1
#   include	<math.h>
#   undef	y0
#   undef	y1

#   include	<utilMatchFont.h>

#   include	<appImage.h>
#   include	"docLayout.h"
#   include	"docFind.h"
#   include	<sioHex.h>
#   include	<sioMemory.h>
#   include	<appWinMeta.h>
#   include	<appMacPict.h>

#   include	<appDebugon.h>

int docPsClaimParticuleData(	const BufferItem *	bi,
				ParticuleData **	pParticuleData )
    {
    static ParticuleData *	PSPrintGeometry;
    static int			PSPrintGeometryCount;

    if  ( bi->biParaParticuleCount > PSPrintGeometryCount )
	{
	ParticuleData *	fresh;
	unsigned int	size;

	size= ( bi->biParaParticuleCount+ 1 )* sizeof( ParticuleData );

	fresh= (ParticuleData *)realloc( PSPrintGeometry,
			bi->biParaParticuleCount* sizeof( ParticuleData ) );
	if  ( ! fresh )
	    { LXDEB(bi->biParaParticuleCount,fresh); return -1;	}

	PSPrintGeometry= fresh;
	}

    *pParticuleData= PSPrintGeometry; return 0;
    }

/************************************************************************/
/*									*/
/*  Find the fonts of an image.						*/
/*									*/
/************************************************************************/

typedef int (*LIST_FONTS_PS)(	PostScriptTypeList *	pstl,
				SimpleInputStream *	sis,
				const PostScriptFontList * psfl,
				const char *		prefix,
				int			mapMode,
				int			xWinExt,
				int			yWinExt,
				int			twipsWide,
				int			twipsHigh );

int docPsListObjectFonts(	PostScriptTypeList *		pstl,
				const InsertedObject *		io,
				const PostScriptFontList *	psfl,
				const char *			prefix )
    {
    LIST_FONTS_PS		listFontsPs;

    SimpleInputStream *		sisMem;
    SimpleInputStream *		sisMeta;

    const MemoryBuffer *	mb;
    int				mapMode= 0;

    switch( io->ioKind )
	{
	case DOCokPICTWMETAFILE:
	    mb= &(io->ioObjectData);
	    mapMode= io->ioMapMode;
	    listFontsPs= appMetaListFontsPs;
	    break;

	case DOCokMACPICT:
	    mb= &(io->ioObjectData);
	    listFontsPs= appMacPictListFontsPs;
	    break;

	case DOCokPICTJPEGBLIP:
	case DOCokPICTPNGBLIP:
	    return 0;

	case DOCokOLEOBJECT:
	    if  ( io->ioResultKind == DOCokPICTWMETAFILE )
		{
		mb= &(io->ioResultData);
		mapMode= io->ioResultMapMode;
		listFontsPs= appMetaListFontsPs;
		break;
		}
	    else{ LDEB(io->ioResultKind); return 0;	}

	case DOCokINCLUDEPICTURE:
	    return 0;

	default:
	    LDEB(io->ioKind); return 0;
	}

    sisMem= sioInMemoryOpen( mb );
    if  ( ! sisMem )
	{ XDEB(sisMem); return -1;	}

    sisMeta= sioInHexOpen( sisMem );
    if  ( ! sisMeta )
	{ XDEB(sisMem); return -1;	}

    if  ( (*listFontsPs)( pstl, sisMeta, psfl, prefix, mapMode,
					io->io_xWinExt, io->io_yWinExt,
					io->ioTwipsWide, io->ioTwipsHigh ) )
	{ LDEB(1); return -1;	}

    sioInClose( sisMeta );
    sioInClose( sisMem );

    return 0;
    }


/************************************************************************/
/*									*/
/*  Recursively retrieve the list of PostScriptFonts that is used in	*/
/*  a document.								*/
/*									*/
/************************************************************************/

typedef struct GetDocumentFonts
    {
    const DocumentFontList *		gdfDocumentFontList;
    const PostScriptFontList *		gdfPostScriptFontList;
    PostScriptTypeList *		gdfPostScriptTypeList;
    } GetDocumentFonts;

/*  a  */
static int docPsPrintGetParaFonts(
				DocumentSelection *		ds,
				BufferItem *			bi,
				const BufferDocument *		bd,
				const DocumentPosition *	dpFrom,
				void *				through )
    {
    GetDocumentFonts *		gdf= (GetDocumentFonts *)through;
    const DocumentFontList *	dfl= gdf->gdfDocumentFontList;
    const PostScriptFontList *	psfl= gdf->gdfPostScriptFontList;
    PostScriptTypeList *	pstl= gdf->gdfPostScriptTypeList;

    int				attributeNumber= -1;

    AfmFontInfo *		afi;
    int				encoding;

    InsertedObject *		io;

    const TextParticule *	tp;
    int				part;

    tp= bi->biParaParticules; part= 0;

    while( part < bi->biParaParticuleCount )
	{
	const int	appearsInText= 1;

	switch( tp->tpKind )
	    {
	    case DOCkindTEXT:
	    case DOCkindTAB:
		if  ( tp->tpTextAttributeNumber >= 0			&&
		      tp->tpTextAttributeNumber != attributeNumber	)
		    {
		    TextAttribute	ta;

		    utilGetTextAttributeByNumber( &ta,
					    &(bd->bdTextAttributeList),
					    tp->tpTextAttributeNumber );

		    afi= utilPsGetAfi( &encoding, dfl, psfl, &ta );
		    if  ( ! afi )
			{ XDEB(afi); return -1;	}

		    if  ( utilRememberPostsciptFace( pstl,
				    encoding, afi, &ta, "f", appearsInText ) )
			{ LDEB(1); return -1;	}

		    attributeNumber= tp->tpTextAttributeNumber;
		    }

		while( part+ 1 < bi->biParaParticuleCount )
		    {
		    if  ( tp[1].tpKind != DOCkindTEXT	&&
			  tp[1].tpKind != DOCkindTAB	)
			{ break;	}
		    if  ( tp[1].tpTextAttributeNumber != attributeNumber )
			{ break;	}

		    part++; tp++;
		    }
		part++; tp++; break;

	    case DOCkindOBJECT:
		io= bi->biParaObjects+ tp->tpObjectNumber;

		if  ( docPsListObjectFonts( pstl, io, psfl, "f" ) )
		    { LDEB(tp->tpKind); return -1;	}

		part++; tp++; break;

	    case DOCkindNOTE:
	    case DOCkindFIELDSTART:
	    case DOCkindFIELDEND:
	    case DOCkindXE:
	    case DOCkindTC:
	    case DOCkindLINEBREAK:
	    case DOCkindPAGEBREAK:
	    case DOCkindCOLUMNBREAK:
	    case DOCkindCHFTNSEP:
	    case DOCkindCHFTNSEPC:
		part++; tp++; break;

	    default:
		LDEB(tp->tpKind); return -1;
	    }
	}

    return 1;
    }


int docPsPrintGetDocumentFonts(	BufferDocument *		bd,
				PostScriptTypeList *		pstl,
				const PostScriptFontList *	psfl )
    {
    const DocumentFontList *	dfl= &(bd->bdProperties.dpFontList);

    GetDocumentFonts		gdf;

    DocumentPosition		dpBeginFrom;
    DocumentSelection		dsIgnored;
    int				res;

    gdf.gdfDocumentFontList= dfl;
    gdf.gdfPostScriptFontList= psfl;
    gdf.gdfPostScriptTypeList= pstl;

    /*  a  */
    if  ( docFirstPosition( &dpBeginFrom, &(bd->bdItem) ) )
	{ LDEB(1); return -1;;	}
    res= docFindFindNextInDocument( &dsIgnored, &dpBeginFrom, bd,
				    docPsPrintGetParaFonts, (void *)&gdf );
    if  ( res != 1 )
	{ LDEB(res); return -1;	}

    return 0;
    }