709 lines
19 KiB
C
709 lines
19 KiB
C
|
/************************************************************/
|
|||
|
|
/* Windows Write, Copyright 1985-1992 Microsoft Corporation */
|
|||
|
|
/************************************************************/
|
|||
|
|
|
|||
|
|
/* cache.c -- Paragraph attribute fetching and caching for WRITE */
|
|||
|
|
|
|||
|
|
#define NOCLIPBOARD
|
|||
|
|
#define NOGDICAPMASKS
|
|||
|
|
#define NOCTLMGR
|
|||
|
|
#define NOVIRTUALKEYCODES
|
|||
|
|
#define NOWINMESSAGES
|
|||
|
|
#define NOWINSTYLES
|
|||
|
|
#define NOSYSMETRICS
|
|||
|
|
#define NOMENUS
|
|||
|
|
#define NOICON
|
|||
|
|
#define NOKEYSTATE
|
|||
|
|
#define NORASTEROPS
|
|||
|
|
#define NOSHOWWINDOW
|
|||
|
|
#define NOSYSCOMMANDS
|
|||
|
|
#define NOCREATESTRUCT
|
|||
|
|
#define NOATOM
|
|||
|
|
#define NOMETAFILE
|
|||
|
|
#define NOGDI
|
|||
|
|
#define NOFONT
|
|||
|
|
#define NOBRUSH
|
|||
|
|
#define NOPEN
|
|||
|
|
#define NOBITMAP
|
|||
|
|
#define NOCOLOR
|
|||
|
|
#define NODRAWTEXT
|
|||
|
|
#define NOWNDCLASS
|
|||
|
|
#define NOSOUND
|
|||
|
|
#define NOCOMM
|
|||
|
|
#define NOMB
|
|||
|
|
#define NOMSG
|
|||
|
|
#define NOOPENFILE
|
|||
|
|
#define NORESOURCE
|
|||
|
|
#define NOPOINT
|
|||
|
|
#define NORECT
|
|||
|
|
#define NOREGION
|
|||
|
|
#define NOSCROLL
|
|||
|
|
#define NOTEXTMETRIC
|
|||
|
|
#define NOWH
|
|||
|
|
#define NOWINOFFSETS
|
|||
|
|
#include <windows.h>
|
|||
|
|
|
|||
|
|
#include "mw.h"
|
|||
|
|
#include "docdefs.h"
|
|||
|
|
#include "editdefs.h"
|
|||
|
|
#include "cmddefs.h"
|
|||
|
|
#include "propdefs.h"
|
|||
|
|
#include "filedefs.h"
|
|||
|
|
#include "fkpdefs.h"
|
|||
|
|
#include "fmtdefs.h"
|
|||
|
|
#define NOKCCODES
|
|||
|
|
#include "ch.h"
|
|||
|
|
#include "prmdefs.h"
|
|||
|
|
#include "debug.h"
|
|||
|
|
|
|||
|
|
extern int vfDiskError;
|
|||
|
|
extern typeCP vcpFirstParaCache;
|
|||
|
|
extern typeCP vcpLimParaCache;
|
|||
|
|
extern typeFC fcMacPapIns;
|
|||
|
|
extern struct FCB (**hpfnfcb)[];
|
|||
|
|
extern struct FKPD vfkpdParaIns;
|
|||
|
|
extern int ichInsert;
|
|||
|
|
extern CHAR rgchInsert[];
|
|||
|
|
extern int vdocExpFetch;
|
|||
|
|
extern int vdocSectCache;
|
|||
|
|
extern typeCP vcpFirstSectCache;
|
|||
|
|
extern typeCP vcpLimSectCache;
|
|||
|
|
extern int vdocPageCache;
|
|||
|
|
extern typeCP vcpMinPageCache;
|
|||
|
|
extern typeCP vcpMacPageCache;
|
|||
|
|
extern typeCP cpMinCur;
|
|||
|
|
|
|||
|
|
extern struct PAP vpapAbs;
|
|||
|
|
extern struct PAP *vppapNormal;
|
|||
|
|
extern struct DOD (**hpdocdod)[];
|
|||
|
|
extern struct FLI vfli;
|
|||
|
|
extern int vdxaPaper;
|
|||
|
|
extern int vdyaPaper;
|
|||
|
|
extern typePN PnFkpFromFcScr();
|
|||
|
|
|
|||
|
|
|
|||
|
|
extern int vdocParaCache;
|
|||
|
|
extern int visedCache;
|
|||
|
|
extern int vdocPageCache;
|
|||
|
|
|
|||
|
|
extern struct SEP vsepAbs;
|
|||
|
|
extern struct SEP vsepPage;
|
|||
|
|
extern struct SEP vsepNormal;
|
|||
|
|
|
|||
|
|
extern int ctrCache;
|
|||
|
|
extern int itrFirstCache;
|
|||
|
|
extern int itrLimCache;
|
|||
|
|
extern typeCP cpCacheHint;
|
|||
|
|
|
|||
|
|
CHAR *PchFromFc();
|
|||
|
|
CHAR *PchGetPn();
|
|||
|
|
|
|||
|
|
CachePara(doc, cp)
|
|||
|
|
int doc;
|
|||
|
|
typeCP cp;
|
|||
|
|
{ /* Make the para containing <doc, cp> the currently cached para */
|
|||
|
|
struct PCD *ppcd, *ppcdBase;
|
|||
|
|
typeCP cpMac, cpGuess;
|
|||
|
|
struct DOD *pdod;
|
|||
|
|
int dty;
|
|||
|
|
struct PCTB *ppctb;
|
|||
|
|
|
|||
|
|
if (vdocParaCache == doc && vcpFirstParaCache <= cp &&
|
|||
|
|
cp < vcpLimParaCache)
|
|||
|
|
return; /* That's what the cache is for */
|
|||
|
|
|
|||
|
|
Assert(cp >= cp0);
|
|||
|
|
|
|||
|
|
pdod = &(**hpdocdod)[doc];
|
|||
|
|
dty = pdod->dty;
|
|||
|
|
if (cp >= pdod->cpMac)
|
|||
|
|
{ /* Use normal para for end mark and beyond */
|
|||
|
|
#ifdef ENABLE /* Occasionally this is not true (but it should be) */
|
|||
|
|
Assert( cp == pdod->cpMac );
|
|||
|
|
#endif
|
|||
|
|
|
|||
|
|
if (cp > cpMinCur)
|
|||
|
|
{ /* this piece of code treats the case when the whole document
|
|||
|
|
is a non-empty semi-paragraph (chars but no EOL's) */
|
|||
|
|
CachePara( doc, cp - 1 ); /* Recursion will not happen */
|
|||
|
|
if ( vcpLimParaCache > cp )
|
|||
|
|
{
|
|||
|
|
vcpLimParaCache = pdod->cpMac + ccpEol;
|
|||
|
|
return;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
vdocParaCache = doc;
|
|||
|
|
vcpLimParaCache = (vcpFirstParaCache = pdod->cpMac) + ccpEol;
|
|||
|
|
DefaultPaps( doc );
|
|||
|
|
return;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
FreezeHp();
|
|||
|
|
ppctb = *pdod->hpctb;
|
|||
|
|
ppcdBase = &ppctb->rgpcd [ IpcdFromCp( ppctb, cpGuess = cp ) ];
|
|||
|
|
|
|||
|
|
if (vdocParaCache == doc && cp == vcpLimParaCache)
|
|||
|
|
vcpFirstParaCache = cp;
|
|||
|
|
else
|
|||
|
|
{ /* Search backward to find para start */
|
|||
|
|
for (ppcd = ppcdBase; ; --ppcd)
|
|||
|
|
{ /* Beware heap movement! */
|
|||
|
|
typeCP cpMin = ppcd->cpMin;
|
|||
|
|
int fn = ppcd->fn;
|
|||
|
|
if (! ppcd->fNoParaLast)
|
|||
|
|
{ /* Don't check if we know there's no para end */
|
|||
|
|
typeFC fcMin = ppcd->fc;
|
|||
|
|
typeFC fc;
|
|||
|
|
|
|||
|
|
if ((fc = FcParaFirst(fn,
|
|||
|
|
fcMin + cpGuess - cpMin, fcMin)) != fcNil)
|
|||
|
|
{ /* Found para begin */
|
|||
|
|
vcpFirstParaCache = cpMin + (fc - fcMin);
|
|||
|
|
break;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
/* Now we know there's no para end from cpMin to cpGuess. */
|
|||
|
|
/* If original piece, may be one after cp */
|
|||
|
|
#ifdef BOGUSBL
|
|||
|
|
/* vfInsertMode protects against a critical section in insert */
|
|||
|
|
/* when the CR is already inserted but the supporting PAP structure */
|
|||
|
|
/* is not in place yet */
|
|||
|
|
|
|||
|
|
if (cp != cpGuess && fn != fnInsert && !vfInsertMode)
|
|||
|
|
#else /* Insert CR works differently now, above test slows us down
|
|||
|
|
by forcing many calls to FcParaLim */
|
|||
|
|
if (cp != cpGuess)
|
|||
|
|
#endif
|
|||
|
|
ppcd->fNoParaLast = true; /* Save some work next time */
|
|||
|
|
if (cpMin == cp0)
|
|||
|
|
{ /* Beginning of doc is beginning of para */
|
|||
|
|
vcpFirstParaCache = cpMinCur;
|
|||
|
|
break;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
/** Some low memory error conditions may cause ppctb to be
|
|||
|
|
messed up **/
|
|||
|
|
if (ppcd == ppctb->rgpcd)
|
|||
|
|
{
|
|||
|
|
Assert(0);
|
|||
|
|
vcpFirstParaCache = cp0; // hope for divine grace
|
|||
|
|
break;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
cpGuess = cpMin;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
vdocParaCache = doc;
|
|||
|
|
/* Now go forward to find the cpLimPara */
|
|||
|
|
cpMac = pdod->cpMac;
|
|||
|
|
cpGuess = cp;
|
|||
|
|
|
|||
|
|
for (ppcd = ppcdBase; ; ++ppcd)
|
|||
|
|
{
|
|||
|
|
typeCP cpMin = ppcd->cpMin;
|
|||
|
|
typeCP cpLim = (ppcd + 1)->cpMin;
|
|||
|
|
typeFC fc;
|
|||
|
|
int fn = ppcd->fn;
|
|||
|
|
|
|||
|
|
if (! ppcd->fNoParaLast)
|
|||
|
|
{ /* Don't check if we know there's no para end */
|
|||
|
|
typeFC fcMin = ppcd->fc;
|
|||
|
|
if ((fc = FcParaLim(fn, fcMin + cpGuess - cpMin,
|
|||
|
|
fcMin + (cpLim - cpMin), &vpapAbs)) != fcNil)
|
|||
|
|
{ /* Found para end */
|
|||
|
|
vcpLimParaCache = cpMin + (fc - fcMin);
|
|||
|
|
/* Under Write, FcParaLim can't set the correct rgtbd */
|
|||
|
|
/* That's because tabs are a DOCUMENT property */
|
|||
|
|
/* We set it here instead */
|
|||
|
|
GetTabsForDoc( doc );
|
|||
|
|
break;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
/* Now we know there's no para end. */
|
|||
|
|
#ifdef BOGUSBL
|
|||
|
|
/* The check for vfInsertMode is necessary because of a critical */
|
|||
|
|
/* section in insertion between the insertion of a CR and the call */
|
|||
|
|
/* to AddRunScratch */
|
|||
|
|
if (cp != cpGuess && fn != fnInsert && !vfInsertMode)
|
|||
|
|
#else /* Insert CR has changed, we no longer try to pretend that
|
|||
|
|
the CR is not in the scratch file piece before the run is
|
|||
|
|
added. This new approach gains us speed, especially during backspace */
|
|||
|
|
if (cp != cpGuess)
|
|||
|
|
#endif
|
|||
|
|
ppcd->fNoParaLast = true; /* Save some work next time */
|
|||
|
|
if (cpLim == cpMac)
|
|||
|
|
{ /* No EOL at end of doc */
|
|||
|
|
vcpLimParaCache = cpMac + ccpEol;
|
|||
|
|
MeltHp();
|
|||
|
|
DefaultPaps( doc );
|
|||
|
|
return;
|
|||
|
|
}
|
|||
|
|
/** Some low memory error conditions may cause ppctb to be
|
|||
|
|
messed up **/
|
|||
|
|
else if ((cpLim > cpMac) || (ppcd == (ppctb->rgpcd + ppctb->ipcdMac - 1)))
|
|||
|
|
{
|
|||
|
|
Assert(0);
|
|||
|
|
vcpLimParaCache = cpMac + ccpEol; // hope for divine grace
|
|||
|
|
MeltHp();
|
|||
|
|
DefaultPaps( doc );
|
|||
|
|
return;
|
|||
|
|
}
|
|||
|
|
cpGuess = cpLim;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
/* Don't bother with properties for buffers */
|
|||
|
|
#ifdef ENABLE /* No buffers or styles in MEMO */
|
|||
|
|
if (dty != dtyBuffer || pdod->docSsht != docNil)
|
|||
|
|
#endif
|
|||
|
|
{
|
|||
|
|
struct PRM prm = ppcd->prm;
|
|||
|
|
if (!bPRMNIL(prm))
|
|||
|
|
DoPrm((struct CHP *) 0, &vpapAbs, prm);
|
|||
|
|
#ifdef STYLES
|
|||
|
|
blt(vpapCache.fStyled ? PpropXlate(doc, &vpapCache, &vpapCache) :
|
|||
|
|
&vpapCache, &vpapAbs, cwPAP);
|
|||
|
|
#endif /* STYLES */
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
/* This little piece of code is necessary to provide compatibility between Word
|
|||
|
|
and Memo documents. It compresses the entire range of line spacing into single
|
|||
|
|
spacing, one and one-half spacing, and double spacing. */
|
|||
|
|
if (vpapAbs.dyaLine <= czaLine)
|
|||
|
|
{
|
|||
|
|
vpapAbs.dyaLine = czaLine;
|
|||
|
|
}
|
|||
|
|
else if (vpapAbs.dyaLine >= 2 * czaLine)
|
|||
|
|
{
|
|||
|
|
vpapAbs.dyaLine = 2 * czaLine;
|
|||
|
|
}
|
|||
|
|
else
|
|||
|
|
{
|
|||
|
|
vpapAbs.dyaLine = (vpapAbs.dyaLine + czaLine / 4) / (czaLine / 2) *
|
|||
|
|
(czaLine / 2);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
MeltHp();
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
|
|||
|
|
|
|||
|
|
|
|||
|
|
DefaultPaps( doc )
|
|||
|
|
int doc;
|
|||
|
|
{
|
|||
|
|
typeCP cpFirstSave, cpLimSave;
|
|||
|
|
struct TBD (**hgtbd)[];
|
|||
|
|
|
|||
|
|
if (vcpFirstParaCache > cpMinCur)
|
|||
|
|
{ /* Get pap from previous paragraph */
|
|||
|
|
cpFirstSave = vcpFirstParaCache;
|
|||
|
|
cpLimSave = vcpLimParaCache;
|
|||
|
|
CachePara(doc, cpFirstSave - 1); /* Recursion should not happen */
|
|||
|
|
vpapAbs.fGraphics = false; /* Don't make last para a picture */
|
|||
|
|
vpapAbs.rhc = 0; /* Don't make last para a running head */
|
|||
|
|
vcpLimParaCache = cpLimSave;
|
|||
|
|
vcpFirstParaCache = cpFirstSave;
|
|||
|
|
return;
|
|||
|
|
}
|
|||
|
|
#ifdef CASHMERE
|
|||
|
|
blt(vppapNormal, &vpapAbs, cwPAPBase+cwTBD);
|
|||
|
|
#else /* For MEMO, the default PAPS have the document's tab table */
|
|||
|
|
blt(vppapNormal, &vpapAbs, cwPAPBase);
|
|||
|
|
GetTabsForDoc( doc );
|
|||
|
|
#endif
|
|||
|
|
|
|||
|
|
#ifdef STYLES
|
|||
|
|
blt(&vpapNormal, &vpapCache, cwPAP);
|
|||
|
|
blt(PpropXlate(doc, &vpapNormal, &vpapStd), &vpapAbs, cwPAP);
|
|||
|
|
#endif
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
|
|||
|
|
|
|||
|
|
|
|||
|
|
GetTabsForDoc( doc )
|
|||
|
|
int doc;
|
|||
|
|
{ /* Get tab table for passed document into vpapAbs.rgtbd */
|
|||
|
|
struct TBD (**hgtbd)[];
|
|||
|
|
|
|||
|
|
hgtbd = (**hpdocdod)[doc].hgtbd;
|
|||
|
|
if (hgtbd==0)
|
|||
|
|
bltc( vpapAbs.rgtbd, 0, cwTBD * itbdMax );
|
|||
|
|
else
|
|||
|
|
blt( *hgtbd, vpapAbs.rgtbd, cwTBD * itbdMax );
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
|
|||
|
|
|
|||
|
|
#ifdef CASHMERE
|
|||
|
|
CacheSect(doc, cp)
|
|||
|
|
int doc;
|
|||
|
|
typeCP cp;
|
|||
|
|
{
|
|||
|
|
struct SETB **hsetb, *psetb;
|
|||
|
|
struct SED *psed;
|
|||
|
|
CHAR *pchFprop;
|
|||
|
|
int cchT;
|
|||
|
|
struct DOD *pdod;
|
|||
|
|
|
|||
|
|
if (doc == vdocSectCache && cp >= vcpFirstSectCache && cp < vcpLimSectCache)
|
|||
|
|
return;
|
|||
|
|
|
|||
|
|
if ( vdocSectCache != doc && cp != cp0 )
|
|||
|
|
CacheSect( doc, cp0 ); /* Changing docs, assure vsepPage is accurate */
|
|||
|
|
|
|||
|
|
vdocSectCache = doc;
|
|||
|
|
visedCache = iNil;
|
|||
|
|
blt(&vsepNormal, &vsepAbs, cwSEP);
|
|||
|
|
|
|||
|
|
if ((hsetb = HsetbGet(doc)) == 0)
|
|||
|
|
{
|
|||
|
|
vcpFirstSectCache = cp0;
|
|||
|
|
vcpLimSectCache = (pdod = &(**hpdocdod)[doc])->cpMac + 1;
|
|||
|
|
blt(&vsepAbs, &vsepPage, cwSEP); /* set up page info */
|
|||
|
|
return;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
psetb = *hsetb;
|
|||
|
|
psed = psetb->rgsed;
|
|||
|
|
|
|||
|
|
FreezeHp();
|
|||
|
|
psed += (visedCache = IcpSearch(cp + 1, psed, cchSED, bcpSED, psetb->csed));
|
|||
|
|
|
|||
|
|
Assert( (visedCache >= 0) && (visedCache < psetb->csed) );
|
|||
|
|
|
|||
|
|
vcpFirstSectCache = (visedCache == 0) ? cp0 : (psed - 1)->cp;
|
|||
|
|
vcpLimSectCache = psed->cp;
|
|||
|
|
|
|||
|
|
if (psed->fc != fcNil)
|
|||
|
|
{
|
|||
|
|
pchFprop = PchFromFc(psed->fn, psed->fc, &cchT);
|
|||
|
|
if (*pchFprop != 0)
|
|||
|
|
bltbyte(pchFprop + 1, &vsepAbs, *pchFprop);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
if (vcpFirstSectCache == cp0)
|
|||
|
|
blt(&vsepAbs, &vsepPage, cwSEP);
|
|||
|
|
else
|
|||
|
|
RecalcSepText(); /* Since this is not the first section of a document,
|
|||
|
|
the margins could be wrong and must be recalculated */
|
|||
|
|
MeltHp();
|
|||
|
|
}
|
|||
|
|
#endif /* CASHMERE */
|
|||
|
|
|
|||
|
|
|
|||
|
|
|
|||
|
|
CacheSect(doc, cp)
|
|||
|
|
int doc;
|
|||
|
|
typeCP cp;
|
|||
|
|
{ /* Get current section properties into vsepAbs; section
|
|||
|
|
limits into vcpFirstSectCache, vcpLimSectCache
|
|||
|
|
MEMO VERSION: one section per document */
|
|||
|
|
struct DOD *pdod;
|
|||
|
|
|
|||
|
|
if (doc == vdocSectCache)
|
|||
|
|
return;
|
|||
|
|
|
|||
|
|
vdocSectCache = doc;
|
|||
|
|
pdod = &(**hpdocdod)[doc];
|
|||
|
|
|
|||
|
|
if ( pdod->hsep )
|
|||
|
|
blt( *pdod->hsep, &vsepAbs, cwSEP );
|
|||
|
|
else
|
|||
|
|
blt( &vsepNormal, &vsepAbs, cwSEP );
|
|||
|
|
|
|||
|
|
vcpFirstSectCache = cp0;
|
|||
|
|
vcpLimSectCache = pdod->cpMac;
|
|||
|
|
blt(&vsepAbs, &vsepPage, cwSEP);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
|
|||
|
|
|
|||
|
|
|
|||
|
|
RecalcSepText()
|
|||
|
|
{
|
|||
|
|
/* calculate value to be changed because of change in page dimensions */
|
|||
|
|
int xaRight, dxaText, cColumns;
|
|||
|
|
int yaBottom, dyaText;
|
|||
|
|
|
|||
|
|
xaRight = vsepPage.xaMac - vsepPage.cColumns * vsepPage.dxaText -
|
|||
|
|
vsepPage.xaLeft - vsepPage.dxaGutter -
|
|||
|
|
(vsepPage.cColumns - 1) * vsepPage.dxaColumns;
|
|||
|
|
dxaText = vdxaPaper - xaRight - vsepPage.xaLeft;
|
|||
|
|
cColumns = vsepAbs.cColumns;
|
|||
|
|
vsepAbs.dxaText = max(dxaMinUseful,
|
|||
|
|
((dxaText-vsepPage.dxaGutter-(cColumns-1)*vsepAbs.dxaColumns)/cColumns));
|
|||
|
|
vsepAbs.xaMac = vdxaPaper;
|
|||
|
|
|
|||
|
|
/* Calculate bottom margin, correct */
|
|||
|
|
yaBottom = vsepPage.yaMac - vsepPage.yaTop - vsepPage.dyaText;
|
|||
|
|
vsepAbs.dyaText = max(dyaMinUseful, vdyaPaper - vsepPage.yaTop - yaBottom);
|
|||
|
|
vsepAbs.yaMac = vdyaPaper;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
|
|||
|
|
|
|||
|
|
|
|||
|
|
InvalidateCaches(doc)
|
|||
|
|
int doc;
|
|||
|
|
{
|
|||
|
|
if (doc == vfli.doc) /* Invalidate current formatted line */
|
|||
|
|
vfli.doc = docNil;
|
|||
|
|
if (doc == vdocExpFetch)
|
|||
|
|
vdocExpFetch = docNil;
|
|||
|
|
if (doc == vdocParaCache)
|
|||
|
|
vdocParaCache = docNil;
|
|||
|
|
if (doc == vdocSectCache)
|
|||
|
|
vdocSectCache = docNil;
|
|||
|
|
|
|||
|
|
/* When the current doc is equal to the cached doc, it is unnecessary */
|
|||
|
|
/* to invalidate the page cache when the vcpMinPageCache is 0 and the */
|
|||
|
|
/* vcpMacPageCache is cpMax, since this indicates that all characters in */
|
|||
|
|
/* the document are on page 1. */
|
|||
|
|
if ((doc == vdocPageCache) &&
|
|||
|
|
(!(vcpMinPageCache == cp0 && vcpMacPageCache == cpMax)))
|
|||
|
|
vdocPageCache = docNil;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
|
|||
|
|
|
|||
|
|
|
|||
|
|
TrashCache()
|
|||
|
|
{ /* Invalidate scrolling cache */
|
|||
|
|
ctrCache = 0;
|
|||
|
|
cpCacheHint = cp0;
|
|||
|
|
itrFirstCache = itrLimCache = 0;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
|
|||
|
|
|
|||
|
|
|
|||
|
|
typeFC FcParaFirst(fn, fc, fcMin)
|
|||
|
|
int fn;
|
|||
|
|
typeFC fc, fcMin;
|
|||
|
|
{ /* Return the fc after the latest para end before fc.
|
|||
|
|
if there is no para end in [fcMin, fc), return fcNil. */
|
|||
|
|
struct FCB *pfcb;
|
|||
|
|
|
|||
|
|
if ((fn == fnInsert) || (fc == fcMin))
|
|||
|
|
return fcNil;
|
|||
|
|
|
|||
|
|
if (fn == fnScratch && fc >= fcMacPapIns)
|
|||
|
|
return (fcMin <= fcMacPapIns) ? fcMacPapIns : fcNil;
|
|||
|
|
|
|||
|
|
pfcb = &(**hpfnfcb)[fn];
|
|||
|
|
if (!pfcb->fFormatted)
|
|||
|
|
{ /* Unformatted file; scan for an EOL */
|
|||
|
|
typePN pn;
|
|||
|
|
typeFC fcFirstPage;
|
|||
|
|
|
|||
|
|
#ifdef p2bSector
|
|||
|
|
fcFirstPage = (fc - 1) & ~(cfcPage - 1);
|
|||
|
|
pn = fcFirstPage / cfcPage;
|
|||
|
|
#else
|
|||
|
|
pn = (fc - 1) / cfcPage;
|
|||
|
|
fcFirstPage = pn * cfcPage;
|
|||
|
|
#endif
|
|||
|
|
|
|||
|
|
while (fc > fcMin)
|
|||
|
|
{
|
|||
|
|
CHAR *pch;
|
|||
|
|
int cchT;
|
|||
|
|
|
|||
|
|
pch = PchGetPn( fn, pn--, &cchT, false ) + (fc - fcFirstPage);
|
|||
|
|
if (fcMin > fcFirstPage)
|
|||
|
|
fcFirstPage = fcMin;
|
|||
|
|
while (fc > fcFirstPage)
|
|||
|
|
{
|
|||
|
|
if (*(--pch) == chEol)
|
|||
|
|
{
|
|||
|
|
return fc;
|
|||
|
|
}
|
|||
|
|
fc--;
|
|||
|
|
}
|
|||
|
|
fcFirstPage -= cfcPage;
|
|||
|
|
}
|
|||
|
|
return fcNil;
|
|||
|
|
}
|
|||
|
|
else
|
|||
|
|
{ /* Formatted file; get info from para run */
|
|||
|
|
struct FKP *pfkp;
|
|||
|
|
typeFC fcFirst, fcLim;
|
|||
|
|
int cchT;
|
|||
|
|
|
|||
|
|
pfkp = (struct FKP *) PchGetPn(fn, fn == fnScratch ?
|
|||
|
|
PnFkpFromFcScr(&vfkpdParaIns, fc) :
|
|||
|
|
pfcb->pnPara + IFromFc(**pfcb->hgfcPap, fc), &cchT, false);
|
|||
|
|
if (vfDiskError)
|
|||
|
|
return fcNil;
|
|||
|
|
BFromFc(pfkp, fc, &fcFirst, &fcLim);
|
|||
|
|
return (fcMin < fcFirst) ? fcFirst : fcNil;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
|
|||
|
|
|
|||
|
|
|
|||
|
|
typeFC FcParaLim(fn, fc, fcMac, ppap)
|
|||
|
|
int fn;
|
|||
|
|
typeFC fc, fcMac;
|
|||
|
|
struct PAP *ppap;
|
|||
|
|
{ /* Return the fc after the first para end after or at fc.
|
|||
|
|
if there is no para end in [fc, fcMac), return fcNil. */
|
|||
|
|
/* Also return paragraph properties in ppap */
|
|||
|
|
struct FCB *pfcb;
|
|||
|
|
|
|||
|
|
/* Start out by feeding caller the normal pap */
|
|||
|
|
#ifdef CASHMERE
|
|||
|
|
blt(vppapNormal, ppap, cwPAPBase + cwTBD);
|
|||
|
|
#else
|
|||
|
|
blt(vppapNormal, ppap, cwPAPBase);
|
|||
|
|
#endif
|
|||
|
|
|
|||
|
|
if ( (fn == fnInsert) || ((fn == fnScratch) && (fc >= fcMacPapIns)) )
|
|||
|
|
return fcNil;
|
|||
|
|
|
|||
|
|
if (!(pfcb = &(**hpfnfcb) [fn])->fFormatted)
|
|||
|
|
{ /* Unformatted file; scan for EOL */
|
|||
|
|
typePN pn;
|
|||
|
|
typeFC fcFirstPage;
|
|||
|
|
|
|||
|
|
#ifdef p2bSector
|
|||
|
|
fcFirstPage = fc & ~(cfcPage - 1);
|
|||
|
|
pn = fcFirstPage / cfcPage;
|
|||
|
|
#else
|
|||
|
|
pn = fc / cfcPage;
|
|||
|
|
fcFirstPage = pn * cfcPage;
|
|||
|
|
#endif
|
|||
|
|
|
|||
|
|
while (fc < fcMac)
|
|||
|
|
{
|
|||
|
|
CHAR *pch;
|
|||
|
|
int cchT;
|
|||
|
|
|
|||
|
|
pch = PchGetPn( fn, pn++, &cchT, false ) + (fc - fcFirstPage);
|
|||
|
|
|
|||
|
|
if ((fcFirstPage += cfcPage) > fcMac)
|
|||
|
|
fcFirstPage = fcMac;
|
|||
|
|
while (fc < fcFirstPage)
|
|||
|
|
{
|
|||
|
|
fc++;
|
|||
|
|
if (*pch++ == chEol)
|
|||
|
|
return fc;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
return fcNil;
|
|||
|
|
}
|
|||
|
|
else
|
|||
|
|
{ /* Formatted file; get info from para run */
|
|||
|
|
struct FKP *pfkp;
|
|||
|
|
struct FPAP *pfpap;
|
|||
|
|
int bfpap;
|
|||
|
|
typeFC fcLim;
|
|||
|
|
int cchT;
|
|||
|
|
|
|||
|
|
pfkp = (struct FKP *) PchGetPn(fn, fn == fnScratch ?
|
|||
|
|
PnFkpFromFcScr(&vfkpdParaIns, fc) :
|
|||
|
|
pfcb->pnPara + IFromFc(**pfcb->hgfcPap, fc), &cchT, false);
|
|||
|
|
if (vfDiskError)
|
|||
|
|
{ /* Recover from severe disk error reading formatting info */
|
|||
|
|
blt(vppapNormal, ppap, cwPAP);
|
|||
|
|
return (fcMac == pfcb->fcMac) ? fcMac : fcNil;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
{ /* In-line, fast substitute for BFromFc */
|
|||
|
|
register struct RUN *prun = (struct RUN *) pfkp->rgb;
|
|||
|
|
|
|||
|
|
while (prun->fcLim <= fc)
|
|||
|
|
prun++;
|
|||
|
|
|
|||
|
|
fcLim = prun->fcLim;
|
|||
|
|
bfpap = prun->b;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
if (fcLim <= fcMac)
|
|||
|
|
{
|
|||
|
|
if (bfpap != bNil)
|
|||
|
|
{ /* Non-standard para */
|
|||
|
|
pfpap = (struct FPAP *) &pfkp->rgb[bfpap];
|
|||
|
|
bltbyte(pfpap->rgchPap, ppap, pfpap->cch);
|
|||
|
|
}
|
|||
|
|
return fcLim;
|
|||
|
|
}
|
|||
|
|
return fcNil;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
|
|||
|
|
/* B F R O M FC */
|
|||
|
|
int BFromFc( pfkp, fc, pfcFirst, pfcLim )
|
|||
|
|
struct FKP *pfkp;
|
|||
|
|
typeFC fc;
|
|||
|
|
typeFC *pfcFirst, *pfcLim;
|
|||
|
|
{ /* Return the base offset & bounds for the first run with fcLim > fc. */
|
|||
|
|
/* Short table, linear search */
|
|||
|
|
register struct RUN *prun = (struct RUN *) pfkp->rgb;
|
|||
|
|
|
|||
|
|
while (prun->fcLim <= fc)
|
|||
|
|
prun++;
|
|||
|
|
|
|||
|
|
*pfcFirst = ((prun == (struct RUN *)pfkp->rgb) ?
|
|||
|
|
pfkp->fcFirst : (prun - 1)->fcLim);
|
|||
|
|
*pfcLim = prun->fcLim;
|
|||
|
|
return prun->b;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
|
|||
|
|
|
|||
|
|
/* I F R O M F C */
|
|||
|
|
int IFromFc(pfcLim, fc)
|
|||
|
|
register typeFC *pfcLim;
|
|||
|
|
typeFC fc;
|
|||
|
|
{ /* Return the index of the first fcLim > fc. */
|
|||
|
|
int ifc = 0;
|
|||
|
|
|
|||
|
|
/* Probably a small table, so linear search? */
|
|||
|
|
while (*pfcLim++ <= fc)
|
|||
|
|
++ifc;
|
|||
|
|
return ifc;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
|
|||
|
|
|
|||
|
|
|
|||
|
|
|
|||
|
|
#ifdef BOGUSBL
|
|||
|
|
/* B F R O M F C */
|
|||
|
|
int BFromFc(pfkp, fc, pfcFirst, pfcLim)
|
|||
|
|
struct FKP *pfkp;
|
|||
|
|
typeFC fc;
|
|||
|
|
typeFC *pfcFirst, *pfcLim;
|
|||
|
|
{ /* Return the base offset & bounds for the first run with fcLim > fc. */
|
|||
|
|
struct RUN *prun, *rgrun;
|
|||
|
|
int ifcMin, ifcLim;
|
|||
|
|
|
|||
|
|
ifcMin = 0;
|
|||
|
|
ifcLim = pfkp->crun;
|
|||
|
|
rgrun = (struct RUN *)pfkp->rgb;
|
|||
|
|
|
|||
|
|
#ifdef INEFFICIENT
|
|||
|
|
ifc = IcpSearch(fc + 1, pfkp->rgb, cchRUN, bfcRUN, pfkp->crun);
|
|||
|
|
#endif
|
|||
|
|
|
|||
|
|
while (ifcMin + 1 < ifcLim)
|
|||
|
|
{
|
|||
|
|
int ifcGuess = (ifcMin + ifcLim - 1) >> 1;
|
|||
|
|
if (rgrun[ifcGuess].fcLim <= fc)
|
|||
|
|
ifcMin = ifcGuess + 1;
|
|||
|
|
else
|
|||
|
|
ifcLim = ifcGuess + 1;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
prun = &rgrun[ifcMin];
|
|||
|
|
*pfcLim = prun->fcLim;
|
|||
|
|
*pfcFirst = (ifcMin == 0 ? pfkp->fcFirst : (prun - 1)->fcLim);
|
|||
|
|
return prun->b;
|
|||
|
|
}
|
|||
|
|
#endif /* BOGUSBL */
|
|||
|
|
|