able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/base/mvdm/wow16/write/select.c

807 lines
22 KiB
C
Raw Normal View History

Add source files
2020-09-26 03:20:57 -05:00
/************************************************************/
/* Windows Write, Copyright 1985-1992 Microsoft Corporation */
/************************************************************/
/* select.c -- MW selection routines */
#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 "toolbox.h"
#include "docdefs.h"
#include "editdefs.h"
#include "dispdefs.h"
#include "cmddefs.h"
#include "wwdefs.h"
#include "ch.h"
#include "fmtdefs.h"
#include "propdefs.h"
#ifdef DBCS
#include "DBCS.h"
#endif
extern int vfSeeSel;
extern typeCP vcpFirstParaCache;
extern typeCP vcpLimParaCache;
extern typeCP vcpFetch;
extern CHAR *vpchFetch;
extern int vccpFetch;
extern typeCP cpMinCur;
extern typeCP cpMacCur;
extern struct SEL selCur;
extern int docCur;
extern struct FLI vfli;
extern struct WWD rgwwd[];
extern int vfSelHidden;
extern int wwCur;
extern struct CHP vchpFetch;
extern struct PAP vpapAbs;
extern struct WWD *pwwdCur;
extern int vfInsEnd;
extern typeCP CpBeginLine();
extern int vfPictSel;
extern int vfSizeMode;
extern struct CHP vchpNormal;
extern int vfInsertOn;
extern struct CHP vchpSel; /* Holds the props when the selection
is an insert point */
extern int vfMakeInsEnd;
extern typeCP vcpSelect;
extern int vfSelAtPara;
/* true iff the last selection was made by an Up/Down cursor key */
extern int vfLastCursor;
extern int vfDidSearch;
extern typeCP cpWall;
/* C P L I M S T Y */
typeCP CpLimSty(cp, sty)
typeCP cp;
int sty;
{ /* Return the first cp which is not part of the same sty unit */
typeCP CpLastStyChar(), CpLimStySpecial();
int wb, ch, ich;
struct EDL *pedl;
if (cp >= cpMacCur)
{ /* Endmark is own unit */
return cpMacCur;
}
if (cp < cpMinCur)
cp = cpMinCur;
switch (sty)
{
int dl;
default:
Assert( FALSE );
case styNil:
return cp;
case styPara:
CachePara(docCur, cp);
if (vcpLimParaCache > cpMacCur)
{ /* No EOL at end of doc */
return cpMacCur;
}
return vcpLimParaCache;
case styChar:
/* Because CpLastStyChar() could be returning cpMacCur already. */
cp = CpLastStyChar( cp ) + 1;
return ((cp <= cpMacCur) ? cp : cpMacCur);
#ifdef BOGUS
/* This portion never gets executed... Why is it in here! */
CachePara(docCur, cp);
if (vpapAbs.fGraphics /* && cp > vcpFirstParaCache */)
return vcpLimParaCache;
#ifdef CRLF
FetchCp(docCur, cp, 0, fcmChars + fcmNoExpand);
return *vpchFetch == chReturn ? cp + 2 : cp + 1;
#else /* not CRLF */
return cp + 1;
#endif
#endif
case styLine:
CpBeginLine(&dl, cp); /* Scrolls cp vertically into view */
pedl = &(**wwdCurrentDoc.hdndl) [dl];
return CpMin(pedl->cpMin + pedl->dcpMac, cpMacCur);
case styDoc:
return cpMacCur;
case styWord:
case stySent:
#ifdef DBCS
return CpLimStySpecial( CpFirstSty(cp, styChar), sty );
#else
return CpLimStySpecial( cp, sty );
#endif /* DBCS */
}
Assert( FALSE );
}
typeCP CpLastStyChar( cp )
typeCP cp;
{ /* Return the last cp of the styChar containing cp */
/* This will be == cp except for pictures & CR-LF */
/* And the second byte of DBCS char's. */
#ifdef DBCS
typeCP CpFirstSty();
CHAR chRetained;
#endif
if (cp >= cpMacCur)
/* Endmark is own unit */
return cpMacCur;
if (cp < cpMinCur)
cp = cpMinCur;
/* Check for picture */
CachePara(docCur, cp);
if (vpapAbs.fGraphics)
return vcpLimParaCache-1;
/* Check for CR-LF */
/* This checking for CR-LF first based on the carriage return */
/* works only becasue the chReturn is outside of the DBCS */
/* range. */
#ifdef CRLF
FetchCp(docCur, cp, 0, fcmChars + fcmNoExpand);
#ifdef DBCS
if ((chRetained = *vpchFetch) == chReturn) {
return cp + 1;
}
else {
if (CpFirstSty(cp, styChar) != cp) {
return cp; /* cp is pointing to the second byte of DBCS. */
}
else {
/* First byte of DBCS or a regular ASCII char. */
return (IsDBCSLeadByte(chRetained) ? cp + 1 : cp);
}
}
#else
return *vpchFetch == chReturn ? cp + 1 : cp;
#endif /* DBCS */
#else
return cp;
#endif
}
/* C P F I R S T S T Y */
typeCP CpFirstSty(cp, sty)
typeCP cp;
int sty;
{ /* Return the first cp of this sty unit. */
typeCP CpFirstStySpecial();
typeCP cpBegin;
int wb, ch, dcpChunk;
typeCP cpSent;
CHAR rgch[dcpAvgSent];
int ich;
typeCP cpT;
if (cp <= cpMinCur)
return cpMinCur;
else if (cp >= cpMacCur)
switch(sty)
{
case styNil:
case styChar:
return cpMacCur; /* Endmark is own unit */
default:
break;
}
CachePara( docCur, cp );
switch (sty)
{
default:
Assert( FALSE );
case styNil:
return cp;
case styPara:
return vcpFirstParaCache;
case styChar:
if (vpapAbs.fGraphics)
return vcpFirstParaCache;
#ifdef CRLF
{
typeCP cpCheckReturn;
typeCP cpMinScan;
cpCheckReturn = CpMax( cp, (typeCP) 1) - 1;
#ifdef DBCS
/* Save vcpFirstParaCache, because it could be changed
by FetchCp() */
cpMinScan = vcpFirstParaCache;
#endif /* DBCS */
FetchCp( docCur, cpCheckReturn, 0, fcmChars + fcmNoExpand );
#ifdef DBCS
/* This works because chReturn is outside of DBCS range. */
if (*vpchFetch == chReturn) {
return cpCheckReturn;
}
else {
typeCP cpT;
typeCP cpRgMin;
int ichMacRgch;
BOOL fBreakFound;
int fkCur;
cpT = cp;
do {
cpRgMin = CpMax( cpT - dcpAvgSent, cpMinScan);
FetchRgch(&ichMacRgch, rgch, docCur, cpRgMin, cpT,
dcpAvgSent);
ich = ichMacRgch - 1;
fBreakFound = FALSE;
while (ich >= 0 && !fBreakFound) {
if (!IsDBCSLeadByte(rgch[ich])) {
fBreakFound = TRUE;
}
else {
ich--;
}
}
cpT = cpRgMin;
} while (!fBreakFound && cpRgMin > cpMinScan);
if (fBreakFound) {
ich++;
}
else {
ich = 0;
}
fkCur = fkNonDBCS;
cpT = cpRgMin + ichMacRgch;
do {
while (ich < ichMacRgch) {
if (fkCur == fkDBCS1) {
/* Last rgch[] ended with the first byte
of a DBCS character. */
fkCur = fkNonDBCS;
}
else if (IsDBCSLeadByte(rgch[ich])) {
if (ich + 1 < ichMacRgch) {
fkCur = fkNonDBCS;
ich++;
}
else {
fkCur = fkDBCS1;
}
}
else {
fkCur = fkNonDBCS;
}
ich++;
}
cpRgMin = cpT;
cpT += dcpAvgSent;
if (cpT <= cp) { /* Saves some time. */
FetchRgch(&ichMacRgch, rgch, docCur, cpRgMin, cpT,
dcpAvgSent);
ich = 0;
}
} while (cpT <= cp);
if (fkCur == fkDBCS1) {
Assert(cp - 1 <= cpMacCur);
return (cp - 1);
}
else {
Assert(cp <= cpMacCur);
return (cp);
}
}
#else
return *vpchFetch == chReturn ? cpCheckReturn : cp;
#endif /* DBCS */
}
#else
return cp;
#endif
case styDoc:
return cpMinCur;
case styLine:
{
int dlJunk;
return CpBeginLine( &dlJunk, cp );
}
case styWord:
case stySent:
#ifdef DBCS
return CpFirstStySpecial( CpFirstSty(cp, styChar), sty );
#else
return CpFirstStySpecial( cp, sty );
#endif /* DBCS */
}
Assert( FALSE );
}
/* S E L E C T */
/* used to make a selection from a cp-interval, for example after a find. */
Select(cpFirst, cpLim)
typeCP cpFirst, cpLim;
{ /* Make a selection */
typeCP cpFirstOld = selCur.cpFirst;
typeCP cpLimOld = selCur.cpLim;
int fOldCursorLine;
if (cpFirst > cpLim)
/* The only time this condition should be true is when we have
run out of memory. The following is a senario where
such is the case (and actually, the reason for this code change).
Let us suppose that we have cut, pasted to the end of the
document, and are now executing a "command a" (repeat last
operation). The procedure CmdAgain is invoked. CmdAgain first
calls replace in order to add the text to the document. Now it
must position the cursor properly by calling select.
A SetUndo operation called by the prior paste gave us the
number of bytes that were added to the document. In its call
to Select, CmdAgain assumes that where it wants to position the
cursor is at the old last char position plus the SetUndo quantity
mentioned above. But, if the replace operation failed (due to
lack of memory), CmdAgain may be trying to place the cursor beyond
the physical end of the document.
Other fixes of this problem, at the caller level (CmdAgain)
instead of within Select, are probably "better" in the sense of
programming clarity. The chosen solution has the one advantage
of programming expediency. */
cpFirst = cpLim;
/* This statement replaces "Assert(cpFirst <= cpLim);" */
vfInsEnd = fFalse;
/* notation: + add highlight
- remove highlight
.. leave alone
00 common portion
*/
if (!vfSelHidden)
{
if (cpFirst < cpFirstOld)
{ /* +++... */
if (cpLim <= cpFirstOld)
{ /* +++ --- */
goto SeparateSels;
}
else
{ /* +++000... */
ToggleSel(cpFirst, cpFirstOld, true);
if (cpLim < cpLimOld)
{ /* +++000--- */
ToggleSel(cpLim, cpLimOld, false);
}
else if (cpLim > cpLimOld)
{ /* +++000+++ */
ToggleSel(cpLimOld, cpLim, true);
}
/* Handle the case when old selection was an insert bar */
if (cpFirstOld == cpLimOld)
ToggleSel(cpFirstOld, cpLimOld, false);
}
}
else
{ /* ---... */
if (cpLimOld <= cpFirst)
{ /* --- +++ */
SeparateSels:
fOldCursorLine = cpFirstOld == cpLimOld;
/* prevent flashing if insert point which is ON is repeatedly selected */
/* conditions are: not repeated, not insert point, not ON, not at desired end of line */
vfInsEnd = vfMakeInsEnd;
if ( cpFirst != cpFirstOld || cpLim != cpLimOld ||
!fOldCursorLine || !vfInsertOn ||
selCur.fEndOfLine != vfMakeInsEnd)
{
selCur.fEndOfLine = vfMakeInsEnd;
if (fOldCursorLine)
ClearInsertLine();
/* old selection is off if it was a cursor line */
ToggleSel(cpFirst, cpLim, fTrue);
/* otherwise the old selection is turned off AFTER the new one is made to
make it look faster */
if (!fOldCursorLine)
ToggleSel(cpFirstOld, cpLimOld, fFalse);
}
}
else
{ /* ---000... */
if (cpLimOld < cpLim)
{ /* ---000+++ */
ToggleSel(cpLimOld, cpLim, true);
}
else if (cpLimOld > cpLim)
{ /* ---000--- */
ToggleSel(cpLim, cpLimOld, false);
}
ToggleSel(cpFirstOld, cpFirst, false);
}
}
}
selCur.cpFirst = cpFirst;
selCur.cpLim = cpLim;
selCur.fForward = cpFirst != cpMacCur;
if (cpFirst == cpLim)
{
GetInsPtProps(cpFirst);
vfDidSearch = FALSE; /* reestablish for searching */
cpWall = cpLim;
}
vfLastCursor = vfSizeMode = vfPictSel = vfMakeInsEnd = false;
/* Set vfPictSel iff the selection is exactly one picture */
CachePara( docCur, selCur.cpFirst );
if (vpapAbs.fGraphics && selCur.cpLim == vcpLimParaCache)
vfPictSel = TRUE;
}
/* G E T I N S P T P R O P S */
GetInsPtProps(cp)
typeCP cp;
{ /* determine properties of the insertion point */
if (cpMacCur != cpMinCur)
{
CachePara(docCur, cp);
if (vcpFirstParaCache == cpMacCur)
{
/* cp is in the last para--use preceding para props */
CachePara(docCur, vcpFirstParaCache - 1);
if (vpapAbs.fGraphics)
{ /* Yet another 10 point kludge -- get default props
when typing after a picture at doc end */
goto Default;
}
}
if (vpapAbs.fGraphics)
/* 10 point kludge: make typing before picture non-vchpNormal */
goto Default;
FetchCp(docCur, CpMax(vcpFirstParaCache, cp - 1), 0, fcmProps);
blt(&vchpFetch, &vchpSel, cwCHP);
if (vchpFetch.fSpecial && vchpFetch.hpsPos != 0)
{ /* if this char is a footnote or page marker, then ignore */
vchpSel.hpsPos = 0; /* super/subscript stuff. */
vchpSel.hps = HpsAlter(vchpSel.hps, 1);
}
vchpSel.fSpecial = FALSE;
}
else
{
Default:
/* force default character properties, font size to be 10 point */
blt(&vchpNormal, &vchpSel, cwCHP);
vchpSel.hps = hpsDefault;
}
}
/* C H A N G E S E L */
ChangeSel(cp, sty)
typeCP cp;
int sty;
{ /* Make selCur move, expand or contract to cp */
/* sty is unit to keep in case of movement or flipped selection */
/* styChar is not supported; it is munged to styNil */
/* This is because the Write/Word user interface never asks us to */
/* pivot the selection around a single character, we pivot around */
/* an insertion point ("styNil") instead */
int fNullSelection = (selCur.cpFirst == selCur.cpLim);
typeCP cpFirst = selCur.cpFirst;
typeCP cpLim = selCur.cpLim;
int fForward = selCur.fForward;
typeCP cpOffFirst, cpOffLim, cpOnFirst, cpOnLim;
if (sty == styChar)
sty = styNil;
if (cp == cpMinCur - 1 || cp > cpMacCur)
{ /* Trying to flip off the beginning or end */
_beep();
return;
}
cpOffFirst = cpOffLim = cpOnFirst = cpOnLim = cpNil;
if (cp <= cpFirst)
{ /* Extend backwards */
if (cp == cpLim)
return;
if (fForward && !fNullSelection)
{ /* Selection flipped */
if (vfPictSel)
/* stuck this in to 'correct' behaviour when select pict and
drag up. Don't want to unselect first pict (4.22.91) v-dougk */
{
cpOnFirst = CpFirstSty( cp, sty);
cpOffFirst = cpOffLim = cpLim;
}
else
{
cpOffFirst = selCur.cpLim = CpMin(cpLim, CpLimSty(cpFirst, sty));
cpOnFirst = CpFirstSty( cp, sty);
cpOffLim = cpLim;
}
}
else
{
if ( fNullSelection )
cpOffLim = cpOffFirst = selCur.cpFirst;
cpOnFirst = CpFirstSty( cp, styChar );
if (cpFirst == cpOnFirst)
return;
}
selCur.fForward = false;
cpOnLim = cpFirst;
selCur.cpFirst = cpOnFirst;
}
else if (cp >= cpLim)
{ /* Extend forwards */
if (cp == cpFirst)
return;
if (!fForward && !fNullSelection)
{ /* Selection flipped */
cpOffLim = selCur.cpFirst =
CpMax( cpFirst, CpFirstSty( (sty ==styNil) ? cpLim : cpLim-1,
sty ));
cpOnLim = CpLimSty(cp, sty);
cpOffFirst = cpFirst;
}
else
{
if ( fNullSelection )
cpOffLim = cpOffFirst = selCur.cpFirst;
cpOnLim = cp;
if (cpLim == cpOnLim)
return;
}
selCur.fForward = true;
cpOnFirst = cpLim;
selCur.cpLim = cpOnLim;
if (cpOnLim == cpLim && cpOffLim != cpLim)
cpOnLim = cpNil;
}
else if (fForward)
{ /* Shrink a forward selection */
cpOffFirst = cp;
if (selCur.cpLim == cpOffFirst)
return;
selCur.cpLim = cpOffFirst;
cpOffLim = cpLim;
}
else
{ /* Shrink a backward selection */
cpOffLim = cp;
if (selCur.cpFirst == cpOffLim)
return;
selCur.cpFirst = cpOffLim;
cpOffFirst = cpFirst;
}
ToggleSel(cpOnFirst, cpOnLim, true);
ToggleSel(cpOffFirst, cpOffLim, false);
/* Check for a stray insert point */
if (selCur.cpFirst != selCur.cpLim)
ClearInsertLine();
/* Set vfPictSel iff the selection is exactly one picture */
CachePara( docCur, selCur.cpFirst );
vfPictSel = vpapAbs.fGraphics && (selCur.cpLim == vcpLimParaCache);
}
/* S E L E C T D L X P */
SelectDlXp(dl, xp, sty, fDrag)
int dl, xp, sty;
int fDrag;
{ /* Move cursor to the nearest valid CP and select unit */
typeCP cp;
typeCP cpFirst;
typeCP cpLim;
register struct EDL *pedl;
int xpStart = xpSelBar - wwdCurrentDoc.xpMin;
int itcMin, itcLim;
int xpLeft;
int xpPos;
int fPictInsertPoint=FALSE; /* Setting an insert point before a pict */
UpdateWw(wwCur, false); /* Synchronize cursor & text */
xp = max(0, xp - xpStart);
dl = min( wwdCurrentDoc.dlMax - 1, dl );
pedl = &(**wwdCurrentDoc.hdndl) [dl];
cp = pedl->cpMin;
/* At or Below EMark */
if (cp >= cpMacCur)
{
cp = cpMacCur;
goto FoundCp;
}
if (pedl->fGraphics)
{ /*
Special kludge for selecting a picture:
Select the whole picture (if the hit is inside or to the
right of the picture)
Select an insert point just before the picture if the hit
is to the left of the picture OR in the selection bar
when the picture is left-justified) */
if ( (xp < pedl->xpLeft) || (sty == styLine && xp == 0) )
fPictInsertPoint = TRUE;
goto FoundCp;
}
if (sty >= styPara)
{ /* Selecting a paragraph, line, doc */
goto FoundCp;
}
/* Must Format to figure out the right cp */
FormatLine(docCur, cp, pedl->ichCpMin, cpMacCur, flmSandMode); /*HM*/
CachePara(docCur, cp);
pedl = &(**wwdCurrentDoc.hdndl) [dl];
if (vfli.fSplat) /* Selecting in division/page break */
{
cp = vfli.cpMin;
goto FoundCp;
}
xpLeft = pedl->xpLeft;
if (vfli.xpLeft != xpLeft)
/* This indicates that we are in lo memory conditions; in trouble */
return;
/* Assert (vfli.xpLeft == xpLeft); May not be true in lo memory */
if (xp <= xpLeft)
{
itcMin = 0;
goto FoundCp;
}
/* Out of bounds right */
if (xp >= pedl->xpMac)
{
itcMin = vfli.cpMac - cp - 1;
cp = vfli.cpMac - 1;
goto CheckPastPara;
}
/* Search through the line for the cp at position xp */
xpPos = xpLeft;
itcMin = 0;
itcLim = vfli.cpMac - cp;
while (itcMin < itcLim && xpPos < xp)
xpPos += vfli.rgdxp[itcMin++];
if (itcMin >= 1)
/* This may not be true if we are so low on memory that
FormatLine could not do its job */
itcMin--;
cp += itcMin;
CachePara(docCur, cp);
if ((xpPos < xp + vfli.rgdxp[itcMin] / 2) &&
(sty == styChar /* || !fDrag */) )
{ /* Actually selecting next character */
CheckPastPara:
if (cp + 1 == vcpLimParaCache && !vpapAbs.fGraphics &&
(vfSelAtPara || vcpSelect == cpNil))
/* Return insert point before paragraph mark */
{
if (vcpSelect == cpNil)
vfSelAtPara = true;
goto FoundCp;
}
itcMin++;
cp++;
}
//T-HIROYN sync win3.0
#ifdef DBCS
/* if itcMin point the second char of kanji, increment itcMin */
if (itcMin < itcLim && vfli.rgdxp[itcMin]==0)
goto CheckPastPara; /* Select next character */
#endif /* DBCS */
FoundCp:
/* Set up selection limits */
cpFirst = CpFirstSty( cp, sty );
cpLim = CpLimSty( cp, sty );
if (sty == styChar)
{
if ( !pedl->fGraphics || fPictInsertPoint )
/* In text or before a pic: don't extend to end of styChar */
cpLim = cpFirst;
if ( vcpSelect == cpNil )
{ /* First time through, remember where we started */
/* Set if we want to kludge the insert point at the end of *pedl */
vfMakeInsEnd = (cp == pedl->cpMin + pedl->dcpMac &&
cp <= cpMacCur &&
!pedl->fGraphics &&
!pedl->fSplat);
vcpSelect = cpFirst;
}
}
if (fDrag)
ChangeSel( selCur.fForward ? cpLim : cpFirst, sty );
else
Select( cpFirst, cpLim );
}
typeCP CpEdge()
{ /* Return edge of selection */
return selCur.fForward ?
CpMax( CpFirstSty( selCur.cpLim - 1, styChar ), selCur.cpFirst ) :
selCur.cpFirst;
}

Reference in a new issue Copy permalink