/************************************************************/
/* Windows Write, Copyright 1985-1992 Microsoft Corporation */
/************************************************************/
#define NOCLIPBOARD
#define NOGDICAPMASKS
#define NOCTLMGR
#define NOVIRTUALKEYCODES
#define NOWINMESSAGES
#define NOWINSTYLES
#define NOSYSMETRICS
#define NOMENUS
#define NOSOUND
#define NOCOMM
#define NOPEN
#define NOWNDCLASS
#define NOICON
#define NORASTEROPS
#define NOSHOWWINDOW
#define NOATOM
#define NOKEYSTATE
#define NOSYSCOMMANDS
#define NOBITMAP
#define NOBRUSH
#define NOCOLOR
#define NODRAWTEXT
#define NOMB
#define NOPOINT
#define NOMSG
#include <windows.h>
#include "mw.h"
#include "docdefs.h"
#include "dispdefs.h"
#include "fmtdefs.h"
#include "cmddefs.h"
#include "wwdefs.h"
#include "propdefs.h"
/* Globals used here only */
struct TR { /* Text Row info for CtrBackDyp Cache */
typeCP cp;
int dcpDepend; /* dcpDepend for PREVIOUS edl */
int ichCp;
int dyp;
};
struct TR rgtrCache[ itrMaxCache ];
int wwCache=wwNil;
extern struct PAP vpapAbs;
extern typeCP vcpFirstParaCache;
extern struct WWD *pwwdCur;
extern struct SEL selCur;
extern int docCur;
extern typeCP cpCacheHint;
extern typeCP cpMinCur;
extern typeCP cpMacCur;
extern struct FLI vfli;
extern int wwCur;
extern int ctrCache;
extern int itrFirstCache;
extern int itrLimCache;
extern int vfOutOfMemory;
/* P U T C P I N W W V E R T*/
PutCpInWwVert(cp)
typeCP cp;
{
/* vertical case */
typeCP cpMac;
struct EDL (**hdndl) [] = pwwdCur->hdndl;
int dlMac=pwwdCur->dlMac;
struct EDL *pedl = &(**hdndl) [dlMac - 1];
struct EDL *pedlFirst = &(**hdndl) [0];
if ((pedl->yp > pwwdCur->ypMac) && (pedl > pedlFirst))
/* Partial line at the bottom of the window -- this doesn't count
unless it's all we've got */
{ pedl--; dlMac--; }
if (cp < pwwdCur->cpFirst ||
cp > (cpMac = pedl->cpMin + pedl->dcpMac) ||
(cp == cpMac && !pedl->fIchCpIncr) ||
/* Covers insertion points before pictures reached via curs keys */
(CachePara( docCur, cp ),
(vpapAbs.fGraphics &&
(selCur.cpFirst == selCur.cpLim) &&
(pedlFirst->cpMin == selCur.cpFirst) &&
(pedlFirst->ichCpMin > 0))))
{
DirtyCache(pwwdCur->cpFirst = cp);
pwwdCur->ichCpFirst = 0;
CtrBackDypCtr( 9999, dlMac >> 1 );
}
}
SetCurWwVScrollPos( )
{
typeCP cp;
int dr;
struct EDL (**hdndl)[] = pwwdCur->hdndl;
/* calculate desired elevator position dr */
if ((cp = pwwdCur->cpMac - pwwdCur->cpMin) == (typeCP) 0)
dr = 0;
else
{
typeCP CpWinGraphic();
typeCP cpWinFirst = ((**hdndl) [0].fGraphics && !pwwdCur->fDirty) ?
CpWinGraphic( pwwdCur ) : pwwdCur->cpFirst;
dr = min(drMax - 1,
(int)(((cpWinFirst - pwwdCur->cpMin) * (drMax - 1) + (cp >> 1)) / cp));
}
/* Contemplating this 'if' statement should elevate one to a higher plane
of existence. */
if (dr != pwwdCur->drElevator)
/* reset the value of the vertical scroll bar */
SetScrollPos( pwwdCur->hVScrBar,
pwwdCur->sbVbar,
pwwdCur->drElevator = dr,
TRUE);
}
/* A D J W W V E R T */
/* Scroll a window down vertically so that UpdateWw can re-use the text
that is still visible. Otherwise, UpdateWw would write over the very
lines it will need later on near the bottom of the window.
*/
AdjWwVert(cdl, dyp)
int cdl;
{
#if defined(JAPAN) & defined(DBCS_IME)
extern void IMEManage( );
#endif
struct EDL *pedl;
int dl;
if (cdl == 0) return;
cdl = umin( cdl, pwwdCur->dlMac ); /* ! don't let it run off the end */
Assert( dyp > 0 );
ClearInsertLine();
DypScroll(wwCur, 0, cdl, pwwdCur->ypMin + dyp);
/* invalidate the first cdl dl's */
pedl = &(**(pwwdCur->hdndl))[0];
for (dl = 0; dl < cdl; dl++)
(pedl++)->fValid = FALSE;
pwwdCur->fDirty = fTrue;
#if defined(JAPAN) & defined(DBCS_IME)
IMEManage( FALSE );
#endif
}
ScrollDownCtr(ddr)
int ddr;
{ /* Scroll down in the document by ddr text lines (but < 1 screenful) */
struct EDL *pedl;
UpdateWw(wwCur, FALSE); /* Dl's must be correct */
ddr = min(ddr, max(1, pwwdCur->dlMac - 1));
pedl = &(**(pwwdCur->hdndl))[ddr - 1]; /* pedl is first line above new screen */
while (ddr > 0 && pedl->cpMin + pedl->dcpMac > cpMacCur)
{ /* Don't scroll the endmark off the screen */
--pedl;
--ddr;
}
/* Change the cpFirst of the window and dirty it */
if (ddr > 0)
{
struct TR tr;
int dcpDepend;
if (wwCur != wwCache)
{ /* If window has changed, invalidate cache here
so cp's cached below will be used */
TrashCacheS();
wwCache = wwCur;
}
HideSel(); /* Don't scroll selection if machine can't handle it */
ClearInsertLine();
pwwdCur->cpFirst = pedl->cpMin + pedl->dcpMac;
pwwdCur->ichCpFirst = pedl->fIchCpIncr ? pedl->ichCpMin + 1 : 0;
pwwdCur->dcpDepend = pedl->dcpDepend; /* Remember hot spot */
/* Make tr cache entries for the disappearing lines */
pedl = &(**(pwwdCur->hdndl))[0];
if (ctrCache == 0) /* We don't have top line yet */
{
tr.cp = pedl->cpMin;
tr.ichCp = pedl->ichCpMin;
tr.dyp = pedl->dyp;
tr.dcpDepend = pwwdCur->dcpDepend;
AppendCachePtr( &tr );
}
while ( ddr-- )
{
tr.cp = pedl->cpMin + pedl->dcpMac;
tr.ichCp = pedl->fIchCpIncr ? pedl->ichCpMin + 1 : 0;
tr.dcpDepend = pedl->dcpDepend;
tr.dyp = (++pedl)->dyp;
AppendCachePtr( &tr );
}
pwwdCur->fDirty = true;
SetCurWwVScrollPos();
CheckMode();
}
else
{
_beep();
}
}
ScrollUpDypWw()
{ /* Scroll up in the document by one screenfull less 1 line */
int dypKeep=8;
struct EDL *pedl = &(**pwwdCur->hdndl) [0];
if (pedl->fValid)
{
dypKeep = pedl->dyp;
}
if (CtrBackDypCtr( pwwdCur->ypMac - pwwdCur->ypMin - dypKeep,9999 ) == 0)
{
_beep();
}
else
CheckMode();
}
ScrollUpCtr( ctr )
int ctr;
{ /* Scroll Up ctr text rows in the doc (scroll window down) */
if (CtrBackDypCtr( 9999, ctr ) == 0)
{
_beep();
}
else
CheckMode();
}
int CtrBackDypCtr( dypLim, ctrLim )
int dypLim;
int ctrLim;
{ /* Set pwwdCur->cpFirst to the cpFirst of the text line
dypLim pixels or ctrLim text rows before the value of
pwwdCur->cpFirst, whichever limit is reached first.
Adjust the position of the vert scroll bar according to the new cpFirst.
Return the number of text rows (tr) we went back. */
int fAdj = ( (pwwdCur->cpFirst == (**(pwwdCur->hdndl))[0].cpMin) ||
!(**(pwwdCur->hdndl))[0].fValid );
typeCP cpFirst = pwwdCur->cpFirst;
int ichCpFirst = pwwdCur->ichCpFirst;
int ctrGrant = 0; /* ctr we've backed over so far */
int dypGrant = 0; /* dyp we've backed over so far */
int ichFake = 0;
pwwdCur->fCpBad = false; /* Reset hot spot warning */
pwwdCur->fDirty = true;
/* Cache is only valid for one ww -- invalidate if ww has changed */
if (wwCur != wwCache)
{
TrashCacheS();
wwCache = wwCur;
}
if (ctrCache == 0)
/* Don't have cache entry for first line in Ww -- force formatting
THROUGH first line of Ww instead of TO it. */
++ichFake;
for ( ;; )
{
/* If there is no info in the cache, must replenish it. */
if (ctrCache <= 1) /* <=: also replenish if 1st line of Ww is only entry */
{
typeCP cpStart; /* cp to start formatting from */
int dcpDepend; /* Dependency of line containing cpStart */
typeCP cp;
int ichCp;
int itrTempCacheLim = 0;
struct TR rgtrTempCache[ itrMaxCache ];
int fTempCacheOverflow = false;
if ((cpFirst <= cpMinCur) && (ichCpFirst == 0))
{ /* Reached top of document */
if (fAdj)
AdjWwVert( ctrGrant, dypGrant );
pwwdCur->cpFirst = cpMinCur;
pwwdCur->ichCpFirst = 0;
pwwdCur->dcpDepend = 0;
goto SetScroll;
}
/* Want to go back BEFORE the earliest point we have in the cache */
if (ichFake > 0)
/* Force formatting THROUGH { cpFirst, ichCpFirst }
instead of TO */
--ichFake;
else if (ichCpFirst > 0)
--ichCpFirst;
else
--cpFirst;
cpStart = CpHintCache( cpFirst );
if ( ( CachePara( docCur, cpFirst ), vcpFirstParaCache ) >= cpStart )
{
cpStart = vcpFirstParaCache;
dcpDepend = 0; /* At para start; we know dependency is 0 */
}
else
dcpDepend = cpMaxTl; /* real value unknown; use max */
/* Add TR info for lines from { cpStart, 0 } THROUGH
{ cpFirst, ichCpFirst } to temporary cache */
for ( cp = cpStart, ichCp = 0;
(cp < cpFirst) || ((cp == cpFirst) && (ichCp <= ichCpFirst)); )
{
struct TR *ptr;
if (itrTempCacheLim == itrMaxCache)
{ /* Overflowed the temp cache */
fTempCacheOverflow = fTrue;
itrTempCacheLim = 0;
}
/* Add one tr to the cache */
FormatLine( docCur, cp, ichCp, cpMacCur, flmSandMode );
if (vfOutOfMemory)
return ctrGrant;
ptr = &rgtrTempCache[ itrTempCacheLim++ ];
ptr->cp = cp;
ptr->ichCp = ichCp;
ptr->dyp = vfli.dypLine;
ptr->dcpDepend = dcpDepend; /* Save dcpDepend for prev line */
dcpDepend = vfli.dcpDepend;
/* Continue with next line */
cp = vfli.cpMac;
ichCp = vfli.ichCpMac;
} /* end for */
/* Add our temporary cache in front of the real one */
PrependCacheRgtr( rgtrTempCache, itrTempCacheLim );
if (fTempCacheOverflow)
/* We wrapped around the end of the temp cache; include the
rest of the circle */
PrependCacheRgtr( &rgtrTempCache[ itrTempCacheLim ],
itrMaxCache - itrTempCacheLim );
} /* end for */
/* Walk backward in the cache, eliminating entries,
until: (1) We have run through enough yp's or tr's (return) OR
(2) We have exhausted the cache (loop back to refill it)
NOTE: Case 2 catches the case when we hit the beginning of the doc */
Assert( ctrCache >= 1 );
Assert( itrLimCache > 0 );
for ( ;; )
{
struct TR *ptr = &rgtrCache[ itrLimCache - 1 ];
if (ctrCache == 1)
{ /* Only one thing left in cache: the 1st line of the Ww */
cpFirst = ptr->cp;
ichCpFirst = ptr->ichCp;
break; /* Exhausted cache; loop back to refill it */
}
if ( (dypGrant >= dypLim) || (ctrGrant >= ctrLim) )
{ /* Passed through enough yp's or tr's -- we're done */
if (fAdj)
AdjWwVert( ctrGrant, dypGrant );
pwwdCur->cpFirst = ptr->cp;
pwwdCur->ichCpFirst = ptr->ichCp;
pwwdCur->dcpDepend = ptr->dcpDepend;
goto SetScroll;
}
/* Remove end entry from the cache */
if (--itrLimCache <= 0)
itrLimCache = itrMaxCache;
ctrCache--;
/* Update ctrGrant, dypGrant -- we've granted 1 line of scrollback */
ctrGrant++;
dypGrant += rgtrCache [itrLimCache - 1].dyp;
} /* end for */
Assert( ctrCache == 1 );
} /* end for */
SetScroll: /* All done; set vert scroll bar according to new cpFirstWw */
SetCurWwVScrollPos();
return ctrGrant;
}
/* A P P E N D C A C H E P T R */
AppendCachePtr( ptr )
struct TR *ptr;
{ /* Say we are scrolling up a line, append *ptr to tr cache */
if (++ctrCache > itrMaxCache)
{ /* Have to push one off the top */
if (++itrFirstCache == itrMaxCache)
itrFirstCache = 0;
--ctrCache;
}
/* Now add one onto the end */
if (itrLimCache++ == itrMaxCache)
itrLimCache = 1;
rgtrCache[ itrLimCache - 1 ] = *ptr;
}
/* P R E P E N D C A C H E R G T R */
PrependCacheRgtr( rgtr, ctr )
struct TR rgtr[];
int ctr;
{ /* PREPEND one or more lines JUST BEFORE the ones in the cache */
/* The tr cache is a ring buffer. rgtrCache[ itrLimCache - 1 ] is the
tr entry describing the cpFirst of wwCur; rgtrCache[ itrFirstCache ]
is the tr for the earliest line we know of. All between are
contiguous. ctrCache is the number of tr's we have cached. */
struct TR *ptr = &rgtr[ ctr ];
ctrCache += (ctr = min(ctr, itrMaxCache - ctrCache));
/* Compensate for state introduced by TrashCache -- itrLimCache == 0 */
if (itrLimCache == 0)
itrLimCache = itrMaxCache;
while (ctr-- != 0)
{ /* Now add each tr */
if (itrFirstCache-- == 0)
itrFirstCache = itrMaxCache - 1;
rgtrCache[ itrFirstCache ] = *(--ptr);
}
}
/* T R A S H C A C H E s */
TrashCacheS()
{ /* Invalidate scrolling cache */
ctrCache = 0;
cpCacheHint = cp0;
itrFirstCache = itrLimCache = 0;
}
/* C P H I N T C A C H E */
typeCP CpHintCache(cp)
typeCP cp;
{ /* Give the latest cp <= arg cp that begins a line */
return (cpCacheHint <= cp) ? cpCacheHint : cpMinCur;
}
DirtyCache(cp)
typeCP cp;
{ /* Invalidate cache beyond cp */
while (ctrCache-- > 1)
{
typeCP cpT = rgtrCache[itrLimCache - 1].cp;
if (--itrLimCache == 0)
itrLimCache = itrMaxCache;
if (cpT < cp)
{ /* Found our hint; dirty one extra line for word wrap */
cpCacheHint = rgtrCache [itrLimCache - 1].cp;
itrLimCache = itrFirstCache;
ctrCache = 0;
return;
}
}
TrashCacheS();
}
