|
|
/************************************************************//* Windows Write, Copyright 1985-1992 Microsoft Corporation *//************************************************************/
/* disp.c -- MW display routines */
#define NOKEYSTATE
#define NOSYSCOMMANDS
#define NOSHOWWINDOW
//#define NOATOM
#define NOCLIPBOARD
#define NOGDICAPMASKS
#define NOCTLMGR
#define NOWINSTYLES
//#define NOVIRTUALKEYCODES
#define NOSYSMETRICS
#define NOMENUS
#define NOSOUND
#define NOCOMM
#define NOOPENFILE
#define NOWH
#define NOWINOFFSETS
#define NOMETAFILE
#define NOMB
#define NODRAWTEXT
#include <windows.h>
#define NOUAC
#include "mw.h"
#include "debug.h"
#include "cmddefs.h"
#include "dispdefs.h"
#include "wwdefs.h"
#define NOKCCODES /* Removes all kc code defines */
#include "ch.h"
#include "docdefs.h"
#include "fmtdefs.h"
#include "propdefs.h"
#include "macro.h"
#include "printdef.h"
#include "fontdefs.h"
#if defined(OLE)
#include "obj.h"
#endif
#ifdef DBCS
#include "dbcs.h"
#endif
#ifdef CASHMERE /* No VisiMode in WinMemo */
extern int vfVisiMode;#endif /* CASHMERE */
extern int vcchBlted;extern int vidxpInsertCache;extern int vdlIns;extern int vfInsLast;extern struct PAP vpapAbs;extern struct SEP vsepAbs;extern int rgval[];extern struct DOD (**hpdocdod)[];extern typeCP cpMacCur;extern int vfSelHidden;extern struct WWD rgwwd[];extern int wwCur, wwMac;extern struct FLI vfli;extern struct SEL selCur;extern struct WWD *pwwdCur;extern int docCur;extern struct CHP (**vhgchpFormat)[];extern int vichpFormat;extern typeCP cpMinCur;extern typeCP cpMinDocument;extern int vfInsertOn;extern int vfTextBltValid;extern typeCP vcpFirstParaCache;extern typeCP vcpLimParaCache;extern unsigned vpgn;extern struct SEP vsepAbs;extern CHAR stBuf[];extern typeCP CpEdge();extern typeCP CpMacText();extern int vdocPageCache;extern int vfPictSel;extern int vfAwfulNoise;extern int vfSkipNextBlink;extern int dypMax;extern HDC vhMDC;extern HWND vhWndPageInfo;extern struct FMI vfmiScreen;extern int docScrap;extern long rgbBkgrnd;extern long ropErase;extern BOOL vfMonochrome;extern int dxpbmMDC;extern int dypbmMDC;extern HBITMAP hbmNull;extern int vfOutOfMemory;extern int vfSeeSel;extern int vfInsEnd; /* Is insert point at end-of-line? */extern int vipgd;extern typeCP vcpMinPageCache;extern typeCP vcpMacPageCache;/* actual position of the cursor line */extern int vxpCursLine;extern int vypCursLine;
extern int vdypCursLine;extern int vfScrollInval; /* means scroll did not take and UpdateWw must be repeated */extern BOOL vfDead;extern HRGN vhrgnClip;
/* G L O B A L S
int dlsMac = 0;*/#ifdef DBCS
int donteat = 0; /* propagate not to eat message */#endif
/* D I S P L A Y F L I *//* Display formatted line in window ww at line dl */
DisplayFli(ww, dl, fDontDisplay)int ww;int dl;int fDontDisplay; /* True if we set up dl info but don't display */ {#ifdef KOREA // jinwoo: 92, 9, 28
/* process Subscript separatedly from descent */#ifdef NODESC
extern int isSubs;#endif
#endif
typeCP dcp; typeCP dcpMac; struct WWD *pwwd = &rgwwd[ww]; HDC hDC = pwwd->hDC; int xp; /* Current xp to write text */ int yp; /* Current yp to write text */ int xpMin = pwwd->xpMin; /* Minimum xp in window */ int xpMac = pwwd->xpMac; /* Maximum xp in window */ int ypLine; /* Screen yp for current line */ int dxp; /* Width of current run */ int dyp; /* Line height */ int dxpExtra; /* Width of pad for each space */ typeCP cpMin; typeCP cpMac; int xpSel; /* xp of the start of the selection */ int dxpSel = 0; /* Width of the selection. */ CHAR chMark = '\0'; /* style character */ struct CHP *pchp; BOOL fTabsKludge = (vfli.ichLastTab >= 0); BOOL fInsertOn = FALSE; int cBreakRun; /* break characters in run (no relation to Dick or Jane) */
#ifdef SMFONT
RECT rcOpaque;#endif /* SMFONT */
#ifdef DDISP
CommSzNumNum(" DisplayFli: dl/fDontDisplay ", dl, fDontDisplay);#endif
Assert(ww >= 0 && ww < wwMax);#ifdef SMFONT
Assert(!fDontDisplay || vfli.fGraphics)#endif /* SMFONT */
Scribble(5,'D');
/* Fill up EDL and set some useful locals */ { register struct EDL *pedl = &(**pwwd->hdndl)[dl];
if (dl == vdlIns) { /* Overwriting chars blted during fast insert; reset blt count */ vcchBlted = 0; vidxpInsertCache = -1; }
pedl->xpLeft = vfli.xpLeft; pedl->xpMac = vfli.xpReal; cpMin = pedl->cpMin = vfli.cpMin; pedl->dcpMac = (cpMac = vfli.cpMac) - cpMin; dyp = pedl->dyp = vfli.dypLine; pedl->ichCpMin = vfli.ichCpMin; pedl->dcpDepend = (cpMin == cpMac) ? 0xff : vfli.dcpDepend; pedl->fValid = TRUE; pedl->fGraphics = vfli.fGraphics; pedl->fSplat = vfli.fSplat;
/* The position of current line equals the position of the previous line
+ height of this line. */#ifdef SMFONT
pedl->yp = rcOpaque.bottom = dyp + (ypLine = rcOpaque.top = (dl == 0 ? pwwd->ypMin : (pedl - 1)->yp));#else /* not SMFONT */
pedl->yp = dyp + (ypLine = (dl == 0 ? pwwd->ypMin : (pedl - 1)->yp));#endif /* SMFONT */
if (pedl->fIchCpIncr = (vfli.ichCpMac != 0)) { /* Look at final text column */ ++cpMac;
/* Since this is true, we can compress pedl->ichCpMac to 1 bit. */ Assert(vfli.ichCpMac == pedl->ichCpMin + 1); } }
if (vfli.doc == docNil) { /* This is the space beyond the end mark. */ PatBlt(hDC, 0, ypLine, xpMac, dyp, ropErase); goto Finished; }
/* Is there a character in the "style bar"? */ if (cpMin != cpMac) {
#ifdef CASHMERE
/* This line is not completely empty (not after the end mark); check for
painting marks on the style bar. */ if (cpMin == vcpFirstParaCache && vpapAbs.rhc != 0) { /* This is a running-head. */ chMark = chStatRH; } else if ((**hpdocdod)[vfli.doc].hpgtb != 0)#else /* not CASHMERE */
if (vpapAbs.rhc == 0 && (**hpdocdod)[vfli.doc].hpgtb != 0)#endif /* CASHMERE */
{ if (vdocPageCache != vfli.doc || cpMac > vcpMacPageCache || cpMac <= vcpMinPageCache) { CachePage(vfli.doc, cpMac - 1); }
/* We are now guaranteed that cpMac is within the cached page. */ if (cpMin <= vcpMinPageCache && (!vfli.fGraphics || vfli.ichCpMin == 0)) { /* This is the first line of new page; show page mark. */ chMark = chStatPage; } } }
#ifdef SMFONT
#ifdef DDISP
/* black out this line to test how efficiently/correctly we
overwrite pixels from previously-resident lines of text */ PatBlt(hDC, 0, ypLine, xpMac, dyp, BLACKNESS); { long int i; for (i=0; i < 500000; i++) ; }#endif
/* Calculate dcpMac now, so we might be able to know how much to erase. */ dcpMac = vfli.fSplat ? vfli.ichMac : vfli.ichReal;
/* Erase any character that might be in the style bar. */ dxp = xpSelBar + 1; if (!vfli.fGraphics) { dxp = xpMac; // clear the whole line
} PatBlt(hDC, 0, ypLine, dxp, dyp, ropErase);
/* If this is graphics then go draw any characters in the style bar. */ if (vfli.fGraphics) { goto DrawMark; }
/* If there are no "real" characters on this line then we can skip alot of
this. */ if (dcpMac == 0) { goto EndLine2; }#else /* not SMFONT */
if (vfli.fGraphics || fDontDisplay) { /* Erase any character that might be in the style bar. */ PatBlt(hDC, 0, ypLine, xpSelBar, dyp, ropErase); goto DrawMark; }#endif /* SMFONT */
ValidateMemoryDC(); if (vhMDC == NULL) {Error: /* Notify the user that an error has occured and simply erase this line.
*/ WinFailure(); PatBlt(hDC, xpSelBar, ypLine, xpMac - xpSelBar, dyp, ropErase); goto Finished; }
#ifndef SMFONT
/* Create a new bitmap for the memory DC if the current bitmap is not big
enough. */ if (xpMac > dxpbmMDC || dyp > dypbmMDC) { HBITMAP hbm;
/* If there is an old bitmap, then delete it. */ if (dxpbmMDC != 0 || dypbmMDC != 0) { DeleteObject(SelectObject(vhMDC, hbmNull)); }
/* Create the new bitmap and select it in. */ if ((hbm = CreateBitmap(dxpbmMDC = xpMac, dypbmMDC = dyp, 1, 1, (LPSTR)NULL)) == NULL) { /* There should be a graceful way to recover if the bitmap is ever
NULL (e.g we don't have enough memory for it). */ dxpbmMDC = dypbmMDC = 0; goto Error; } SelectObject(vhMDC, hbm); }
/* Erase the are of the bitmap we are going to use. */ PatBlt(vhMDC, xpSelBar, 0, xpMac, dyp, vfMonochrome ? ropErase : WHITENESS);#endif /* not SMFONT */
/* Initialize some of the variables we'll need. */ pchp = &(**vhgchpFormat)[0];#ifdef SMFONT
xp = rcOpaque.left = rcOpaque.right = vfli.xpLeft + xpSelBar - xpMin + 1;#else /* not SMFONT */
dcpMac = vfli.fSplat ? vfli.ichMac : vfli.ichReal; xp = vfli.xpLeft + xpSelBar - xpMin + 1;#endif /* SMFONT */
dxpExtra = fTabsKludge ? 0 : vfli.dxpExtra;
#ifdef SMFONT
/* If we are horizontally scrolled, then set the clip area to the area
outside of the selection bar. */ if (xpMin != 0) { IntersectClipRect(hDC, xpSelBar, rcOpaque.top, xpMac, rcOpaque.bottom); }#endif /* SMFONT */
for (dcp = 0; dcp < dcpMac; pchp++) { /* For all runs do: */ int ichFirst; /* First character in the current run */ int cchRun; /* Number of characters in the current run */
dcp = ichFirst = pchp->ichRun; dcp += pchp->cchRun; if (dcp > dcpMac) { dcp = dcpMac; } cchRun = dcp - ichFirst;
/* Compute dxp = sum of width of characters in current run (formerly
DxaFromIcpDcp). */ { register int *pdxp; register int cchT = cchRun; PCH pch = vfli.rgch + ichFirst;
dxp = cBreakRun = 0; pdxp = &vfli.rgdxp[ichFirst]; while (cchT-- > 0) { dxp += *pdxp++; if (*pch++ == chSpace) ++cBreakRun; }#ifdef DDISP
CommSzNum(" dxp=",dxp);#endif
}
if (dxp > 0) { int cchDone; PCH pch = &vfli.rgch[ichFirst];
#ifdef KOREA //920525 KDLEE; jinwoo: 92, 9, 28
#ifdef NODESC
TEXTMETRIC tm;#endif
#endif //KOREA
LoadFont(vfli.doc, pchp, mdFontScreen);#ifdef KOREA //KDLEE 920525; jinwoo: 92, 9, 28
#ifdef NODESC
GetTextMetrics (vhMDC, (LPTEXTMETRIC)&tm);
if (tm.tmCharSet==HANGEUL_CHARSET) yp = dyp - (vfli.dypBase/3) -((pchp->hpsPos != 0 ? (pchp->hpsPos < hpsNegMin ? ypSubSuper : -ypSubSuper) : 0)) - vfmiScreen.dypBaseline - (isSubs ? ypSubSuper : 0); else yp = (dyp - (vfli.dypBase + (pchp->hpsPos != 0 ? (pchp->hpsPos < hpsNegMin ? ypSubSuper : -ypSubSuper) : 0))) - vfmiScreen.dypBaseline - (isSubs ? ypSubSuper : 0);#else /* NODESC */
yp = (dyp - (vfli.dypBase + (pchp->hpsPos != 0 ? (pchp->hpsPos < hpsNegMin ? ypSubSuper : -ypSubSuper) : 0))) - vfmiScreen.dypBaseline;#endif /* NODESC */
#else /* KOREA */
yp = (dyp - (vfli.dypBase + (pchp->hpsPos != 0 ? (pchp->hpsPos < hpsNegMin ? ypSubSuper : -ypSubSuper) : 0))) - vfmiScreen.dypBaseline;#endif // KOREA jinwoo: 92, 9, 28
/* Note: tabs and other special characters are guaranteed to come at
the start of a run. */ SetTextJustification(vhMDC, dxpExtra * cBreakRun, cBreakRun);#ifdef SMFONT
SetTextJustification(hDC, dxpExtra * cBreakRun, cBreakRun);#endif /* SMFONT */
cchDone = 0; while (cchDone < cchRun) { int cch;
/* Does the wide-space zone begin in this run? */ if (vfli.fAdjSpace && (vfli.ichFirstWide < ichFirst + cchRun) && (ichFirst + cchDone <= vfli.ichFirstWide)) { int cchDoneT = cchDone;
/* Is this the beginning of the wide-space zone? */ if (ichFirst + cchDone == vfli.ichFirstWide) { /* Reset the width of the spaces. */ SetTextJustification(vhMDC, ++dxpExtra * cBreakRun, cBreakRun);#ifdef SMFONT
SetTextJustification(hDC, dxpExtra * cBreakRun, cBreakRun);#endif /* SMFONT */
cch = cchRun - cchDone; cchDone = cchRun; } else { cchDone = cch = vfli.ichFirstWide - ichFirst; }
/* This run is cut short because of a wide space, so we need
to calculate a new width. */ { register int *pdxp; register int cchT = cch; PCH pch = &vfli.rgch[ichFirst + cchDoneT];
dxp = 0; pdxp = &vfli.rgdxp[ichFirst + cchDoneT]; while (cchT-- > 0) { dxp += *pdxp++; if (*pch++ == chSpace) ++cBreakRun; } } } else { cchDone = cch = cchRun; }
while (cch > 0) { switch (*pch) { CHAR ch; int dxpT;
case chTab:
#ifdef CASHMERE
/* chLeader contains tab leader character (see
FormatLine) */ if ((ch = pchp->chLeader) != chSpace) { int cxpTab; CHAR rgch[32]; int dxpLeader = CharWidth(ch); int xpT = xp; int iLevelT = SaveDC(vhMDC);
SetBytes(&rgch[0], ch, 32); dxpT = vfli.rgdxp[ichFirst]; cxpTab = ((dxpT + dxpLeader - 1) / dxpLeader + 31) >> 5;
xp += dxpT;
while (cxpTab-- > 0) { TextOut(vhMDC, xpT, yp, (LPSTR)rgch, 32); xpT += dxpLeader << 5; } RestoreDC(vhMDC, iLevelT); } else#endif /* CASHMERE */
{#ifdef SMFONT
/* Expand the opaque rectangle to include the tab.
*/ rcOpaque.right += vfli.rgdxp[ichFirst];#endif /* SMFONT */
xp += vfli.rgdxp[ichFirst]; }
if (fTabsKludge && ichFirst >= vfli.ichLastTab) { SetTextJustification(vhMDC, (dxpExtra = vfli.dxpExtra) * cBreakRun, cBreakRun);#ifdef SMFONT
SetTextJustification(hDC, dxpExtra * cBreakRun, cBreakRun);#endif /* SMFONT */
fTabsKludge = FALSE; } dxp -= vfli.rgdxp[ichFirst]; pch++; cch--; goto EndLoop;
#ifdef CASHMERE
case schPage: if (!pchp->fSpecial) { goto EndLoop; } stBuf[0] = CchExpPgn(&stBuf[1], vpgn, vsepAbs.nfcPgn, flmSandMode, ichMaxLine); goto DrawSpecial;
case schFootnote: if (!pchp->fSpecial) { goto EndLoop; } stBuf[0] = CchExpFtn(&stBuf[1], cpMin + ichFirst, flmSandMode, ichMaxLine);DrawSpecial:#else /* not CASHMERE */
case schPage: case schFootnote: if (!pchp->fSpecial) { goto EndLoop; } stBuf[0] = *pch == schPage && (wwdCurrentDoc.fEditHeader || wwdCurrentDoc.fEditFooter) ? CchExpPgn(&stBuf[1], vpgn, 0, flmSandMode, ichMaxLine) : CchExpUnknown(&stBuf[1], flmSandMode, ichMaxLine);#endif /* not CASHMERE */
#ifdef SMFONT
/* Calculate the opaque rectangle. */ rcOpaque.right += vfli.rgdxp[ichFirst] + vfmiScreen.dxpOverhang;
TextOut(hDC, xp, ypLine+yp, &stBuf[1], stBuf[0]);#else /* not SMFONT */
TextOut(vhMDC, xp, yp, (LPSTR)&stBuf[1], stBuf[0]);#endif /* SMFONT */
break;
default: goto EndLoop; }
dxp -= vfli.rgdxp[ichFirst];#ifdef SMFONT
/* End the line if no more will fit into the window. */ if ((xp += vfli.rgdxp[ichFirst++]) >= xpMac) { goto EndLine; } rcOpaque.left = (rcOpaque.right = xp) + vfmiScreen.dxpOverhang;#else /* not SMFONT */
xp += vfli.rgdxp[ichFirst++];#endif /* SMFONT */
pch++; cch--; }EndLoop:
#ifdef SMFONT
if (cch == 0) { Assert(dxp == 0); } else { /* Calculate the opaque rectangle. */ rcOpaque.right += dxp + vfmiScreen.dxpOverhang;
#if 0
{ char msg[180]; wsprintf(msg,"putting out %d characters\n\r",cch); OutputDebugString(msg); }#endif
/* Output cch characters starting at pch */ TextOut(hDC, xp, ypLine+yp, pch, cch);
/* End the line if no more will fit into the window. */ if ((xp += dxp) >= xpMac) { goto EndLine; } rcOpaque.left = (rcOpaque.right = xp) + vfmiScreen.dxpOverhang; pch += cch; }#else /* not SMFONT */
/* Output cch characters starting at pch */ TextOut(vhMDC, xp, yp, (LPSTR)pch, cch); xp += dxp; pch += cch;#endif /* SMFONT */
} /* end while (cchDone<cchRun) */ } /* end if (dxp>0) */ } /* end for dcp=0..dcpMac */
#ifdef SMFONT
EndLine: /* Restore the clip region if need be. */ if (xpMin != 0) { SelectClipRgn(hDC, NULL); }EndLine2:#endif /* SMFONT */
#ifdef CASHMERE
if (vfVisiMode) { AddVisiSpaces(ww, &(**pwwd->hdndl)[dl], vfli.dypBase, vfli.dypAfter + vfli.dypFont); }#endif /* CASHMERE */
vfTextBltValid = FALSE;
if ((ww == wwCur) && (pwwd->doc != docScrap) && !vfSelHidden && (selCur.cpLim >= cpMin)) { if (selCur.cpFirst <= cpMac) { /* Show selection */ int xpFirst; int xpLim;
#ifdef ENABLE
if (vfli.fSplatNext && selCur.cpFirst == selCur.cpLim && selCur.cpFirst == cpMac) { vfInsEnd = TRUE; ClearInsertLine(); } vfInsertOn = FALSE;#endif /* ENABLE */
if (selCur.cpFirst <= cpMin && selCur.cpLim >= cpMac) { xpFirst = vfli.xpLeft; xpLim = vfli.xpReal; } else if (selCur.cpFirst < cpMac || (selCur.cpLim == cpMac && vfInsEnd)) { typeCP cpBegin = CpMax(cpMin, selCur.cpFirst); typeCP cpEnd = CpMin(cpMac, selCur.cpLim);
dxp = DxpDiff((int)(cpBegin - cpMin), (int)(cpEnd - cpBegin), &xpFirst); xpLim = min(xpMin + vfli.xpReal, xpFirst + dxp); } else { goto DidntHighlight; }
xpSel = xpSelBar + max(xpFirst - xpMin, 0); if (xpLim > xpFirst) { /* Set highlighting at desired screen position. */ dxpSel = max(xpLim - max(xpFirst, xpMin), 0); } else if (selCur.cpFirst == selCur.cpLim && ((selCur.cpLim != cpMac) ^ vfInsEnd)) { vfInsertOn = FALSE; /* Because we redisplayed insert pt line */
#ifdef CASHMERE
vdypCursLine = min(vfli.dypFont, vfli.dypLine - vfli.dypAfter); vypCursLine = ypLine + dyp - vfli.dypAfter;#else /* not CASHMERE */
vdypCursLine = vfli.dypFont; vypCursLine = ypLine + dyp;#endif /* not CASHMERE */
vxpCursLine = xpSel;
/* Start blinking in a while */ vfSkipNextBlink = TRUE;
fInsertOn = xpFirst >= xpMin; }
DidntHighlight:; } }
#ifdef SMFONT
/* Invert the selection */ if (dxpSel != 0) { PatBlt(hDC, xpSel, ypLine, dxpSel, dyp, DSTINVERT); }#else /* not SMFONT */
/* Blt the line of text onto the screen. */ PatBlt(vhMDC, 0, 0, xpSelBar, dyp, vfMonochrome ? ropErase : WHITENESS); if (dxpSel == 0) { BitBlt(hDC, 0, ypLine, xpMac, dyp, vhMDC, 0, 0, SRCCOPY); } else { BitBlt(hDC, 0, ypLine, xpSel, dyp, vhMDC, 0, 0, SRCCOPY); BitBlt(hDC, xpSel, ypLine, dxpSel, dyp, vhMDC, xpSel, 0, NOTSRCCOPY); xpSel += dxpSel; BitBlt(hDC, xpSel, ypLine, xpMac - xpSel, dyp, vhMDC, xpSel, 0, SRCCOPY); }#endif /* SMFONT */
/* Draw the insertion bar if necessary. */ if (fInsertOn) { DrawInsertLine(); }
DrawMark: /* Draw the character in the style bar if necessary. */ if (chMark != '\0') {#ifdef SYSENDMARK
struct CHP chpT; extern struct CHP vchpNormal;
blt(&vchpNormal, &chpT, cwCHP); chpT.ftc = ftcSystem; chpT.ftcXtra = 0; chpT.hps = hpsDefault;
/* Draw the style character in the standard font. */ LoadFont(vfli.doc, &chpT, mdFontScreen);
TextOut(hDC, 0, ypLine + dyp - vfli.dypBase - vfmiScreen.dypBaseline, (LPSTR)&chMark, 1);#else /* ifdef SYSENDMARK */
/* Draw the style character in the standard font. */ LoadFont(vfli.doc, NULL, mdFontScreen); TextOut(hDC, 0, ypLine + dyp - vfli.dypBase - vfmiScreen.dypBaseline, (LPSTR)&chMark, 1);#endif /* if-else-def SYSENDMARK */
}
if (vfli.fGraphics) { DisplayGraphics(ww, dl, fDontDisplay); }
Finished: Scribble(5,' '); }
/* D X P D I F F */DxpDiff(dcpFirst, dcp, pdxpFirst)int dcpFirst;int dcp;int *pdxpFirst;{#if 1
register int *pdxp = &vfli.rgdxp[0]; register int cch; int dxp = vfli.xpLeft;#ifdef ENABLE /* Not used */
int ichLim = dcpFirst + dcp;#endif
if (dcp > vfli.ichMac - dcpFirst) { /* This should not be, but is when we have a CR */ //Assert( dcpFirst < vfli.ichMac );
dcp = vfli.ichMac - dcpFirst; }
for (cch = 0; cch < dcpFirst; ++cch) { dxp += *pdxp++; } *pdxpFirst = dxp; dxp = 0; for (cch = 0; cch < dcp; ++cch) { dxp += *pdxp++; } return dxp;#else
int dxp; if (dcp > vfli.ichMac - dcpFirst) { /* This should not be, but is when we have a CR */ Assert( dcpFirst < vfli.ichMac ); dcp = vfli.ichMac - dcpFirst; }
/* first get space up to first character */ *pdxpFirst = LOWORD(GetTextExtent(hDC,vfli.rgch,dcpFirst)) + vfli.xpLeft;
/* now get space between first and first+dcp */ dxp = LOWORD(GetTextExtent(hDC,vfli.rgch+dcpFirst,dcp)); return dxp;#endif
}
UpdateDisplay(fAbortOK)int fAbortOK;{ int ww;
if (wwMac <= 0) { return; }
#ifdef CASHMERE
for (ww = 0; ww < wwMac; ww++) if ( rgwwd[ww].doc != docScrap ) { UpdateWw(ww, fAbortOK); if (rgwwd[ww].fDirty || vfOutOfMemory) { return; /* update has been interrupted */ } }#else /* not CASHMERE */
UpdateWw(wwDocument, fAbortOK); if (wwdCurrentDoc.fDirty || vfOutOfMemory) { /* Update has been interrupted */ return; }#endif /* not CASHMERE */
if (wwdCurrentDoc.fRuler) { UpdateRuler(); }}
/* U P D A T E W W */UpdateWw(ww, fAbortOK)int ww, fAbortOK;{ /* Redisplay ww as necessary */ extern int vfWholePictInvalid; register struct WWD *pwwd = &rgwwd[ww]; int dlMac; int dlOld, dlNew; int doc; int ichCp; struct EDL *pedlNew; register struct EDL *pedl; struct EDL (**hdndl)[]=pwwd->hdndl; int dypDiff; int ypTop; int ypFirstInval; int dr; int fLastNotShown; typeCP cp, cpMacWw;
if (!pwwd->fDirty) { return; }
if (!((**hpdocdod)[pwwd->doc].fDisplayable)) return;
if (fAbortOK && FImportantMsgPresent()) return;
#if 0 // how to get first and last cp's in invalid rect?
#if defined(OLE)
/*
Load visible objects. Do it now rather than in DisplayGraphics() because here it has less chance of disrupting the state variables upon which UpdateWw depends. */ ObjEnumInRange(docCur,cpMinCur,cpMacCur,ObjLoadObjectInDoc);#endif
#endif
dlMac = pwwd->dlMac; ypTop = pwwd->ypMin;
Assert( ww >= 0 && ww < wwMax ); vfli.doc = docNil; /* An aid to Fast Insert */
UpdateInvalid(); /* InvalBand for what Windows considers to be invalid */ ypFirstInval = pwwd->ypFirstInval;
#ifndef CASHMERE
Assert( ww == wwCur ); /* A MEMO-only assumption */#endif /* CASHMERE */
Scribble(5, 'U');
ValidateMemoryDC(); /* to do any update, we need a good memory DC */ if (vhMDC == NULL) { WinFailure(); return; }
doc = pwwd->doc; vfli.doc = docNil;
if (pwwd->fCpBad) {/* cp first displayed has not been blessed */
#ifdef CASHMERE /* Must do this if ww != wwCur assertion is FALSE */
int wwT = wwCur; if (ww != wwCur && wwCur >= 0)/* CtrBackTrs cache is only good for wwCur. Treat != case */ { if (pwwdCur->fDirty) /* Do wwCur first, saving cache */ UpdateWw(wwCur, fAbortOK);
if (fAbortOK && FImportantMsgPresent()) return;
ChangeWw(ww, false); CtrBackDypCtr( 0, 0 ); /* Validate pwwdCur->cpFirst */ ChangeWw(wwT, false); } else#endif /* CASHMERE */
{ if (fAbortOK && FImportantMsgPresent()) return;
CtrBackDypCtr( 0, 0 ); /* Validate pwwdCur->cpFirst */ } }
/* check for cpMin accessible in this ww */RestartUpdate: vfWholePictInvalid = fTrue; /* Tells DisplayGraphics to
abandon accumulated partial pict rect */ fLastNotShown = fFalse; cp = CpMax(pwwd->cpMin, pwwd->cpFirst); cpMacWw = pwwd->cpMac; ichCp = pwwd->ichCpFirst;
/* Note test for dlNew==0 that guarantees that there will be at least
one dl -- this was added for WRITE because we do not have the ability to enforce a minimum window size */
for (dlNew = dlOld = 0; ypTop < pwwd->ypMac || (dlNew == 0) ; dlNew++) /* we have: cp, ichCP: pints to text desired on the coming line dlNew
ypTop: desired position for top of dlNew -1 dlOld: next line to be considered for re-use */ /* check for having to extend dndl array */ { if (dlNew >= (int)pwwd->dlMax) {/* extend the array with uninitialized dl's, increment max, break if no space.
We assume that dlMac(Old) was <= dlMax, so the dl's will not be looked atbut used only to store new lines */#define ddlIncr 5
if (!FChngSizeH(hdndl, (pwwd->dlMax + ddlIncr) * cwEDL, fFalse)) break; pwwd->dlMax += ddlIncr; }/* discard unusable dl's */ for (; dlOld < dlMac; dlOld++) { /* Set dlOld and pedl to the next good dl */ int ypTopOld, ypOld;
/* Re-entrant Heap Movement */ if (fAbortOK && !fLastNotShown && FImportantMsgPresent()) goto RetInval;
pedl = &(**hdndl)[dlOld]; ypOld = pedl->yp;
/* loop if: invalid, passed over in cp space, passed over in dl space,
passed over in yp space,in invalid band, passed over in ich space */ if (!pedl->fValid || dlOld < dlNew || pedl->cpMin < cp || (ypTopOld = (ypOld - pedl->dyp)) < ypTop || (ypOld >= ypFirstInval && ypTopOld <= pwwd->ypLastInval) || (pedl->cpMin == cp && pedl->ichCpMin < ichCp)) continue;/* now we have dlOld, an acceptable if not necessarily useful dl.
now compute dlNew either from scratch or by re-using dlOld. To bere-useable, dlOld must have right cp/ichCp pair, plus be totally on screenor, if it is a partial line, it must stay still or move down - not up */ if (pedl->cpMin == cp && pedl->ichCpMin == ichCp && (ypOld <= pwwd->ypMac || ypTopOld <= ypTop)) {/* Re-use this dl */ int yp = ypTop; if (fLastNotShown) { /* HEAP MOVEMENT */ DisplayFli(ww, dlNew - 1, fLastNotShown = fFalse); pedl = &(**hdndl)[dlOld]; }
cp = pedl->cpMin + pedl->dcpMac; ichCp = pedl->fIchCpIncr ? pedl->ichCpMin + 1 : 0; ypTop += pedl->dyp; if (dlOld != dlNew || ypTopOld != yp) { DypScroll(ww, dlOld, dlNew - dlOld, yp); if (vfScrollInval) { /* There was a popup; invalid region might have changed */ /* fLastNotShown test is for interrupting picture display */ /* before we've really displayed it */
(**hdndl) [dlOld].fValid = fFalse; goto Restart1; } dlMac += dlNew - dlOld; } dlOld = dlNew + 1; goto NextDlNew; } break; }/* cpMin > cp, the line is not anywhere so it will have to be formatted
from scratch */
if (fAbortOK && !fLastNotShown && FImportantMsgPresent()) goto RetInval;
FormatLine(doc, cp, ichCp, cpMacWw, flmSandMode); /* Creates vfli */
if (vfOutOfMemory) goto RetInval;
ichCp = vfli.ichCpMac; cp = vfli.cpMac;/* advance invalid band so that update can resume after an interruption */ pwwd->ypFirstInval = (ypTop += vfli.dypLine); pedl = &(**hdndl)[dlOld]; if (dlOld < dlMac && pedl->cpMin == cp && pedl->ichCpMin == ichCp) { int dlT = dlOld;
/* line at dlOld is a valid, existing line that will abutt the line just about
to be displayed. */ if (dlOld == dlNew && pedl->yp - pedl->dyp <= ypTop)/* the line about to be overwritten will be re-used in the next loop.
Hence, it is worthwhile to save this line and its dl */ DypScroll(ww, dlOld++, 1, ypTop); else/* Move the next line to its abutting position. We know that it has not yet been
overwritten (yp, dlOld all > than ypTop, dlNew) */ DypScroll(ww, dlOld, 0, ypTop);
if (vfScrollInval) { /* There was a popup; invalid region might have changed */ /* fLastNotShown test is for interrupting picture display */ /* before we've really displayed it */
(**hdndl) [dlT].fValid = fFalse;Restart1: if (fLastNotShown) { pwwd->ypFirstInval = pwwd->ypMin; }
ypFirstInval = pwwd->ypFirstInval; ypTop = pwwd->ypMin; goto RestartUpdate; } }
/* true in 3rd param means put off picture redisplay till later *//* condition: graphics & not last in picture & not last in y space and
not in front of a invalid or valid transition in the picture */ DisplayFli(ww, dlNew, fLastNotShown = (vfli.fGraphics && vfli.ichCpMac!=0 && ypTop < pwwd->ypMac));NextDlNew:; }Break1: pwwd->dlMac = dlNew;
#ifdef CASHMERE
/* condition is here to avoid swapping */ if (pwwd->fSplit && rgwwd[pwwd->ww].fFtn) CalcFtnLimits(pwwd);#endif /* CASHMERE */
SetCurWwVScrollPos(); /* Set Scroll bar position */ vfTextBltValid = false;
/* reset invalid indications */ pwwd->fDirty = false; pwwd->ypFirstInval = ypMaxAll; pwwd->ypLastInval = 0; /* so that max in InvalBand will work */ Scribble(5, ' '); goto Validate;
/* Before returning from an interrupt, invalidate lines that were overwritten
within the present update. */RetInval: Scribble(5, ' '); for (; dlOld < dlMac; dlOld++) { pedl = &(**hdndl)[dlOld]; if ((pedl->yp - pedl->dyp) < ypTop) pedl->fValid = fFalse; else break; }Validate: ;
#ifdef ENABLE /* We will let UpdateInvalid handle this in case
further invalidation occurred during the update */
{ /* Tell Windows that the part we updated is valid */ RECT rc;
rc.left = 0; rc.top = pwwd->ypMin; rc.right = pwwd->xpMac; rc.bottom = imin( pwwd->ypMac, ypTop ); ValidateRect( pwwd->wwptr, (LPRECT)&rc ); }#endif
}
/* D Y P S C R O L L */DypScroll(ww, dlFirst, ddl, ypTo)int ww, dlFirst, ddl, ypTo;{/* Scroll dl's in a window, from dlFirst to end, down ddl lines (or up -ddl).
Bitmap is moved from top of dlFirst to ypTo. The yp's of the dl's are updated.Returns the amount scrolled. (positive means down). */
register struct WWD *pwwd = &rgwwd[ww]; int dlMac; int dlT; int ypFrom; int dypChange; int cdlBelow; struct EDL *pedl; struct EDL *pedlT;
/* Do not call procedures while dndl is loaded up to avoid heap movement */ struct EDL *dndl = &(**(pwwd->hdndl))[0];
Assert( ww >= 0 && ww < wwMax );
vfScrollInval = fFalse;
/* Number of dl's below (and including) the first one to be scrolled */ cdlBelow = pwwd->dlMac - dlFirst; pwwd->dlMac = min(pwwd->dlMac + ddl, pwwd->dlMax); cdlBelow = max(0, min(cdlBelow, pwwd->dlMac - ddl - dlFirst));
pedlT = &dndl[dlFirst]; ypFrom = pedlT->yp - pedlT->dyp;
/* Length of area to be moved */ dypChange = ypTo - ypFrom;
if (cdlBelow > 0) { int dlTo = dlFirst + ddl; int ypMac = pwwd->ypMac;
pedlT = &dndl[dlTo]; if (ddl != 0) { blt(&dndl[dlFirst], pedlT, cwEDL * cdlBelow); }
for (dlT = dlTo; dlT < pwwd->dlMac; ++dlT, ++pedlT) { if (dypChange < 0 && pedlT->yp > ypMac) { /* Invalidate dl's that are pulled in from the ozone below ypMac
*/ pedlT->fValid = fFalse; } else { pedlT->yp += dypChange; } } }
if (dypChange != 0) { RECT rc;
SetRect( (LPRECT)&rc, 0, min(ypFrom, ypTo), pwwd->xpMac, pwwd->ypMac ); Assert( ww == wwCur ); /* A MEMO-only assumption */ ScrollCurWw( &rc, 0, dypChange ); }
return dypChange;}
FImportantMsgPresent(){ /* If the next message is important enough to interrupt a screen update, we
return TRUE; if it can wait, we return FALSE */
BOOL fToggledKey; extern MSG vmsgLast;
#ifdef DEBUG
unsigned wHeapVal = *(pLocalHeap + 1);
Assert( wHeapVal == 0 ); /* Heap should not be frozen */#endif
#ifdef DBCS
if( donteat ) return TRUE;#endif
while (PeekMessage((LPMSG) &vmsgLast, NULL, NULL, NULL, PM_NOREMOVE)) {
if (((vmsgLast.wParam == VK_MENU) || (vmsgLast.wParam == VK_CONTROL))) { if (vmsgLast.wParam == VK_CONTROL) { GetMessage((LPMSG) &vmsgLast, NULL, NULL, NULL); SetShiftFlags(); } return TRUE; } /* Filter uninteresting or easily handled events */ else if (fToggledKey = FCheckToggleKeyMessage(&vmsgLast) || (vmsgLast.message == WM_KEYUP && vmsgLast.hwnd == wwdCurrentDoc.wwptr)) {
/* This is so the Windows keyboard interface mechanism will see toggle
key and key-up transitions */ GetMessage((LPMSG) &vmsgLast, NULL, NULL, NULL);#ifdef WIN30
/* PeekMessage has been changed in Win 3.0 so that GetKeyState()
called from FCheckToggleKeyMessage() is really only valid if you've done a PeekMessage(...,PM_REMOVE) or GetMessage() first. That is, while the FCheckToggleKeyMessage() call might succeed above, it will NOT have set the vfShiftKey/vfCommandKey flags correctly -- so we do it here ..pault */ if (fToggledKey) FCheckToggleKeyMessage(&vmsgLast);#endif
if (vmsgLast.hwnd != wwdCurrentDoc.wwptr) { /* Just in case a modeless dialog's window proc cares */ TranslateMessage((LPMSG)&vmsgLast); DispatchMessage((LPMSG)&vmsgLast); }#ifdef DBCS
#ifdef KOREA /* 90.12.23 by sangl */ // jinwoo: 92, 9, 28
if (vmsgLast.message == WM_CHAR || vmsgLast.message == WM_KEYDOWN || vmsgLast.message == WM_INTERIM) {#else /* KOREA */
if (vmsgLast.message == WM_CHAR || vmsgLast.message == WM_KEYDOWN ) {#endif //KOREA 920525 KDLEE; jinwoo: 92, 9, 28
donteat = TRUE; return( TRUE ); } /* else Ok, you are KEYUP message. do normal */#endif
} else { switch (vmsgLast.message) { case WM_MOUSEMOVE: /* Process mouse move messages immediately; they are not really
important. NOTE: This assumes that we have not captured all mouse events; in which case, they are important. */ DispatchMessage((LPMSG)&vmsgLast);
case WM_TIMER: case WM_SYSTIMER: /* Remove timer and mouse move messages from the queue. */ GetMessage((LPMSG) &vmsgLast, NULL, NULL, NULL); break;
default: Assert( *(pLocalHeap+1) == 0 ); /* Heap should still not be frozen */ return (TRUE); } } }
Assert( *(pLocalHeap + 1) == 0 ); /* Heap should still not be frozen */return (FALSE);}
/* C P B E G I N L I N E */typeCP CpBeginLine(pdl, cp)int *pdl;typeCP cp; { /* return the cp and dl containing cp */ int dlMin, dlLim; typeCP cpGuess; struct EDL *dndl;
do { UpdateWw(wwCur, false); PutCpInWwVert(cp); /* Ensure cp on screen */ } while (pwwdCur->fDirty && !vfOutOfMemory);
dndl = &(**(pwwdCur->hdndl))[0]; dlMin = 0; dlLim = pwwdCur->dlMac; while (dlMin + 1 < dlLim) { /* Binary search the ww */ int dlGuess = (dlMin + dlLim) >> 1; struct EDL *pedl = &dndl[dlGuess]; if ((cpGuess = pedl->cpMin) <= cp && (cpGuess != cp || pedl->ichCpMin == 0)) { /* guess is low or right */ dlMin = dlGuess; if (cp == cpGuess && pedl->cpMin + pedl->dcpMac != cp) break; /* Got it right */ } else /* Guess is high */ dlLim = dlGuess; } *pdl = dlMin; return dndl[dlMin].cpMin;}
/* T O G G L E S E L */ToggleSel(cpFirst, cpLim, fOn)typeCP cpFirst, cpLim; /* selection bounds */int fOn;{ /* Flip selection highlighting on and off */ extern int vfPMS; struct EDL *pedl; int dlT; int xpMin; int dxpRoom; int xpFirst; int xpLim; int fInsertPoint = (cpFirst == cpLim);
if (vfSelHidden || cpFirst > cpLim || cpLim < /*cp0*/ cpMinCur || vfDead) return;
if ( vfPictSel && vfPMS && (CachePara( docCur, cpFirst ), vpapAbs.fGraphics) && (vcpLimParaCache == cpLim) ) { /* Don't show inversion if we're moving or sizing a picture */ return; }
dxpRoom = pwwdCur->xpMac - xpSelBar; xpMin = pwwdCur->xpMin;
for (dlT = 0; dlT < pwwdCur->dlMac; dlT++) { typeCP cpMin, cpMac; /* line bounds */ pedl = &(**(pwwdCur->hdndl))[dlT]; if (!pedl->fValid) continue; cpMin = pedl->cpMin; if (cpMin > cpLim || cpMin > cpMacCur || (cpMin == cpLim && cpLim != cpFirst)) break; cpMac = cpMin + pedl->dcpMac; if (cpFirst <= cpMin && cpLim >= cpMac) {/* entire line is highlighted */ xpFirst = pedl->xpLeft; if (pedl->fGraphics && cpLim == cpMac && cpMin == cpMac) /* Special kludge for graphics paras */ xpLim = xpFirst; else xpLim = pedl->xpMac; } else if (fInsertPoint && cpFirst == cpMac && vfInsEnd) { /* Special kludge for an insert point at the end of a line */ xpLim = xpFirst = pedl->xpMac; } else if (cpFirst < cpMac) { /* Bite the bullet */ int dxp; typeCP cpBegin = CpMax(cpMin, cpFirst); typeCP cpEnd = CpMin(cpMac, cpLim);
FormatLine(docCur, cpMin, pedl->ichCpMin, cpMacCur, flmSandMode); dxp = DxpDiff((int) (cpBegin - cpMin), (int) (cpEnd - cpBegin), &xpFirst); xpLim = xpFirst + dxp;/* reload pedl because procedures were called */ pedl = &(**(pwwdCur->hdndl))[dlT]; } else continue;/* now we have: pedl valid, xpFirst, xpLast describe highlight */ /* xpFirst = max(xpFirst, xpMin); */ xpLim = min(xpLim, xpMin + pedl->xpMac); if (xpLim > xpFirst) { if (xpLim > xpMin) { RECT rc; rc.top = pedl->yp - pedl->dyp; rc.left = xpSelBar + max(xpFirst - xpMin, 0); rc.bottom = pedl->yp; rc.right = xpSelBar + xpLim - xpMin; InvertRect( wwdCurrentDoc.hDC, (LPRECT)&rc); } }/* ToggleSel modified 7/28/85 -- added explicit check for fInsertPoint, since
the xpLim == xpFirst test sometimes succeeded bogusly when a selection was extended backwards. BL */ else if (fInsertPoint && (xpLim == xpFirst)) /* Insertion point */ { /* vfli should usually be cached already, so will be fast. */ int yp = pedl->yp; FormatLine(docCur, cpMin, pedl->ichCpMin, cpMacCur, flmSandMode); if (fOn ^ vfInsertOn) { if (!vfInsertOn) { vxpCursLine = xpSelBar + xpFirst - xpMin; vypCursLine = yp - vfli.dypAfter; vdypCursLine = min(vfli.dypFont, vfli.dypLine - vfli.dypAfter);
/* Start blinking in a while */ vfSkipNextBlink = TRUE; } DrawInsertLine(); } return; } }}
/* T R A S H W W */TrashWw(ww){ /* Invalidate all dl's in ww */ Assert( ww >= 0 && ww < wwMax ); InvalBand(&rgwwd[ww], 0, ypMaxAll);}
/* I N V A L B A N D *//* invalidate the band ypFirst, ypLast inclusive */InvalBand(pwwd, ypFirst, ypLast)struct WWD *pwwd; int ypFirst, ypLast; {/* this covers some peculiar rects received from update event after a
window resize by 1 pixel. CS */ if (ypLast < 0 || ypFirst == ypLast) return;
pwwd->fDirty = true; pwwd->ypFirstInval = min(pwwd->ypFirstInval, ypFirst); pwwd->ypLastInval = max(ypLast, pwwd->ypLastInval); }
/* T R A S H A L L W W S */TrashAllWws(){ /* trash them all */ int ww;
#ifdef CASHMERE
for (ww = 0; ww < wwMac; ++ww) TrashWw(ww);#else
TrashWw( wwDocument );#endif
vfli.doc = docNil; /* Mark vfli invalid */}
/* T U R N O F F S E L */TurnOffSel(){ /* Remove sel highlighting from screen *//* HideSel has no effect */ if (!vfSelHidden) { ToggleSel(selCur.cpFirst, selCur.cpLim, false); vfSelHidden = true; }}
/* D R A W I N S E R T L I N E */DrawInsertLine(){ /* Draw (in Xor mode) a vertical bar at screen position v*CursLine */ /* Toggles both the display and the vfInsertOn flag */ /* Adjustments in cursor draw must be reflected in DisplayFli, above */
/* Last-minute correction for a bug: assure that the insert line
does not extend above ypMin */ if (!vfInsertOn && vdypCursLine > vypCursLine - wwdCurrentDoc.ypMin) vdypCursLine = vypCursLine - wwdCurrentDoc.ypMin;
/* Tell GDI to invert the caret line */ PatBlt( wwdCurrentDoc.hDC, vxpCursLine, vypCursLine - vdypCursLine, 2, vdypCursLine , DSTINVERT ); vfInsertOn = 1 - vfInsertOn;}
/* C L E A R I N S E R T L I N E */ClearInsertLine(){ if ( vfInsertOn) DrawInsertLine();}
|
