/************************************************************/
/* Windows Write, Copyright 1985-1992 Microsoft Corporation */
/************************************************************/

/* This routine sets up the screen position used by Word relative to the
current device. */

#define NOGDICAPMASKS
#define NOVIRTUALKEYCODES
#define NOWINMESSAGES
#define NOWINSTYLES
#define NOCLIPBOARD
#define NOCTLMGR
#define NOMENUS
/* HEY!  if you change this to wwsmall.h, talk to bobm!
    (see Assert(LF_FACESIZE == LocalFaceSize)) */
#include <windows.h>
#include "mw.h"
#include "cmddefs.h"
#include "docdefs.h"
#include "fontdefs.h"


int viffnDefault = -1;
CHAR rgffnFontFamily[6][ibFfnMax];


struct FFN *PffnDefault(ffid)
/* returns pointer to default font structure for this font family ID, which
   is set up when we started the program */

FFID ffid;
    {
    int iffn;
    struct FFN *pffn;

    if (ffid == FF_DONTCARE)
        {
        Assert(viffnDefault >= 0);
        iffn = viffnDefault;
        }
    else
        iffn = MpFfidIffn(ffid);

    pffn = (struct FFN *)(rgffnFontFamily[iffn]);
    if (pffn->szFfn[0] == 0)
        /* haven't gotten this one yet - must be old word document */
        GetDefaultFonts(TRUE, FALSE);

    Assert(pffn->szFfn[0] != 0);
    return(pffn);
    }



GetDefaultFonts(fExtraFonts, fGetAspect)
/* We set up our table of default fonts in two steps.  First we choose a single
   font, to use as the default font for a new document.  Perhaps later, we
   are asked for a set of default fonts for different families to help
   make sense out of an old, word document.  That case is differentiated
   by fExtraFonts being TRUE */

int fExtraFonts, fGetAspect;

    {
    extern int aspectXFont;
    extern int aspectYFont;
    extern HDC vhDCPrinter;
    struct FFN *pffn;
    CHAR rgb[ibFfnMax];

    Assert(LF_FACESIZE == LocalFaceSize);
#ifndef NEWFONTENUM  
    Assert(vhDCPrinter);
    if (fGetAspect && vhDCPrinter != NULL)
        {
        extern FARPROC lpFontFaceEnum;
        int rgw[6];

        rgw[0] = enumFindAspectRatio;
        rgw[1] = rgw[2] = 0xFFFF;
        rgw[3] = GetDeviceCaps(vhDCPrinter, LOGPIXELSY);
        rgw[4] = GetDeviceCaps(vhDCPrinter, LOGPIXELSX);
        rgw[5] = TRUE;
        
        EnumFonts(vhDCPrinter, 0L, lpFontFaceEnum, (LPSTR)MAKELONG(&rgw[0], 0));
        aspectXFont = rgw[1];
        aspectYFont = rgw[2];
        }
#endif

    if (FInitFontEnum(docNil, fExtraFonts ? 32767 : 1, TRUE))
        {
        pffn = (struct FFN *)rgb;
        while (FEnumFont(pffn))
#ifdef NEWFONTENUM
            DefaultFamilyCheck(pffn->ffid, pffn->szFfn, pffn->chs);
#else
            DefaultFamilyCheck(pffn->ffid, pffn->szFfn);
#endif
        EndFontEnum();
        }

    /* Fill in just in case we missed some.  The order here is important, if
    there are no fonts at all, the default font will be the first one. */
    {
    extern CHAR szModern[];
    extern CHAR szRoman[];
    extern CHAR szSwiss[];
    extern CHAR szScript[];
    extern CHAR szDecorative[];

    DefaultFamilyCheck(FF_MODERN, szModern, NULL);
    if (fExtraFonts)
        {
        DefaultFamilyCheck(FF_ROMAN, szRoman, NULL);
        DefaultFamilyCheck(FF_SWISS, szSwiss, NULL);
        DefaultFamilyCheck(FF_SCRIPT, szScript, NULL);
        DefaultFamilyCheck(FF_DECORATIVE, szDecorative, NULL);
        DefaultFamilyCheck(FF_DONTCARE, szSwiss, NULL);
        }
    }

    }



DefaultFamilyCheck(ffid, sz, chsIfKnown)
FFID ffid;
CHAR *sz;
BYTE chsIfKnown;
    {
    int iffn;
    struct FFN *pffn;

    iffn = MpFfidIffn(ffid);
    pffn = (struct FFN *)(rgffnFontFamily[iffn]);
    if (pffn->szFfn[0] == 0)
        {
#ifdef NEWFONTENUM
        pffn->chs = chsIfKnown;
#endif
        pffn->ffid = ffid;
        bltszLimit(sz, pffn->szFfn, LF_FACESIZE);
        if (viffnDefault < 0)
                /* this font will be chosen for new documents */
                viffnDefault = iffn;
        }
    }


#define iffnSwiss 0
#define iffnRoman 1
#define iffnModern 2
#define iffnScript 3
#define iffnDecorative 4
#define iffnDontCare 5


MpFfidIffn(ffid)
FFID ffid;
    {
    switch (ffid)
        {
        default:
            Assert( FALSE );
            /* FALL THROUGH */
        case FF_DONTCARE:
            return(iffnDontCare);
        case FF_SWISS:
            return(iffnSwiss);
        case FF_ROMAN:
            return(iffnRoman);
        case FF_MODERN:
            return(iffnModern);
        case FF_SCRIPT:
            return(iffnScript);
        case FF_DECORATIVE:
            return(iffnDecorative);
        }
    }


ResetDefaultFonts(fGetAspect)
int fGetAspect;
    {
    /* This routine resets the default mapping from a font family to a font face
    name. */
    bltbc(rgffnFontFamily, 0, 6 * ibFfnMax);
    viffnDefault = -1;
    GetDefaultFonts(FALSE, fGetAspect);
    }