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.
418 lines
10 KiB
418 lines
10 KiB
/************************************************************/
|
|
/* Windows Write, Copyright 1985-1992 Microsoft Corporation */
|
|
/************************************************************/
|
|
|
|
/* doprm.c -- MW Property modifying routines */
|
|
#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 "cmddefs.h"
|
|
#include "filedefs.h"
|
|
#include "propdefs.h"
|
|
#include "prmdefs.h"
|
|
#include "fkpdefs.h"
|
|
#include "docdefs.h"
|
|
#include "macro.h"
|
|
#include "dispdefs.h"
|
|
#include "fontdefs.h"
|
|
|
|
/* E X T E R N A L S */
|
|
extern int rgxaRulerSprm[];
|
|
extern struct PAP *vppapNormal;
|
|
extern struct CHP vchpNormal;
|
|
extern CHAR dnsprm[];
|
|
extern struct CHP vchpNormal;
|
|
extern struct SEP vsepStd;
|
|
extern struct SEP vsepNormal;
|
|
|
|
#ifdef CASHMERE
|
|
extern struct TBD rgtbdRulerSprm[];
|
|
#endif
|
|
|
|
/* List of approved font sizes, in half points */
|
|
#ifdef INTL
|
|
int rghps[csizeApprovedMax] = {8, 12, 16, 20, 24, 28, 36, 48, 60, 72, 96, 144, 254};
|
|
#else
|
|
int rghps[csizeApprovedMax] = {8, 12, 16, 20, 24, 32, 40, 48, 60, 72, 96, 144, 254};
|
|
#endif /* if-else-def INTL */
|
|
|
|
CHAR *PchFromFc();
|
|
|
|
|
|
/* D O P R M */
|
|
DoPrm(struct CHP *pchp, struct PAP *ppap, struct PRM prm)
|
|
{ /* Apply prm to char and para properties */
|
|
if (bPRMNIL(prm))
|
|
return;
|
|
if (((struct PRM *) &prm)->fComplex)
|
|
{
|
|
int cch;
|
|
CHAR *pfsprm;
|
|
struct FPRM *pfprm = (struct FPRM *) PchFromFc(fnScratch,
|
|
fcSCRATCHPRM(prm), &cch);
|
|
|
|
cch = pfprm->cch;
|
|
pfsprm = pfprm->grpfsprm;
|
|
|
|
while (cch > 0)
|
|
{
|
|
int cchT;
|
|
int sprm;
|
|
|
|
DoSprm(pchp, ppap, sprm = *pfsprm, pfsprm + 1);
|
|
if ((cchT = (dnsprm[sprm] & ESPRM_cch)) == 0)
|
|
cchT = CchPsprm(pfsprm);
|
|
cch -= cchT;
|
|
pfsprm += cchT;
|
|
}
|
|
}
|
|
else
|
|
/* Simple prm; single sprm */
|
|
DoSprm(pchp, ppap, ((struct PRM *) &prm)->sprm,
|
|
&((struct PRM *) &prm)->val);
|
|
}
|
|
|
|
/* D O S P R M */
|
|
/* Apply a single property modifier to para/char prop */
|
|
DoSprm(pchp, ppap, sprm, pval)
|
|
struct CHP *pchp;
|
|
struct PAP *ppap;
|
|
int sprm;
|
|
CHAR *pval;
|
|
{
|
|
int *pvalTo;
|
|
int val = *pval;
|
|
|
|
#ifdef DEBUG
|
|
Assert(sprm > 0 && sprm < sprmMax);
|
|
#endif
|
|
if ((dnsprm[sprm] & ESPRM_sgc) != sgcChar)
|
|
{
|
|
if (ppap != 0)
|
|
{
|
|
struct TBD *ptbd;
|
|
int rhc;
|
|
int fGraphics;
|
|
|
|
ppap->fStyled = fFalse;
|
|
switch (sprm)
|
|
{
|
|
case sprmPLMarg:
|
|
pvalTo = &ppap->dxaLeft;
|
|
break;
|
|
case sprmPRMarg:
|
|
pvalTo = &ppap->dxaRight;
|
|
break;
|
|
case sprmPFIndent:
|
|
pvalTo = &ppap->dxaLeft1;
|
|
break;
|
|
case sprmPJc:
|
|
ppap->jc = val;
|
|
return;
|
|
#ifdef CASHMERE
|
|
case sprmPRuler:
|
|
/* Ruler and Ruler1 rely on the fact that rgxaRulerSprm and PAP both
|
|
align R, L, L1 in that order.
|
|
Ruler: apply the current state of the ruler */
|
|
blt(&rgxaRulerSprm[0], &ppap->dxaRight, 3);
|
|
blt(&rgtbdRulerSprm[0], ppap->rgtbd, itbdMax * cwTBD);
|
|
return;
|
|
case sprmPRuler1:
|
|
/* as Ruler, except information is at pval+1 and pval+"7" */
|
|
bltbyte((CHAR *)(pval + 1), &ppap->dxaRight, 3 * cchINT);
|
|
/* append terminating 0 word to tab table */
|
|
bltc(bltbyte((CHAR *)(pval + 1 + (3 * cchINT)), ppap->rgtbd,
|
|
val - (3 * cchINT)), 0, cchINT);
|
|
return;
|
|
case sprmPRgtbd:
|
|
bltc(bltbyte(pval + 1, ppap->rgtbd,
|
|
val), 0, cchINT);
|
|
return;
|
|
case sprmPKeep:
|
|
ppap->fKeep = val;
|
|
return;
|
|
case sprmPKeepFollow:
|
|
ppap->fKeepFollow = val;
|
|
return;
|
|
#endif
|
|
case sprmPDyaLine:
|
|
pvalTo = &ppap->dyaLine;
|
|
break;
|
|
#ifdef CASHMERE
|
|
case sprmPDyaBefore:
|
|
pvalTo = &ppap->dyaBefore;
|
|
break;
|
|
case sprmPDyaAfter:
|
|
pvalTo = &ppap->dyaAfter;
|
|
break;
|
|
#endif
|
|
case sprmPRhc:
|
|
ppap->rhc = val;
|
|
return;
|
|
case sprmPRhcNorm:
|
|
/* (int) dxaLeftAdj + (int) dxaRightAdj */
|
|
Assert(*pval == 4);
|
|
pval++; /* skip over cch */
|
|
ppap->dxaLeft = imax( 0,
|
|
ppap->dxaLeft - *(int *) pval);
|
|
ppap->dxaRight = imax( 0,
|
|
ppap->dxaRight - *((int *) pval + 1));
|
|
return;
|
|
case sprmPNormal:
|
|
rhc = ppap->rhc;
|
|
fGraphics = ppap->fGraphics;
|
|
blt(vppapNormal, ppap, cwPAPBase);
|
|
goto LSame;
|
|
case sprmPSame:
|
|
rhc = ppap->rhc;
|
|
fGraphics = ppap->fGraphics;
|
|
/* note: tab terminating 0 MUST be part of value if tab table is to be changed */
|
|
bltbyte(pval + 1, ppap, val - 1);
|
|
LSame: ppap->rhc = rhc;
|
|
ppap->fGraphics = fGraphics;
|
|
return;
|
|
#ifdef CASHMERE
|
|
case sprmPNest:
|
|
if (ppap->rgtbd[0].dxa != 0 &&
|
|
ppap->rgtbd[0].dxa == ppap->dxaLeft &&
|
|
ppap->rgtbd[1].dxa == 0)
|
|
ppap->rgtbd[0].dxa += dxaNest;
|
|
ppap->dxaLeft += dxaNest;
|
|
return;
|
|
case sprmPUnNest:
|
|
if (ppap->rgtbd[0].dxa != 0 &&
|
|
ppap->rgtbd[0].dxa == ppap->dxaLeft &&
|
|
ppap->rgtbd[1].dxa == 0)
|
|
ppap->rgtbd[0].dxa -= dxaNest;
|
|
ppap->dxaLeft = max(0, (int)(ppap->dxaLeft - dxaNest));
|
|
return;
|
|
case sprmPHang:
|
|
ppap->dxaLeft = umin(ppap->dxaLeft + cxaInch, xaRightMax - cxaInch);
|
|
ppap->dxaLeft1 = -cxaInch;
|
|
ptbd = &ppap->rgtbd[0];
|
|
SetWords(ptbd, 0, cwTBD * 2);
|
|
ptbd->dxa = ppap->dxaLeft;
|
|
/* Inefficient:
|
|
ptbd->tlc = tlcWhite;
|
|
ptbd->jc = jcLeft;
|
|
++ptbd->dxa = 0 */
|
|
return;
|
|
#endif
|
|
default:
|
|
Assert(FALSE);
|
|
return;
|
|
}
|
|
/* common portion for those transferring a single word */
|
|
bltbyte(pval, pvalTo, cchINT);
|
|
}
|
|
return;
|
|
}
|
|
else
|
|
{
|
|
if (pchp != 0)
|
|
{
|
|
int fSpecial;
|
|
int ftc, hps;
|
|
|
|
pchp->fStyled = fFalse;
|
|
switch (sprm)
|
|
{
|
|
/* CHARACTER sprm's */
|
|
case sprmCBold:
|
|
pchp->fBold = val;
|
|
return;
|
|
case sprmCItalic:
|
|
pchp->fItalic = val;
|
|
return;
|
|
case sprmCUline:
|
|
pchp->fUline = val;
|
|
return;
|
|
#ifdef CASHMERE
|
|
case sprmCOutline:
|
|
pchp->fOutline = val;
|
|
return;
|
|
case sprmCShadow:
|
|
pchp->fShadow = val;
|
|
return;
|
|
case sprmCCsm:
|
|
pchp->csm = val;
|
|
return;
|
|
#endif
|
|
case sprmCPos:
|
|
/* If going in or out of sub/superscript, alter font size */
|
|
if (pchp->hpsPos == 0 && val != 0)
|
|
pchp->hps = HpsAlter(pchp->hps, -1);
|
|
else if (pchp->hpsPos != 0 && val == 0)
|
|
pchp->hps = HpsAlter(pchp->hps, 1);
|
|
pchp->hpsPos = val;
|
|
return;
|
|
case sprmCFtc:
|
|
case sprmCChgFtc:
|
|
pchp->ftc = val & 0x003f;
|
|
pchp->ftcXtra = (val & 0x00c0) >> 6;
|
|
return;
|
|
case sprmCHps:
|
|
pchp->hps = val;
|
|
return;
|
|
case sprmCChgHps:
|
|
pchp->hps = HpsAlter(pchp->hps,
|
|
val >= 128 ? val - 256 : val); /* sign extend from char to int */
|
|
return;
|
|
case sprmCSame:
|
|
fSpecial = pchp->fSpecial;
|
|
bltbyte(pval, pchp, cchCHP);
|
|
pchp->fSpecial = fSpecial;
|
|
return;
|
|
case sprmCPlain:
|
|
fSpecial = pchp->fSpecial;
|
|
ftc = FtcFromPchp(pchp);
|
|
hps = pchp->hps;
|
|
/* If we used to be sub/superscript, increase font size */
|
|
if (pchp->hpsPos != 0)
|
|
hps = HpsAlter(hps, 1);
|
|
blt(&vchpNormal, pchp, cwCHP);
|
|
pchp->fSpecial = fSpecial;
|
|
pchp->ftc = ftc & 0x003f;
|
|
pchp->ftcXtra = (ftc & 0x00c0) >> 6;
|
|
pchp->hps = hps;
|
|
return;
|
|
case sprmCMapFtc:
|
|
/* val is ftcMac for mapping */
|
|
/* pval+1 points to ftcMac mapping bytes */
|
|
ftc = pchp->ftc + (pchp->ftcXtra << 6);
|
|
Assert(ftc < val);
|
|
ftc = *(pval + 1 + ftc);
|
|
pchp->ftc = ftc & 0x003f;
|
|
pchp->ftcXtra = (ftc & 0x00c0) >> 6;
|
|
return;
|
|
case sprmCOldFtc:
|
|
ftc = pchp->ftc + (pchp->ftcXtra << 6);
|
|
ftc = FtcMapOldFtc(ftc, pval);
|
|
pchp->ftc = ftc & 0x003f;
|
|
pchp->ftcXtra = (ftc & 0x00c0) >> 6;
|
|
return;
|
|
default:
|
|
Assert(FALSE);
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/* C C H P S P R M */
|
|
/* returns length of sprm's that are of variable or large size.
|
|
(cch = (esprm & ESPRM_cch)) == 0 must be checked before calling.*/
|
|
CchPsprm(psprm)
|
|
CHAR *psprm;
|
|
{
|
|
return (*psprm == sprmCSame ? cchCHP + 1 :
|
|
/* PSame, PRgtbd, PRuler1, CMapFtc, COldFtc: */
|
|
*(psprm + 1) + 2);
|
|
}
|
|
|
|
int HpsAlter(hps, ialter)
|
|
int hps, ialter;
|
|
{ /* Return the hps of the approved font size that is ialter steps
|
|
away from the given size. I.e.: if ialter is -1, then return
|
|
the next smaller size. If alter is 0, return hps. */
|
|
/* return 0 if request exceeds limits (11.15.91) v-dougk */
|
|
int isize;
|
|
|
|
if (ialter == 0)
|
|
return hps;
|
|
|
|
/* Find the size just larger than the given size. */
|
|
if (ialter > 0)
|
|
{
|
|
for (isize = 0; isize < csizeApprovedMax - 1; ++isize)
|
|
if (rghps[isize] > hps) break;
|
|
isize = min(csizeApprovedMax - 1, isize + ialter - 1);
|
|
return max(hps, rghps[isize]);
|
|
}
|
|
else
|
|
{
|
|
for (isize = 0; isize < csizeApprovedMax; ++isize)
|
|
if (rghps[isize] >= hps) break;
|
|
isize = max(0, isize + ialter);
|
|
return min(hps, rghps[isize]);
|
|
}
|
|
}
|
|
|
|
BOOL CanChangeFont(int howmuch)
|
|
{
|
|
extern struct CHP vchpSel;
|
|
extern struct SEL selCur;
|
|
int hps;
|
|
|
|
if (selCur.cpFirst != selCur.cpLim)
|
|
return TRUE;
|
|
|
|
hps = HpsAlter(vchpSel.hps, howmuch);
|
|
return ((hps <= rghps[csizeApprovedMax-1]) &&
|
|
(hps >= rghps[0]));
|
|
}
|
|
|
|
FtcMapOldFtc(ftc, ftctb)
|
|
/* maps an old word font code into one of our selection */
|
|
|
|
int ftc;
|
|
CHAR *ftctb;
|
|
{
|
|
#ifdef WIN30
|
|
int iftc = iftcSwiss; /* Default to SOMEthing! ..pault */
|
|
#else
|
|
int iftc ;
|
|
#endif
|
|
|
|
if (ftc == 8)
|
|
/* helvetica */
|
|
iftc = iftcSwiss;
|
|
else if (ftc < 16)
|
|
iftc = iftcModern;
|
|
else if (ftc < 32)
|
|
iftc = iftcRoman;
|
|
else if (ftc < 40)
|
|
iftc = iftcScript;
|
|
else if (ftc < 48)
|
|
iftc = iftcDecorative;
|
|
Assert(iftc < *ftctb);
|
|
return(*(ftctb + 1 + iftc));
|
|
}
|
|
|