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.
433 lines
13 KiB
433 lines
13 KiB
/************************************************************/
|
|
/* Windows Write, Copyright 1985-1992 Microsoft Corporation */
|
|
/************************************************************/
|
|
|
|
/* AddPrm.c -- Routines to add prms and sprms to docs */
|
|
#define NOGDICAPMASKS
|
|
#define NOVIRTUALKEYCODES
|
|
#define NOWINMESSAGES
|
|
#define NOWINSTYLES
|
|
#define NOSYSMETRICS
|
|
#define NOMENUS
|
|
#define NOKEYSTATE
|
|
#define NOSYSCOMMANDS
|
|
#define NORASTEROPS
|
|
#define NOSHOWWINDOW
|
|
#define NOSYSMETRICS
|
|
#define NOATOM
|
|
#define NOBITMAP
|
|
#define NOBRUSH
|
|
#define NOPEN
|
|
#define NOCLIPBOARD
|
|
#define NOCOLOR
|
|
#define NOCTLMGR
|
|
#define NOWNDCLASS
|
|
#define NODRAWTEXT
|
|
#define NOFONT
|
|
#define NOGDI
|
|
#define NOHDC
|
|
#define NOMB
|
|
#define NOMENUS
|
|
#define NOMETAFILE
|
|
#define NOMSG
|
|
#define NOTEXTMETRIC
|
|
#define NOSOUND
|
|
#define NOSCROLL
|
|
#define NOCOMM
|
|
/* no everything except MEMMGR */
|
|
#include <windows.h>
|
|
|
|
#include "mw.h"
|
|
#include "cmddefs.h"
|
|
#include "code.h"
|
|
#include "ch.h"
|
|
#include "docdefs.h"
|
|
#include "editdefs.h"
|
|
#include "str.h"
|
|
#include "prmdefs.h"
|
|
#include "propdefs.h"
|
|
#include "filedefs.h"
|
|
#include "stcdefs.h"
|
|
#include "fkpdefs.h"
|
|
#include "macro.h"
|
|
#include "dispdefs.h"
|
|
|
|
/* E X T E R N A L S */
|
|
|
|
extern int docCur;
|
|
extern struct SEL selCur;
|
|
extern struct DOD (**hpdocdod)[];
|
|
extern struct UAB vuab;
|
|
extern int vfSysFull;
|
|
extern CHAR dnsprm[];
|
|
extern struct CHP vchpSel;
|
|
extern typeCP vcpLimParaCache;
|
|
extern typeCP cpMacCur;
|
|
extern typeCP CpLimNoSpaces();
|
|
extern int ferror;
|
|
|
|
/* G L O B A L S */
|
|
|
|
struct FPRM fprmCache = { 0 };
|
|
struct PRM prmCache = {0,0,0,0};
|
|
|
|
|
|
/* A D D O N E S P R M */
|
|
/* applies sprm at psprm to the current selection. Take care of
|
|
undoing, invalidation, special endmark cases, and extension of selection
|
|
to paragraph boundaries */
|
|
void AddOneSprm(psprm, fSetUndo)
|
|
CHAR *psprm;
|
|
int fSetUndo; /* True if we need to set up the undo buffer */
|
|
{
|
|
int cch;
|
|
int fParaSprm = fFalse;
|
|
typeCP cpFirst, cpLim, dcp;
|
|
|
|
if (!FWriteOk( fwcNil ))
|
|
return;
|
|
|
|
if ((dnsprm[*psprm] & ESPRM_sgc) != sgcChar)
|
|
{
|
|
typeCP dcpExtraPara = cp0;
|
|
|
|
cpFirst = CpFirstSty( selCur.cpFirst, styPara );
|
|
CachePara( docCur, CpMax( selCur.cpLim - 1, selCur.cpFirst ) );
|
|
cpLim = vcpLimParaCache;
|
|
|
|
dcp = cpLim - cpFirst;
|
|
|
|
/* Check for para following selection that has no Eol */
|
|
|
|
if (cpLim < cpMacCur)
|
|
{
|
|
/* Note that in this case only, dcp (the # of cp's affected
|
|
by the change) does not equal (cpLim - cpFirst)
|
|
(the # of cp's to which the sprm should apply) */
|
|
CachePara( docCur, cpLim );
|
|
dcpExtraPara = vcpLimParaCache - cpLim;
|
|
}
|
|
|
|
if (cpFirst + dcp + dcpExtraPara > cpMacCur)
|
|
{ /* Last para affected has no Eol -- add one */
|
|
struct SEL selSave;
|
|
|
|
dcp += dcpExtraPara;
|
|
Assert( cpFirst + dcp == cpMacCur + (typeCP) ccpEol);
|
|
|
|
if (fSetUndo)
|
|
{
|
|
SetUndo( uacReplNS, docCur, cpFirst, dcp,
|
|
docNil, cpNil, dcp - ccpEol, 0 );
|
|
fSetUndo = fFalse;
|
|
}
|
|
/* Add an eol. Save the current selection so
|
|
it does not get adjusted */
|
|
selSave = selCur;
|
|
InsertEolInsert(docCur,cpMacCur);
|
|
selCur = selSave;
|
|
}
|
|
}
|
|
else
|
|
{ /* Char sprm -- eliminate trailing spaces from the
|
|
affected region, so we don't underline spaces after words. */
|
|
cpFirst = selCur.cpFirst;
|
|
cpLim = CpLimNoSpaces(selCur.cpFirst, selCur.cpLim);
|
|
dcp = cpLim - cpFirst;
|
|
if (dcp == 0)
|
|
{ /* Doing character looks to the insert point... */
|
|
if (fSetUndo)
|
|
SetUndo(uacReplNS, docCur, cpFirst, cp0,
|
|
docNil, cp0, cp0, 0);
|
|
DoSprm(&vchpSel, 0, *psprm, psprm + 1);
|
|
return;
|
|
}
|
|
}
|
|
|
|
if (fSetUndo)
|
|
SetUndo(uacReplNS, docCur, cpFirst, dcp, docNil, cpNil, dcp, 0);
|
|
|
|
if (ferror) /* not enough memory to store info for undo operation */
|
|
{
|
|
NoUndo();
|
|
return;
|
|
}
|
|
|
|
AddSprmCps(psprm, docCur, cpFirst, cpLim);
|
|
AdjustCp( docCur, cpFirst, dcp, dcp );
|
|
}
|
|
|
|
/* E X P A N D C U R S E L */
|
|
ExpandCurSel(pselSave)
|
|
struct SEL *pselSave;
|
|
{
|
|
*pselSave = selCur;
|
|
|
|
selCur.cpFirst = CpFirstSty(selCur.cpFirst, styPara);
|
|
CachePara(docCur, CpMax(selCur.cpLim - 1, selCur.cpFirst));
|
|
selCur.cpLim = vcpLimParaCache;
|
|
}
|
|
|
|
/* E N D L O O K S E L */
|
|
EndLookSel(pselSave, fPara)
|
|
struct SEL *pselSave; BOOL fPara;
|
|
{
|
|
typeCP cpLim, cpFirst, dcp;
|
|
dcp = (cpLim = selCur.cpLim) - (cpFirst = selCur.cpFirst);
|
|
if (fPara)
|
|
{
|
|
TrashCache();
|
|
if (cpLim <= cpMacCur)
|
|
{
|
|
CachePara(docCur, selCur.cpLim);
|
|
if (vcpLimParaCache > cpMacCur) /* Last (partial) paragraph */
|
|
dcp = cpMacCur - cpFirst + 1;
|
|
}
|
|
}
|
|
AdjustCp(docCur, cpFirst, dcp, dcp);
|
|
|
|
selCur = *pselSave;
|
|
}
|
|
|
|
|
|
|
|
/* A D D S P R M */
|
|
|
|
AddSprm(psprm)
|
|
CHAR *psprm;
|
|
{ /* Add a single property modifier to the pieces contained in selCur. */
|
|
AddSprmCps(psprm, docCur, selCur.cpFirst, selCur.cpLim);
|
|
}
|
|
|
|
|
|
/* A D D S P R M C P S */
|
|
AddSprmCps(char *psprm, int doc, typeCP cpFirst, typeCP cpLim)
|
|
{
|
|
struct PCTB **hpctb;
|
|
int ipcdFirst, ipcdLim, ipcd;
|
|
struct DOD *pdod;
|
|
int cch;
|
|
struct PCD *ppcd;
|
|
|
|
/* First get address of piece table and split off desired pieces. */
|
|
pdod = &(**hpdocdod)[doc];
|
|
hpctb = pdod->hpctb;
|
|
pdod->fFormatted = fTrue;
|
|
ipcdFirst = IpcdSplit(hpctb, cpFirst);
|
|
ipcdLim = IpcdSplit(hpctb, cpLim);
|
|
if (ferror)
|
|
/* Ran out of memory trying to expand piece table */
|
|
return;
|
|
|
|
/* Now just add this sprm to the pieces. */
|
|
FreezeHp();
|
|
for (ipcd = ipcdFirst, ppcd = &(**hpctb).rgpcd[ipcdFirst];
|
|
ipcd < ipcdLim && !vfSysFull; ++ipcd, ++ppcd)
|
|
ppcd->prm = PrmAppend(ppcd->prm, psprm);
|
|
MeltHp();
|
|
}
|
|
|
|
/* P R M A P P E N D */
|
|
|
|
struct PRM PrmAppend(struct PRM prm, CHAR *psprm)
|
|
{ /* Append <sprm, val> to the chain of sprm's in prm. Return new prm. */
|
|
struct FPRM *pfprmOld;
|
|
CHAR *pfsprm;
|
|
CHAR *pfsprmOld;
|
|
int sprm = *psprm;
|
|
int sprmOld;
|
|
register int esprm = dnsprm[sprm];
|
|
register int esprmOld;
|
|
int cchNew = (esprm & ESPRM_cch);
|
|
int cchOld;
|
|
int sgc = (esprm & ESPRM_sgc);
|
|
int spr = (esprm & ESPRM_spr);
|
|
int fSame = (esprm & ESPRM_fSame);
|
|
int fClobber = (esprm & ESPRM_fClobber);
|
|
int dval = 0;
|
|
int cch;
|
|
int cchT;
|
|
typeFC fcPrm;
|
|
|
|
struct FPRM fprm;
|
|
|
|
if (cchNew == 0) cchNew = CchPsprm(psprm);
|
|
|
|
pfsprm = fprm.grpfsprm;
|
|
|
|
if (prm.fComplex)
|
|
{ /* Get the old list of sprm's from scratch file; copy it to fprm. */
|
|
pfprmOld = (struct FPRM *) PchFromFc(fnScratch,
|
|
//(typeFC)(unsigned)(((struct PRMX *) &prm)->bfprm << 1), &cch);
|
|
fcSCRATCHPRM(prm), &cch);
|
|
pfsprmOld = pfprmOld->grpfsprm;
|
|
cchT = cch = pfprmOld->cch;
|
|
while (cchT)
|
|
{ /* Copy grpsprm, removing ones which we will clobber */
|
|
sprmOld = *pfsprmOld;
|
|
esprmOld = dnsprm[sprmOld];
|
|
if ((cchOld = (esprmOld & ESPRM_cch)) == 0)
|
|
cchOld = CchPsprm(pfsprmOld);
|
|
#ifdef DEBUG
|
|
if (cchOld == 0)
|
|
panic();
|
|
#endif
|
|
if (sprmOld == sprm && fSame ||
|
|
(esprmOld & ESPRM_sgc) == sgc &&
|
|
(esprmOld & ESPRM_spr) <= spr && fClobber)
|
|
{
|
|
/* make sure we properly coalesce change
|
|
size prms */
|
|
if (sprm == sprmOld && sprm == sprmCChgHps)
|
|
dval += *(pfsprmOld + 1);
|
|
cch -= cchOld;
|
|
}
|
|
/* CHps overrides CChgHps */
|
|
else if (sprmOld == sprmCChgHps && sprm == sprmCHps)
|
|
{
|
|
cch -= cchOld;
|
|
}
|
|
else
|
|
pfsprm = (CHAR *)bltbyte(pfsprmOld, pfsprm, cchOld);
|
|
pfsprmOld += cchOld;
|
|
cchT -= cchOld;
|
|
}
|
|
}
|
|
else
|
|
{ /* No file entry yet; convert simple prm to fsprm */
|
|
int valOld = prm.val;
|
|
sprmOld = prm.sprm;
|
|
esprmOld = dnsprm[sprmOld];
|
|
|
|
if (bPRMNIL(prm) ||
|
|
sprmOld == sprm && fSame ||
|
|
(esprmOld & ESPRM_sgc) == sgc &&
|
|
(esprmOld & ESPRM_spr) <= spr && fClobber)
|
|
{
|
|
/* make sure we are combinning consecutive sprmCChgHps */
|
|
if (sprm == sprmOld && sprm == sprmCChgHps)
|
|
dval += valOld;
|
|
cch = 0;
|
|
}
|
|
/* CHps overrides CChgHps */
|
|
else if (sprmOld == sprmCChgHps && sprm == sprmCHps)
|
|
{
|
|
cch = 0;
|
|
}
|
|
else
|
|
{ /* Save old sprm */
|
|
*pfsprm++ = sprmOld;
|
|
if ((cch = (esprmOld & ESPRM_cch)) == 2)
|
|
*pfsprm++ = valOld;
|
|
}
|
|
}
|
|
/* we have: cch = length of old prm after removal of clobbered/etc. entries.
|
|
cchNew: length of the entry to be appended.
|
|
dval: correction for 2nd byte of new entry
|
|
pfsprm: where 1st byte of new entry will go
|
|
*/
|
|
bltbyte((CHAR *) psprm, pfsprm, imin(cchNew, cchMaxGrpfsprm - cch));
|
|
*(pfsprm + 1) += dval;
|
|
|
|
if (cch == 0 && cchNew <= 2)
|
|
{ /* Pack sprm and val into a prm word. */
|
|
struct PRM prmT;
|
|
prmT.dummy=0;
|
|
bltbyte(pfsprm, (CHAR *) &prmT, cchNew);
|
|
prmT.fComplex = false;
|
|
prmT.sprm = *pfsprm;
|
|
return (prmT);
|
|
}
|
|
|
|
if ((cch += cchNew) > cchMaxGrpfsprm)
|
|
{
|
|
int fSave = ferror;
|
|
Error(IDPMT2Complex);
|
|
ferror = fSave;
|
|
return (prm);
|
|
}
|
|
if (vfSysFull)
|
|
return prm; /* Assume disk full message already given */
|
|
|
|
fprm.cch = cch;
|
|
|
|
/* Check newly created prm to see if same as previous */
|
|
if (CchDiffer(&fprmCache, &fprm, cch + 1) == 0)
|
|
return prmCache;
|
|
bltbyte(&fprm, &fprmCache, cch + 1);
|
|
|
|
AlignFn(fnScratch, cch = ((cch >> 1) + 1) << 1, fTrue);
|
|
prm.fComplex = fTrue;
|
|
|
|
//((struct PRMX)prm).bfprm = FcWScratch((CHAR *) &fprm, cch) >> 1;
|
|
|
|
fcPrm = FcWScratch((CHAR *) &fprm, cch) >> 1;
|
|
((struct PRMX *)&prm)->bfprm_hi = (fcPrm >> 16) & 0x7F;
|
|
((struct PRMX *)&prm)->bfprm_low = fcPrm & 0xFFFF;
|
|
|
|
prmCache = prm;
|
|
return prm;
|
|
}
|
|
|
|
|
|
/* A P P L Y C L O O K S */
|
|
/* character looks. val is a 1 char value */
|
|
ApplyCLooks(pchp, sprm, val)
|
|
struct CHP *pchp;
|
|
int sprm, val;
|
|
{
|
|
/* Assemble sprm */
|
|
CHAR rgbSprm[1 + cchINT];
|
|
CHAR *pch = &rgbSprm[0];
|
|
*pch++ = sprm;
|
|
*pch = val;
|
|
|
|
if (pchp == 0)
|
|
{
|
|
/* apply looks to current selection */
|
|
AddOneSprm(rgbSprm, fTrue);
|
|
vuab.uac = uacChLook;
|
|
SetUndoMenuStr(IDSTRUndoLook);
|
|
}
|
|
else
|
|
{
|
|
/* apply looks to pchp */
|
|
DoSprm(pchp, 0, sprm, pch);
|
|
}
|
|
}
|
|
|
|
|
|
/* A P P L Y L O O K S P A R A S */
|
|
/* val is a char value */
|
|
ApplyLooksParaS(pchp, sprm, val)
|
|
struct CHP *pchp;
|
|
int sprm, val;
|
|
{
|
|
int valT = 0;
|
|
CHAR *pch = (CHAR *)&valT;
|
|
*pch = val;
|
|
/* all the above is just to prepare bltbyte later gets the right byte order */
|
|
ApplyLooksPara(pchp, sprm, valT);
|
|
}
|
|
|
|
|
|
/* A P P L Y L O O K S P A R A */
|
|
/* val is an integer value. Char val's must have been bltbyte'd into val */
|
|
ApplyLooksPara(pchp, sprm, val)
|
|
struct CHP *pchp;
|
|
int sprm, val;
|
|
{
|
|
|
|
if (FWriteOk(fwcNil)) /* Check for out-of-memory/ read-only */
|
|
{
|
|
CHAR rgbSprm[1 + cchINT];
|
|
CHAR *pch = &rgbSprm[0];
|
|
|
|
*pch++ = sprm;
|
|
bltbyte(&val, pch, cchINT);
|
|
AddOneSprm(rgbSprm, fTrue);
|
|
vuab.uac = uacChLook;
|
|
SetUndoMenuStr(IDSTRUndoLook);
|
|
}
|
|
}
|
|
|