mirror of https://github.com/tongzx/nt5src
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
606 lines
16 KiB
606 lines
16 KiB
/************************************************************/
|
|
/* Windows Write, Copyright 1985-1992 Microsoft Corporation */
|
|
/************************************************************/
|
|
|
|
/* Open.c -- WRITE document opening */
|
|
|
|
#define NOCLIPBOARD
|
|
#define NOGDICAPMASKS
|
|
#define NOVIRTUALKEYCODES
|
|
#define NOWINMESSAGES
|
|
#define NOSYSMETRICS
|
|
#define NOMENUS
|
|
#define NOICON
|
|
#define NOKEYSTATE
|
|
#define NOSYSCOMMANDS
|
|
#define NORASTEROPS
|
|
//#define NOATOM
|
|
#define NOBITMAP
|
|
#define NOPEN
|
|
#define NODRAWTEXT
|
|
#define NOCOLOR
|
|
#define NOCREATESTRUCT
|
|
#define NOHDC
|
|
#define NOMETAFILE
|
|
#define NOMSG
|
|
#define NOPOINT
|
|
#define NORECT
|
|
#define NOREGION
|
|
#define NOSCROLL
|
|
#define NOWH
|
|
#define NOWINOFFSETS
|
|
#define NOSOUND
|
|
#define NOCOMM
|
|
#define NORESOURCE
|
|
#include <windows.h>
|
|
#include "mw.h"
|
|
#include "doslib.h"
|
|
#include "dispdefs.h"
|
|
#define NOUAC
|
|
#include "cmddefs.h"
|
|
#include "wwdefs.h"
|
|
#include "docdefs.h"
|
|
#include "fontdefs.h"
|
|
#include "editdefs.h"
|
|
#include "filedefs.h"
|
|
#include "propdefs.h"
|
|
#include "fkpdefs.h"
|
|
#define NOSTRUNDO
|
|
#define NOSTRMERGE
|
|
#include "str.h"
|
|
#include "code.h"
|
|
#include "prmdefs.h"
|
|
#include "obj.h"
|
|
#define PAGEONLY
|
|
#include "printdef.h" /* printdefs.h */
|
|
/*
|
|
#include "dlgdefs.h"
|
|
*/
|
|
|
|
/* These defines replace dlgdefs.h to combat compiler heap overflows */
|
|
#define idiYes IDOK
|
|
#define idiNo 3
|
|
#define idiCancel IDCANCEL
|
|
|
|
/* These defines replace heapdefs.h and heapdata.h for the same
|
|
irritating reason */
|
|
#define cwSaveAlloc (128)
|
|
#define cwHeapMinPerWindow (50)
|
|
#define cwHeapSpaceMin (60)
|
|
|
|
/* E X T E R N A L S */
|
|
|
|
extern CHAR (**vhrgbSave)[];
|
|
extern HANDLE hParentWw;
|
|
extern HANDLE hMmwModInstance;
|
|
extern struct WWD rgwwd[];
|
|
extern int wwMac;
|
|
extern struct FCB (**hpfnfcb)[];
|
|
extern struct DOD (**hpdocdod)[];
|
|
extern int docMac;
|
|
extern struct WWD *pwwdCur;
|
|
extern int fnMac;
|
|
extern CHAR stBuf[];
|
|
#if WINVER >= 0x300
|
|
extern BOOL fError;
|
|
#endif
|
|
|
|
|
|
short WCompSzC();
|
|
CHAR (**HszCreate())[];
|
|
struct FNTB **HfntbCreate();
|
|
#ifdef CASHMERE
|
|
struct SETB **HsetbCreate();
|
|
#else
|
|
struct SEP **HsepCreate();
|
|
#endif
|
|
struct PGTB **HpgtbCreate();
|
|
|
|
|
|
CHAR *PchFromFc( int, typeFC, int * );
|
|
CHAR *PchGetPn( int, typePN, int *, int );
|
|
typeFC FcMacFromUnformattedFn( int );
|
|
int CchReadAtPage( int, typePN, CHAR *, int, int );
|
|
|
|
|
|
|
|
|
|
|
|
struct TBD (**HgtbdCreate(fn))[]
|
|
int fn;
|
|
{ /* Create a MEMO tab table by reading the properties of the first
|
|
para of the passed fn and returning a handle. The handle returned will
|
|
be 0 if the tab table is not present or null */
|
|
struct TBD (**hgtbd)[] = 0;
|
|
struct PAP pap;
|
|
|
|
Assert( (fn != fnNil) && (**hpfnfcb)[fn].fFormatted );
|
|
|
|
bltc((int *)&pap, 0, cwPAP); /* else we will have garbage tabs */
|
|
FcParaLim( fn, (typeFC)cfcPage, (**hpfnfcb)[fn].fcMac, &pap );
|
|
if (pap.rgtbd[0].dxa && !FNoHeap( hgtbd = (struct TBD (**)[])HAllocate( cwTBD *
|
|
itbdMax )))
|
|
{
|
|
register struct TBD *ptbd = &pap.rgtbd[0];
|
|
pap.rgtbd[itbdMax - 1].dxa = 0; /* just in case a WORD document has more
|
|
than 12 tabs */
|
|
|
|
/* overwrite tabs and leading tab char that WRITE does not support */
|
|
for ( ; ptbd->dxa != 0; ptbd++)
|
|
{
|
|
ptbd->tlc = tlcWhite;
|
|
ptbd->opcode = 0;
|
|
ptbd->chAlign = 0;
|
|
if (ptbd->jc == jcCenter)
|
|
ptbd->jc = jcLeft;
|
|
else if (ptbd->jc == jcRight)
|
|
ptbd->jc = jcBoth;
|
|
}
|
|
blt( &pap.rgtbd[0], *hgtbd, cwTBD * itbdMax );
|
|
}
|
|
return hgtbd;
|
|
}
|
|
|
|
|
|
|
|
struct SEP **HsepCreate(fn)
|
|
int fn;
|
|
{ /* Given an fn for a formatted file, return a handle to an SEP
|
|
giving section properties for the file. Returns NULL if
|
|
standard properties should be used. If the file has a section
|
|
table, the properties from the first section in the table are used */
|
|
extern struct SEP vsepNormal;
|
|
|
|
|
|
struct SETB *psetbFile;
|
|
typePN pn;
|
|
struct SEP **hsep;
|
|
struct SED *psed;
|
|
CHAR *pchFprop;
|
|
int cch;
|
|
|
|
Assert(fn != fnNil && (**hpfnfcb)[fn].fFormatted);
|
|
|
|
if ((pn = (**hpfnfcb)[fn].pnSetb) == (**hpfnfcb)[fn].pnBftb)
|
|
return (struct SEP **) 0;
|
|
psetbFile = (struct SETB *) PchGetPn(fn, pn, &cch, false);
|
|
if (psetbFile->csed == 0)
|
|
return (struct SEP **)0;
|
|
|
|
/* File has a section table; copy properties from first SEP */
|
|
hsep = (struct SEP **) HAllocate( cwSEP );
|
|
if (FNoHeap( hsep ))
|
|
return (struct SEP **) hOverflow;
|
|
blt( &vsepNormal, *hsep, cwSEP );
|
|
psed = &psetbFile->rgsed [0];
|
|
if (psed->fc == fcNil)
|
|
return (struct SEP **)0;
|
|
pchFprop = PchFromFc( fn, psed->fc, &cch );
|
|
if (*pchFprop != 0)
|
|
{
|
|
struct SEP *psep = *hsep;
|
|
|
|
bltbyte( pchFprop+1, psep, *pchFprop );
|
|
|
|
#ifndef FIXED_PAGE
|
|
/* Some of the section properties must be adjusted to the current page size
|
|
(stored in vsepNormal). */
|
|
if (psep->xaMac != vsepNormal.xaMac)
|
|
{
|
|
int dxa = vsepNormal.xaMac - psep->xaMac;
|
|
|
|
psep->xaMac += dxa;
|
|
psep->dxaText = max(psep->dxaText + dxa, dxaMinUseful);
|
|
psep->xaPgn += dxa;
|
|
}
|
|
if (psep->yaMac != vsepNormal.yaMac)
|
|
{
|
|
int dya = vsepNormal.yaMac - psep->yaMac;
|
|
|
|
psep->yaMac += dya;
|
|
psep->dyaText = max(psep->dyaText + dya, dyaMinUseful);
|
|
psep->yaRH2 += dya;
|
|
}
|
|
#endif /* not FIXED_PAGE */
|
|
|
|
}
|
|
return hsep;
|
|
} /* end of H s e p C r e a t e */
|
|
|
|
|
|
|
|
|
|
struct PGTB **HpgtbCreate(fn)
|
|
int fn;
|
|
{ /* Create a page table from a formatted file */
|
|
struct PGTB *ppgtbFile;
|
|
typePN pn;
|
|
int cchT;
|
|
int cpgd;
|
|
struct PGTB **hpgtb;
|
|
int *pwPgtb;
|
|
int cw;
|
|
|
|
Assert(fn != fnNil && (**hpfnfcb)[fn].fFormatted);
|
|
|
|
if ((pn = (**hpfnfcb)[fn].pnBftb) == (**hpfnfcb)[fn].pnFfntb)
|
|
return (struct PGTB **)0;
|
|
ppgtbFile = (struct PGTB *) PchGetPn(fn, pn, &cchT, false);
|
|
if ((cpgd = ppgtbFile->cpgd) == 0)
|
|
return (struct PGTB **)0;
|
|
|
|
hpgtb = (struct PGTB **) HAllocate(cw = cwPgtbBase + cpgd * cwPGD);
|
|
if (FNoHeap(hpgtb))
|
|
return (struct PGTB **)hOverflow;
|
|
|
|
pwPgtb = (int *) *hpgtb;
|
|
|
|
blt(ppgtbFile, pwPgtb, min(cwSector, cw));
|
|
|
|
while ((cw -= cwSector) > 0)
|
|
{ /* Copy the pgd's to heap */
|
|
blt(PchGetPn(fn, ++pn, &cchT, false), pwPgtb += cwSector,
|
|
min(cwSector, cw));
|
|
}
|
|
|
|
(*hpgtb)->cpgdMax = cpgd;
|
|
return hpgtb;
|
|
} /* end of H p g t b C r e a t e */
|
|
|
|
|
|
|
|
|
|
int FnFromSz( sz ) /* filename is expected as ANSI */
|
|
CHAR *sz;
|
|
{
|
|
int fn;
|
|
struct FCB *pfcb;
|
|
|
|
if (sz[0] == 0)
|
|
return fnNil;
|
|
|
|
/* Mod for Sand: Only return fn if it is on the "current" volume (disk) */
|
|
for (fn = 0; fn < fnMac; fn++)
|
|
if ((pfcb = &(**hpfnfcb)[fn])->rfn != rfnFree && (WCompSzC((PCH)sz, (PCH)**pfcb->hszFile) == 0)
|
|
#ifdef SAND
|
|
&& (pfcb->vref == vrefFile)
|
|
#endif /* SAND */
|
|
)
|
|
return fn;
|
|
return fnNil;
|
|
} /* end of F n F r o m S z */
|
|
|
|
|
|
|
|
|
|
int FnOpenSz( szT, dty, fSearchPath ) /* filename is expected as ANSI */
|
|
CHAR *szT;
|
|
int dty;
|
|
int fSearchPath;
|
|
{ /* Open an existing file. Returns fnNil if not found */
|
|
int fn;
|
|
struct FIB fib;
|
|
|
|
struct FCB *pfcb;
|
|
CHAR (**hsz)[];
|
|
|
|
CHAR sz[cchMaxFile];
|
|
|
|
bltsz( szT, sz );
|
|
sz[cchMaxFile - 1] = 0;
|
|
|
|
#ifdef DFILE
|
|
CommSzSz("FnOpenSz: sz presumed ANSI = ",sz);
|
|
#endif
|
|
|
|
if (sz[0]=='\0')
|
|
return fnNil;
|
|
|
|
if ((fn = FnFromSz(sz)) != fnNil)
|
|
{ /* File is already open -- re-open it, in case it was changed by
|
|
another app */
|
|
FreeFn( fn );
|
|
}
|
|
|
|
if ((fn = FnAlloc()) == fnNil)
|
|
return fnNil;
|
|
|
|
if (FNoHeap((hsz = HszCreate((PCH)sz))))
|
|
return fnNil;
|
|
|
|
pfcb = &(**hpfnfcb)[fn];
|
|
Assert( !pfcb->fSearchPath );
|
|
if (fSearchPath)
|
|
pfcb->fSearchPath = TRUE;
|
|
pfcb->mdFile = mdBinary; /* Try R/W first, will be smashed to RO if needed */
|
|
pfcb->dty = pfcb->mdExt = (dty == dtyNormNoExt) ? dtyNormal : dty;
|
|
pfcb->hszFile = hsz;
|
|
|
|
{
|
|
OFSTRUCT of;
|
|
SetErrorMode(1);
|
|
if (OpenFile(sz, (LPOFSTRUCT) &of, OF_EXIST) == -1)
|
|
/* this is much cleaner than FAccessFn() for check existance */
|
|
{
|
|
char szMsg[cchMaxSz];
|
|
extern int vfInitializing;
|
|
int fT = vfInitializing;
|
|
|
|
vfInitializing = FALSE; /* Report this err, even during inz */
|
|
MergeStrings ((of.nErrCode == dosxSharing) ? IDPMTCantShare:IDPMTCantOpen, sz, szMsg);
|
|
IdPromptBoxSz(vhWndMsgBoxParent ? vhWndMsgBoxParent : hParentWw, szMsg, MB_OK|MB_ICONEXCLAMATION);
|
|
vfInitializing = fT;
|
|
FreeH( (**hpfnfcb) [fn].hszFile);
|
|
return fnNil;
|
|
}
|
|
}
|
|
|
|
/* dtyNormNoExt is directed at this call */
|
|
if (!FAccessFn( fn, dty )) /* HM if error */
|
|
{
|
|
FreeH( (**hpfnfcb) [fn].hszFile);
|
|
return fnNil;
|
|
}
|
|
|
|
/* kludge management (6.21.91) v-dougk */
|
|
dty = (dty == dtyNormNoExt) ? dtyNormal : dty;
|
|
|
|
Assert( (sizeof (struct FIB) == cfcPage) && (cfcPage == cbSector) );
|
|
Assert( pfcb == &(**hpfnfcb) [fn] ); /* No HM if FAccessFn succeeds */
|
|
|
|
if ( (CchReadAtPage( fn, (typePN) 0,
|
|
(CHAR *) &fib, cbSector, TRUE ) != cbSector) ||
|
|
(fib.wTool != wMagicTool) )
|
|
|
|
{ /* Not a formatted file */
|
|
typeFC fcMac = fc0;
|
|
int cfc;
|
|
|
|
if (dty != dtyNormal)
|
|
{
|
|
char szMsg[cchMaxSz];
|
|
PchFillPchId( szMsg, IDPMTBadFile, sizeof(szMsg) );
|
|
if (MessageBox(hPARENTWINDOW, (LPSTR)szMsg,
|
|
(LPSTR)szAppName, MB_ICONEXCLAMATION|MB_YESNO|MB_DEFBUTTON2) == IDNO)
|
|
goto ErrRet;
|
|
}
|
|
pfcb->fFormatted = false;
|
|
|
|
/* Obtain file size by seeking to end-of-file */
|
|
if ((pfcb->fcMac = fcMac = FcMacFromUnformattedFn( fn )) == (typeFC) -1)
|
|
/* Serious error while seeking to file's end */
|
|
goto ErrRet;
|
|
pfcb->pnMac = (fcMac + cfcPage - 1) / cfcPage;
|
|
}
|
|
else
|
|
{ /* File is formatted; use stored fcMac, create run table */
|
|
|
|
if ((((fib.wIdent != wMagic) && (fib.wIdent != wOleMagic)) ||
|
|
(fib.dty != dty)) ||
|
|
// some bigwig media guy sent us a Write file whose fcMac was
|
|
// trashed (all else was OK). We gotta try to detect this obsure
|
|
// potentiality.
|
|
(fib.fcMac >= (typeFC)fib.pnPara*128 ) ||
|
|
(fib.fcMac > FcMacFromUnformattedFn( fn ))
|
|
)
|
|
{ /* Wrong type of file or corrupted file */
|
|
char szMsg[cchMaxSz];
|
|
PchFillPchId( szMsg, IDPMTBadFile, sizeof(szMsg) );
|
|
if (MessageBox(hPARENTWINDOW, (LPSTR)szMsg,
|
|
(LPSTR)szAppName, MB_ICONEXCLAMATION|MB_YESNO|MB_DEFBUTTON2) == IDNO)
|
|
goto ErrRet;
|
|
}
|
|
|
|
if ((fib.wIdent == wOleMagic) && !fOleEnabled)
|
|
Error(IDPMTFileContainsObjects);
|
|
|
|
if (fib.pnMac == (typePN)0)
|
|
/* KLUDGE to load word files, which don't have ffntb entries. */
|
|
fib.pnMac = fib.pnFfntb;
|
|
|
|
pfcb->fFormatted = true;
|
|
pfcb->fcMac = fib.fcMac;
|
|
#ifdef p2bSector
|
|
pfcb->pnChar = (fib.fcMac + cfcPage - 1) / cfcPage;
|
|
#else
|
|
pfcb->pnChar = (fib.fcMac + cfcPage - 1) / cfcPage;
|
|
#endif
|
|
pfcb->pnPara = fib.pnPara;
|
|
pfcb->pnFntb = fib.pnFntb;
|
|
pfcb->pnSep = fib.pnSep;
|
|
|
|
pfcb->pnSetb = fib.pnSetb;
|
|
pfcb->pnBftb = fib.pnBftb;
|
|
pfcb->pnFfntb = fib.pnFfntb;
|
|
pfcb->pnMac = fib.pnMac;
|
|
if (dty != dtyPrd)
|
|
{
|
|
if (FNoHeap(hsz = HszCreate((PCH)fib.szSsht)))
|
|
goto ErrRet;
|
|
(**hpfnfcb)[fn].hszSsht = hsz;
|
|
if (!FMakeRunTables(fn))
|
|
goto ErrRet;
|
|
}
|
|
}
|
|
|
|
return fn;
|
|
|
|
ErrRet:
|
|
(pfcb = &(**hpfnfcb)[fn])->rfn = rfnFree;
|
|
FreeH(pfcb->hszFile);
|
|
return fnNil;
|
|
} /* end of F n O p e n S z */
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/*---------------------------------------------------------------------------
|
|
-- Routine: WCompSzC(psz1,psz2)
|
|
-- Description and Usage:
|
|
Alphabetically compares the two null-terminated strings psz1 and psz2.
|
|
Upper case alpha characters are mapped to lower case.
|
|
Comparison of non-alpha characters is by ascii code.
|
|
Returns 0 if they are equal, a negative number if psz1 precedes psz2, and
|
|
a non-zero positive number if psz2 precedes psz1.
|
|
-- Arguments:
|
|
psz1, psz2 - pointers to two null-terminated strings to compare
|
|
-- Returns:
|
|
a short - 0 if strings are equal, negative number if psz1 precedes psz2,
|
|
and non-zero positive number if psz2 precedes psz1.
|
|
-- Side-effects: none
|
|
-- Bugs:
|
|
-- History:
|
|
3/14/83 - created (tsr)
|
|
----------------------------------------------------------------------------*/
|
|
short
|
|
WCompSzC(psz1,psz2)
|
|
PCH psz1;
|
|
PCH psz2;
|
|
{
|
|
int ch1;
|
|
int ch2;
|
|
|
|
for(ch1=ChLowerC(*psz1++),ch2=ChLowerC(*psz2++);
|
|
ch1==ch2;
|
|
ch1=ChLowerC(*psz1++),ch2=ChLowerC(*psz2++))
|
|
{
|
|
if(ch1 == '\0')
|
|
return(0);
|
|
}
|
|
return(ch1-ch2);
|
|
} /* end of W C o m p S z C */
|
|
|
|
/*---------------------------------------------------------------------------
|
|
-- Routine: ChLowerC(ch)
|
|
-- Description and Usage:
|
|
Converts its argument to lower case iff its argument is upper case.
|
|
Returns the de-capitalized character or the initial char if it wasn't caps.
|
|
-- Arguments:
|
|
ch - character to be de-capitalized
|
|
-- Returns:
|
|
a character - initial character, de-capitalized if needed.
|
|
-- Side-effects:
|
|
-- Bugs:
|
|
-- History:
|
|
3/14/83 - created (tsr)
|
|
----------------------------------------------------------------------------*/
|
|
int
|
|
ChLowerC(ch)
|
|
register CHAR ch;
|
|
{
|
|
if(isupper(ch))
|
|
return(ch + ('a' - 'A')); /* foreign is taken care of */
|
|
else
|
|
return ch;
|
|
} /* end of C h L o w e r C */
|
|
|
|
#ifdef JAPAN
|
|
// Compare ch with halfsize-KANA code range, then return whether it is or not.
|
|
BOOL IsKanaInDBCS(int ch)
|
|
{
|
|
ch &= 0x00ff;
|
|
if(ch>=0xA1 && ch <= 0xDF) return TRUE;
|
|
else return FALSE;
|
|
}
|
|
#endif
|
|
|
|
|
|
|
|
|
|
|
|
typeFC (**HgfcCollect(fn, pnFirst, pnLim))[]
|
|
typePN pnFirst, pnLim;
|
|
{ /* Create a table indexing fc's by fkp number */
|
|
typeFC fcMac;
|
|
typePN pn;
|
|
int ifcMac, ifc;
|
|
typeFC (**hgfc)[];
|
|
|
|
struct FKP fkp;
|
|
|
|
fcMac = (**hpfnfcb)[fn].fcMac;
|
|
pn = pnFirst + 1;
|
|
ifcMac = ifcMacInit; /* Length of table */
|
|
hgfc = (typeFC (**)[])HAllocate((ifcMacInit * sizeof(typeFC)) / sizeof(int));
|
|
if (FNoHeap(hgfc))
|
|
return (typeFC (**)[])hOverflow;
|
|
|
|
for (ifc = 0; ; ++ifc, ++pn)
|
|
{ /* Put first fcLim of each fkp in table */
|
|
if (ifc >= ifcMac)
|
|
{ /* Must grow table */
|
|
int cw = ((ifcMac += ifcMacInit) * sizeof (typeFC)) / sizeof(int);
|
|
if (!FChngSizeH(hgfc, cw, false))
|
|
{
|
|
LHFGCErrRet:
|
|
FreeH(hgfc);
|
|
return (typeFC (**)[])hOverflow;
|
|
}
|
|
}
|
|
if (pn < pnLim)
|
|
{ /* Get fcLimFkb from fcFirst of next page */
|
|
int cch;
|
|
|
|
cch = CchReadAtPage( fn, pn, (CHAR *) &fkp, cbSector, TRUE );
|
|
if (cch != cfcPage)
|
|
goto LHFGCErrRet;
|
|
(**hgfc)[ifc] = fkp.fcFirst;
|
|
}
|
|
else
|
|
{ /* fcLimFkb is fcMac + 1 */
|
|
(**hgfc)[ifc] = fcMac + 1;
|
|
if (!FChngSizeH(hgfc, ((ifc + 1) * sizeof(typeFC)) / sizeof(int), true))
|
|
{
|
|
/* Previously ignored bad return value here ..pault 11/3/89 */
|
|
goto LHFGCErrRet;
|
|
}
|
|
return hgfc;
|
|
}
|
|
}
|
|
} /* end of H g f c C o l l e c t */
|
|
|
|
|
|
|
|
|
|
/* F M A K E R U N T A B L E S */
|
|
int FMakeRunTables(fn)
|
|
{ /* Create two tables of fc-dpn pairs, one for chr's and one for par's */
|
|
typeFC (**hgfc)[];
|
|
|
|
if (FNoHeap(hgfc = HgfcCollect(fn, (**hpfnfcb)[fn].pnChar, (**hpfnfcb)[fn].pnPara)))
|
|
return false;
|
|
(**hpfnfcb)[fn].hgfcChp = hgfc;
|
|
if (FNoHeap(hgfc = HgfcCollect(fn, (**hpfnfcb)[fn].pnPara, (**hpfnfcb)[fn].pnFntb)))
|
|
{
|
|
FreeH( (**hpfnfcb) [fn].hgfcChp );
|
|
return false;
|
|
}
|
|
(**hpfnfcb)[fn].hgfcPap = hgfc;
|
|
return true;
|
|
} /* end of F M a k e R u n T a b l e */
|
|
|
|
|
|
|
|
FApplyOldWordSprm(doc)
|
|
/* applies a sprm to this doc which causes all "old word" fonts to be remapped
|
|
into new windows ones */
|
|
{
|
|
CHAR rgbSprm[7];
|
|
extern int vfSysFull;
|
|
|
|
/* set up the OldFtc sprm mapping */
|
|
rgbSprm[0] = sprmCOldFtc;
|
|
rgbSprm[1] = 5;
|
|
|
|
rgbSprm[2 + iftcModern] = FtcScanDocFfn(doc, PffnDefault(FF_MODERN));
|
|
rgbSprm[2 + iftcRoman] = FtcScanDocFfn(doc, PffnDefault(FF_ROMAN));
|
|
rgbSprm[2 + iftcScript] = FtcScanDocFfn(doc, PffnDefault(FF_SCRIPT));
|
|
rgbSprm[2 + iftcDecorative] = FtcScanDocFfn(doc, PffnDefault(FF_DECORATIVE));
|
|
rgbSprm[2 + iftcSwiss] = FtcScanDocFfn(doc, PffnDefault(FF_SWISS));
|
|
|
|
AddSprmCps(rgbSprm, doc, (typeCP)0, (**hpdocdod)[doc].cpMac);
|
|
return(vfSysFull == 0);
|
|
}
|
|
|