/*  ScianFontSystem.c
    Routines for font system and string utilities

    Jim Lyons
    7/26/91

    9/24/91  added support for raster fonts
    1/5/92   EMP added font counting for both types of fonts
    1/28/92  modified StrWidth and DrawString to handle tabs
    4/6/92   added PostScript drawing mode 
    9/14/92  changed DrawString to take alignment parameter
	     and changed name to DrawAString
    9/10/93  added SetUIFont
    11/19/93 implemented caching in SetupFont etc.
*/

#include "Scian.h"
#include "ScianStyle.h"
#include "ScianTypes.h"
#include "ScianFontSystem.h"
#include "ScianWindows.h"
#include "ScianDraw.h"
#include "ScianTextBoxes.h"

#ifdef GRAPHICS
#include "ScianPalatino18.h"
#include "ScianTitleFont.h"

#define NRASTERFONTS	4	/* NOT including system font or icon fonts */
#define SCIANTITLE	1
#define MAXFONTSUSED	10  /* max different fonts in window (for PS drawing) */
#endif

/*
	The font system handles font manager routines, if available, as
	well as raster fonts. A cache is kept of fonts and sizes used,  and
	when SetupFont is called, it is searched first; if new, fmfindfont 
	and fmscalefont are called to get a new handle which is cached for
	subsequent use. The handle is stored in currentFontHandle for use by 
	DrawAString, StringWidth, etc. If not found, (or if not FONTS4D), 
	currentFontHandle is set to NULL and the name is looked
	up in the raster font name table, rasterFont[]. (The size parameter
	is ignored.) If not found the system font is used.

	Note that icon fonts are not treated like text fonts, although they
	are initialized here in InitFonts.
*/

/* globals for font system */

#ifdef GRAPHICS

char *rasterFont[NRASTERFONTS + 1];	/* table of raster font name pointers */
int nFonts = 0;
char **fonts;	/* names of available fonts */
static int registeredFonts;
char curFontName[64];		/* remember which font is set */
int curFontSize;

#ifdef FONTS4D
fmfonthandle currentFontHandle = NIL;

struct fontinfo *cachedFontInfo;    /* pointer to font info table */
int fontInfoSize;   /* current size of font info table */ 
int nCachedFonts;   /* number of entries in font info table */
#else
int uiFontSize[NUIFONTTYPES];	/* table of UI font sizes if not FONTS4D */
#endif

int uiFontMap[NUIFONTS];

#endif

/* for PostScript output */
char *fontsUsed[MAXFONTSUSED];	/* list of fonts used in current file */
int numFontsUsed = 0;		/* number of fonts used = next index */
char showBuf[256];	/* string buffer for PostScript show */

#ifdef GRAPHICS

#ifdef HAVE_PROTOTYPES
int UIFontSize(int uiFontNum)
#else
int UIFontSize(uiFontNum)
int uiFontNum;
#endif
{
#ifdef FONTS4D
    return cachedFontInfo[uiFontMap[uiFontNum]].size;
#else
    return uiFontSize[uiFontMap[uiFontNum]];
#endif
}

void SetDemoFonts(void)
{
    uiFontMap[UISMALLFONT] = UIBOLDSMALLFONT;
    uiFontMap[UINORMALFONT] = UIBOLDNORMALFONT;
    uiFontMap[UILARGEFONT] = UIBOLDLARGEFONT;
    uiFontMap[UITITLEFONT] = UIBOLDTITLEFONT;
    uiFontMap[UIHELPFONT] = UIBOLDLARGEFONT;
    uiFontMap[UIINFOFONT] = UIBOLDNORMALFONT;
    uiFontMap[UICONTROLFONT] = UIBOLDNORMALFONT;
    uiFontMap[UISMALLCONTROLFONT] = UIBOLDSMALLFONT;
    uiFontMap[UIICONFONT] = UIBOLDNORMALFONT;
    uiFontMap[UIICONSUBFONT] = UIBOLDSMALLFONT;
}
#endif

static void CountFonts(s)
char *s;
/*Counts the fonts*/
{
#ifdef GRAPHICS
    ++nFonts;
#endif
}

static void RegisterFont(s)
char *s;
/*Puts the font names in a list, fonts[]*/
{
#ifdef GRAPHICS
    fonts[registeredFonts] = Alloc(strlen(s) + 1);	/* freed by KillFonts */
    strcpy(fonts[registeredFonts], s);
    ++registeredFonts;
#endif
}

#ifdef HAVE_PROTOTYPES
static int CompareFonts(const void *f1, const void *f2)
#else
static int CompareFonts(f1, f2)
void *f1;
void *f2;
#endif
/*Compares two font names*/
{
    return strcmp2(*(char **) f1, *(char **) f2);
}

#ifdef HAVE_PROTOTYPES
static void SortFonts(void)
#else
static void SortFonts()
#endif
{
    /*Sorts the fonts*/

    qsort(fonts, registeredFonts, sizeof(char *), CompareFonts);
}

void InitFonts(void) /*********************************** INITFONTS */
{
#ifdef GRAPHICS
    int i;
#ifdef FONTS4D
    fmfonthandle fh;
#endif

    nFonts = 2;

#ifdef FONTS4D
    fminit();
    fmenumerate(CountFonts);
#endif
    fonts = (char**) Alloc(sizeof(char *) * nFonts); /* freed in KillFonts */
#ifdef FONTS4D
    /* register fonts for font menu */
    registeredFonts = 0;
    fmenumerate(RegisterFont);
#endif

    /*Complete font menu with System and Palatino18*/
    RegisterFont("System");
    RegisterFont("Palatino18");

    SortFonts();

    rasterFont[0] = "System"; /* default */
    for (i=1; i<NRASTERFONTS+1; ++i) rasterFont[i] = "\0";

#ifdef BIGFONTSOK
    rasterFont[TITLEFONT] = "ScianTitle";
    defrasterfont(TITLEFONT, ScianTitleFontHT, ScianTitleFontNC, ScianTitleFontchars, 
		    ScianTitleFontRS, (void *) ScianTitleFontrasters);
#endif
    rasterFont[SUBTITLEFONT] = "Palatino18";
    defrasterfont(SUBTITLEFONT, palatino18HT, palatino18NC, stChars,
		    palatino18RS, (void *) stRasters);

    numFontsUsed = 0;
    strcpy(curFontName, "System");
    curFontSize = 10;

#ifdef FONTS4D

/* set up font info table */
    fontInfoSize = NUIFONTTYPES + FONTINFOCHUNK;
    cachedFontInfo = (struct fontinfo *) Alloc(fontInfoSize*sizeof(struct fontinfo));
    if (!cachedFontInfo)
    {
	/* The sky is falling! */
	OMErr();
	return;
    }
    
/* set up font mapping table */
    uiFontMap[UIMENUFONT] = UIMENUFONT;
    uiFontMap[UISMALLFONT] = UISMALLFONT;
    uiFontMap[UINORMALFONT] = UINORMALFONT;
    uiFontMap[UILARGEFONT] = UILARGEFONT;
    uiFontMap[UITITLEFONT] = UITITLEFONT;
    uiFontMap[UIBOLDSMALLFONT] = UIBOLDSMALLFONT;
    uiFontMap[UIBOLDNORMALFONT] = UIBOLDNORMALFONT;
    uiFontMap[UIBOLDLARGEFONT] = UIBOLDLARGEFONT;
    uiFontMap[UIBOLDTITLEFONT] = UIBOLDTITLEFONT;
    uiFontMap[UIHELPFONT] = UILARGEFONT;
    uiFontMap[UIHELPTITLEFONT] = UITITLEFONT;
    uiFontMap[UIINFOFONT] = UILARGEFONT;
    uiFontMap[UIPROMPTFONT] = UIBOLDLARGEFONT;
    uiFontMap[UICONTROLFONT] = UINORMALFONT;
    uiFontMap[UISMALLCONTROLFONT] = UISMALLFONT;
    uiFontMap[UIICONFONT] = UINORMALFONT;
    uiFontMap[UIICONSUBFONT] = UISMALLFONT;

/* set up fonts for user interface */

    /* Regular fonts */
    cachedFontInfo[UISMALLFONT].name = 
	cachedFontInfo[UINORMALFONT].name =
	cachedFontInfo[UILARGEFONT].name = 
	cachedFontInfo[UITITLEFONT].name = "Helvetica";
    cachedFontInfo[UISMALLFONT].size = 10;
    cachedFontInfo[UINORMALFONT].size = 12;
    cachedFontInfo[UILARGEFONT].size = 14;
    cachedFontInfo[UITITLEFONT].size = 18;
    fh = fmfindfont(cachedFontInfo[UISMALLFONT].name);
    if (fh) 
    {
	cachedFontInfo[UISMALLFONT].fontHandle = (char **)
		fmscalefont(fh, cachedFontInfo[UISMALLFONT].size);
	cachedFontInfo[UINORMALFONT].fontHandle = (char **)
		fmscalefont(fh, cachedFontInfo[UINORMALFONT].size);
	cachedFontInfo[UILARGEFONT].fontHandle = (char **)
		fmscalefont(fh, cachedFontInfo[UILARGEFONT].size);
	cachedFontInfo[UITITLEFONT].fontHandle = (char **)
		fmscalefont(fh, cachedFontInfo[UITITLEFONT].size);
    }
    else
    {
	cachedFontInfo[UISMALLFONT].fontHandle =
	    cachedFontInfo[UINORMALFONT].fontHandle =
	    cachedFontInfo[UILARGEFONT].fontHandle = 
	    cachedFontInfo[UITITLEFONT].fontHandle = (char **) 0;
    }
    /* Bold fonts */
    cachedFontInfo[UIBOLDSMALLFONT].name = 
	cachedFontInfo[UIBOLDNORMALFONT].name =
	cachedFontInfo[UIBOLDLARGEFONT].name = 
	cachedFontInfo[UIBOLDTITLEFONT].name = "Helvetica-Bold";
    cachedFontInfo[UIBOLDSMALLFONT].size = 10;
    cachedFontInfo[UIBOLDNORMALFONT].size = 12;
    cachedFontInfo[UIBOLDLARGEFONT].size = 14;
    cachedFontInfo[UIBOLDTITLEFONT].size = 18;
    fh = fmfindfont(cachedFontInfo[UIBOLDSMALLFONT].name);
    if (fh)
    {
	cachedFontInfo[UIBOLDSMALLFONT].fontHandle = (char **)
		fmscalefont(fh, cachedFontInfo[UIBOLDSMALLFONT].size);
	cachedFontInfo[UIBOLDNORMALFONT].fontHandle = (char **)
		fmscalefont(fh, cachedFontInfo[UIBOLDNORMALFONT].size);
	cachedFontInfo[UIBOLDLARGEFONT].fontHandle = (char **)
		fmscalefont(fh, cachedFontInfo[UIBOLDLARGEFONT].size);
	cachedFontInfo[UIBOLDTITLEFONT].fontHandle = (char **)
		fmscalefont(fh, cachedFontInfo[UIBOLDTITLEFONT].size);
    }
    else
    {
	cachedFontInfo[UIBOLDSMALLFONT].fontHandle =
		cachedFontInfo[UISMALLFONT].fontHandle;
	cachedFontInfo[UIBOLDNORMALFONT].fontHandle = 
		cachedFontInfo[UINORMALFONT].fontHandle;
	cachedFontInfo[UIBOLDLARGEFONT].fontHandle = 
		cachedFontInfo[UILARGEFONT].fontHandle;
	cachedFontInfo[UIBOLDTITLEFONT].fontHandle = 
		cachedFontInfo[UITITLEFONT].fontHandle;
    }
    /* menu font */
    cachedFontInfo[UIMENUFONT].name = "Helvetica-BoldOblique";
    cachedFontInfo[UIMENUFONT].size = 12;
    fh = fmfindfont(cachedFontInfo[UIMENUFONT].name);
    if (fh)
    {
	cachedFontInfo[UIMENUFONT].fontHandle = (char **)
		    fmscalefont(fh, cachedFontInfo[UIMENUFONT].size);
    }
    else
    {
	if (cachedFontInfo[UIBOLDNORMALFONT].fontHandle)
		cachedFontInfo[UIMENUFONT].fontHandle =
			cachedFontInfo[UIBOLDNORMALFONT].fontHandle;
	else cachedFontInfo[UIMENUFONT].fontHandle =
			cachedFontInfo[UINORMALFONT].fontHandle;
    }
    nCachedFonts = NUIFONTTYPES;
#else
/* not FONTS4D -- just set up UI font size table */
    uiFontSize[UIMENUFONT] = 12;
    uiFontSize[UISMALLFONT] = uiFontSize[UIBOLDSMALLFONT] = 10;
    uiFontSize[UINORMALFONT] = uiFontSize[UIBOLDNORMALFONT] = 12;
    uiFontSize[UILARGEFONT] = uiFontSize[UIBOLDLARGEFONT] = 14;
    uiFontSize[UITITLEFONT] = uiFontSize[UIBOLDTITLEFONT] = 18;
#endif

#endif
}

void KillFonts(void)
{
#ifdef GRAPHICS
    int k;

    for (k = 0; k < nFonts; ++k)
    {
	Free(fonts[k]);
    }
    if (fonts)
    {
	Free(fonts);
    }
#ifdef FONTS4D
    if (cachedFontInfo)
    {
	for (k=1; k<nCachedFonts; ++k)
	{
	    if (cachedFontInfo[k].name) Free(cachedFontInfo[k].name);
	}
	Free(cachedFontInfo);
    }
#endif
#endif
}

#ifdef HAVE_PROTOTYPES
Bool SetupFont(char *name, int size)
#else
Bool SetupFont(name, size)
char *name;
int size;
#endif
{
#ifdef GRAPHICS
    int i;

    if (drawingMode == DRAW_SCREEN)
    {
#ifdef FONTS4D
	/* see if this font is chached */
	
	for (i=1; i<nCachedFonts; ++i)
	{
	    if (strcmp(name, cachedFontInfo[i].name) != 0
		|| cachedFontInfo[i].size != size) continue;
	    /* found it */
	    currentFontHandle = (fmfonthandle) cachedFontInfo[i].fontHandle;
	    fmsetfont(currentFontHandle);
	    return true;
	}
	
	/* new font -- set it up and cache it */
        currentFontHandle = fmfindfont(name);
        if (currentFontHandle)
        {
            currentFontHandle = fmscalefont(currentFontHandle, size);
            fmsetfont(currentFontHandle);
	    
	    /* enter cache info; expand table if full */
	    if (!(nCachedFonts < fontInfoSize))
	    {
		fontInfoSize += FONTINFOCHUNK;
		cachedFontInfo =
		    (struct fontinfo *) Realloc((char *) cachedFontInfo,
			fontInfoSize*sizeof(struct fontinfo));
	    }
	    cachedFontInfo[nCachedFonts].name = Alloc(strlen(name) + 1);
	    strcpy(cachedFontInfo[nCachedFonts].name, name);
	    cachedFontInfo[nCachedFonts].size = size;
	    cachedFontInfo[nCachedFonts].fontHandle = (char **) currentFontHandle;
	    ++nCachedFonts;

            return true;
	}
        else /* font not known to font manager, maybe it's a raster */
        {
            currentFontHandle = NIL;
            for (i=1; i<NRASTERFONTS+1; ++i)
            {
                if (strcmp(name, rasterFont[i]) != 0) continue;
                font(i);
                return true;
            }
	    
	    /* no can find, use system font */
            font(0);
            return false;
	}
#else
        for (i=1; i<NRASTERFONTS+1; ++i)
        {
            if (strcmp(name, rasterFont[i]) != 0) continue;
            font(i);
            return true;
        }
        font(0);
        return false;
#endif
    }
    else if (drawingMode == DRAW_POSTSCRIPT && psFile)
    {
        /* see if same as current font and size */
        if (strcmp(name, curFontName) == 0 && size == curFontSize) return true;
	RegisterFontUsed(name);	/* add to list for PS file trailer */
        strcpy(curFontName, name); /* remember this */
	curFontSize = size;

        /* write PostScript to drawing file to set up font */
	/* size is made larger by 2 points to adjust for screen vs printer */
        fprintf(psFile, "/%s findfont %d scalefont setfont\n", name, size+2);
        return true;
    }
#endif
    return false;
}

#ifdef HAVE_PROTOTYPES
void SetUIFont(int uiFontNum)
#else
void SetUIFont(uiFontNum)
int uiFontNum;
#endif
{
    uiFontNum = uiFontMap[uiFontNum];
#ifdef GRAPHICS
    if (drawingMode == DRAW_SCREEN)
    {
#ifdef FONTS4D
	currentFontHandle = (fmfonthandle) cachedFontInfo[uiFontNum].fontHandle;
        fmsetfont(currentFontHandle);
#else
	font(0); /*** fix to use any raster font ***/
#endif
    }
    else if (drawingMode == DRAW_POSTSCRIPT && psFile)
    {
#ifdef FONTS4D
        /* see if same as current font and size */
        if (strcmp(cachedFontInfo[uiFontNum].name, curFontName) == 0
		&& cachedFontInfo[uiFontNum].size == curFontSize) return;
	RegisterFontUsed(cachedFontInfo[uiFontNum].name);
        strcpy(curFontName, cachedFontInfo[uiFontNum].name); /* remember this */
	curFontSize = cachedFontInfo[uiFontNum].size;

        /* write PostScript to drawing file to set up font */
	/* size is made larger by 2 points to adjust for screen vs printer */
        fprintf(psFile, "/%s findfont %d scalefont setfont\n", 
		cachedFontInfo[uiFontNum].name, cachedFontInfo[uiFontNum].size+2);
#else
	fprintf(psFile, "/Helvetica findfont 10 scalefont setfont\n");
	/*** fix to use any raster font ***/
#endif
    }
#endif
}

#ifdef HAVE_PROTOTYPES
void RegisterFontUsed(char *name)
#else
void RegisterFontUsed(name)
char *name;
#endif
{
/* for PostScript file output--makes list of fonts used for trailer */
#ifdef GRAPHICS
    int i;

    /* check list of fonts used */
    for (i = 0; i < numFontsUsed; ++i)
    {
        if (strcmp(name, fontsUsed[i]) == 0) return;
    }
    if (numFontsUsed >= MAXFONTSUSED)
    {
        ReportError("RegisterFontUsed","Too many fonts in PostScript file!");
        return;
    }
    fontsUsed[numFontsUsed] = Alloc(strlen(name) + 1);
    /* string space will be freed by EndDrawing() in ScianDraw.c */
    if (fontsUsed[numFontsUsed])
    {
         strcpy(fontsUsed[numFontsUsed], name);
         ++numFontsUsed;
    }
    else OMErr();
#endif
    return;
}


#ifdef HAVE_PROTOTYPES
int ChrWidth(char c)
#else
int ChrWidth(c)
char c;
#endif
{
#ifdef GRAPHICS
	if (c < ' ') return 0;
#ifdef FONTS4D
	if (currentFontHandle)
	{
		return fmgetchrwidth(currentFontHandle, c);
	}
	else
	{
		char buf[2];

		buf[0] = c;
		buf[1] = '\0';
		return strwidth(buf);
	}
#else
	{	char buf[2];

	buf[0] = c;
	buf[1] = '\0';
	return strwidth(buf);
	}
#endif
#else
	return 0;
#endif
}

#ifdef HAVE_PROTOTYPES
int StrWidth(char *s)
#else
int StrWidth(s)
char *s;
#endif
/* handles tabs in string */
{
#ifdef GRAPHICS
	int nTabs=0;
	char *t=s;

	while (*t)
	{
		if (*t++ == '\t')
		{
			s = t; /* point to char following tab */
			++nTabs;   /* incr tab count */
		}
	}
	/* now return the indent plus the length of the string following last tab */
#ifdef FONTS4D
	if (currentFontHandle)
	{
		return nTabs*TABWID*ChrWidth('0') + fmgetstrwidth(currentFontHandle, s);
	}
	else
	{
		return nTabs*TABWID*ChrWidth('0') + strwidth(s);
	}
#else
	return nTabs*TABWID*ChrWidth('0') + strwidth(s);
#endif
#else
	return 0;
#endif
}

#ifdef HAVE_PROTOTYPES
char *PSShow(char *s)
#else
char *PSShow(s)
char *s;
#endif
{
    /*
     * Process any special characters in string for PostScript show.
     */

    char *p = showBuf;
    
    while (*s)
    {
	if (*s == '(' || *s == ')' || *s == '\\') *p++ = '\\';
	*p++ = *s++;
    }
    *p = '\0';
    return showBuf;
}

#ifdef HAVE_PROTOTYPES
void DrawAString(int align, long x, long y, char *s)
#else
void DrawAString(align, x, y, s)
int align;
long x, y;
char *s;
#endif
{
#ifdef GRAPHICS
    int left, right, bottom, top;
	int xx, yy, dxx, dyy;
    
    if (drawingMode == DRAW_SCREEN)
    {
    /* find starting point of string */
	switch (align)
	{
	    case RIGHTALIGN:
		    x -= StrWidth(s);
		    break;

	    case CENTERALIGN:
		    x -= StrWidth(s)/2;
		    break;

	    case LEFTALIGN:
	    default:
		    break;
    	}

    /* check to see if string starts out of window */
	GetWindowBounds(&left, &right, &bottom, &top);
	CurOffset(&xx, &yy);
	GetWindowOrigin(&dxx, &dyy);
	left -= xx - dxx;
	
    /* trim string if necessary */
	while (x < left)
	{
	    if (*s == '\0') return;
	    x += ChrWidth(*s++);
	}
	cmov2i(x, y);
    
#ifdef FONTS4D
	if (currentFontHandle)
	{
		fmprstr(s);
	}
	else
	{
		charstr(s);
	}
#else
	charstr(s);
#endif
    }
    else if (drawingMode == DRAW_POSTSCRIPT && psFile && *s != '\0')
    {
    /* write PostScript to file */
	fprintf(psFile, "%f setgray\n", PSColor());
	switch (align)
	{
		case RIGHTALIGN:
			fprintf(psFile,
	"(%s) dup %d exch stringwidth pop sub %d moveto show\n", PSShow(s), x, y);
			break;

		case CENTERALIGN:
			fprintf(psFile,
	"(%s) dup %d exch stringwidth pop 2 div sub %d moveto show\n", PSShow(s), x, y);
			break;

		case LEFTALIGN:
		default:
        		fprintf(psFile, "%d %d moveto (%s) show\n", x, y, PSShow(s));
			break;
	}
    }
#endif
}