3880 lines
96 KiB
C++
3880 lines
96 KiB
C++
/*
|
|
* @doc INTERNAL
|
|
*
|
|
* @module DISPML.CPP -- CDisplayML class |
|
|
*
|
|
* This is the Multi-line display engine. See disp.c for the base class
|
|
* methods and dispsl.c for the single-line display engine.
|
|
*
|
|
* Owner:<nl>
|
|
* RichEdit 1.0 code: David R. Fulmer
|
|
* Christian Fortini (initial conversion to C++)
|
|
* Murray Sargent
|
|
* Rick Sailor (for most of RE 2.0)
|
|
*
|
|
* Copyright (c) 1995-2000, Microsoft Corporation. All rights reserved.
|
|
*/
|
|
|
|
#include "_common.h"
|
|
#include "_dispml.h"
|
|
#include "_edit.h"
|
|
#include "_font.h"
|
|
#include "_measure.h"
|
|
#include "_render.h"
|
|
#include "_select.h"
|
|
#include "_dfreeze.h"
|
|
|
|
/*
|
|
#include "icecap.h"
|
|
|
|
class CCapProfile
|
|
{
|
|
public:
|
|
CCapProfile() { StartProfile(PROFILE_THREADLEVEL, PROFILE_CURRENTID); }
|
|
~CCapProfile() { StopProfile(PROFILE_THREADLEVEL, PROFILE_CURRENTID); }
|
|
};
|
|
*/
|
|
ASSERTDATA
|
|
|
|
//
|
|
// Invariant support
|
|
//
|
|
#define DEBUG_CLASSNAME CDisplayML
|
|
#include "_invar.h"
|
|
|
|
// Timer tick counts for background task
|
|
#define cmsecBgndInterval 300
|
|
#define cmsecBgndBusy 100
|
|
|
|
// Lines ahead
|
|
const LONG cExtraBeforeLazy = 60;
|
|
|
|
// cursor. NB! 6144 is not a measured number; 4096 was the former number,
|
|
// and it wasn't measured either; it just seemed like a good one. We bumped
|
|
// the number to 6144 as a safe-fix to a problem which caused cursor-flashing
|
|
// for the eBook reader. The eBook reader's idle process pumps up to
|
|
// 5120 characters into RichEdit between ReCalc attempts. However, each
|
|
// recalc can still work on more that 5120 characters; if the
|
|
// insertion started at the middle of a line, then recalc starts
|
|
// at the beginning of the line, picking up a few extra characters.
|
|
#define NUMCHARFORWAITCURSOR 6144
|
|
|
|
#ifndef DEBUG
|
|
#define CheckView()
|
|
#define CheckLineArray()
|
|
#endif
|
|
|
|
|
|
// =========================== CDisplayML =====================================================
|
|
|
|
#ifdef DEBUG
|
|
/*
|
|
* CDisplayML::Invariant
|
|
*
|
|
* @mfunc Make sure the display is in a valid state
|
|
*
|
|
* @rdesc TRUE if the tests succeeded, FALSE otherwise
|
|
*/
|
|
BOOL CDisplayML::Invariant(void) const
|
|
{
|
|
CDisplay::Invariant();
|
|
|
|
return TRUE;
|
|
}
|
|
#endif // DEBUG
|
|
|
|
/*
|
|
* CDisplayML::CalcScrollHeight()
|
|
*
|
|
* @mfunc
|
|
* Calculate the maximum Y scroll position.
|
|
*
|
|
* @rdesc
|
|
* Maximum possible scrolling position
|
|
*
|
|
* @devnote
|
|
* This routine exists because plain text controls do not have
|
|
* the auto-EOP and so the scroll height is different than
|
|
* the height of the control if the text ends in an EOP type
|
|
* character.
|
|
*/
|
|
LONG CDisplayML::CalcScrollHeight(LONG dvp) const
|
|
{
|
|
// The max scroll height for plain text controls is calculated
|
|
// differently because they don't have an automatic EOP character.
|
|
if(!_ped->IsRich() && Count())
|
|
{
|
|
// If last character is an EOP, bump scroll height
|
|
CLine *pli = Elem(Count() - 1); // Get last line in array
|
|
if(pli->_cchEOP)
|
|
dvp += pli->GetHeight();
|
|
}
|
|
return dvp;
|
|
}
|
|
|
|
/*
|
|
* CDisplayML::GetMaxVpScroll()
|
|
*
|
|
* @mfunc
|
|
* Calculate the maximum Y scroll position.
|
|
*
|
|
* @rdesc
|
|
* Maximum possible scrolling position
|
|
*
|
|
* @devnote
|
|
* This routine exists because we may have to come back and modify this
|
|
* calculation for 1.0 compatibility. If we do, this routine only needs
|
|
* to be changed in one place rather than the three at which it is used.
|
|
*
|
|
*/
|
|
inline LONG CDisplayML::GetMaxVpScroll() const
|
|
{
|
|
// The following code is turn off because we don't want to support
|
|
// 1.0 mode unless someone complained about it.
|
|
#if 0
|
|
if (_ped->Get10Mode())
|
|
{
|
|
// Ensure last line is always visible
|
|
// (use dy as temp to calculate max scroll)
|
|
vpScroll = Elem(max(0, Count() - 1))->_dvp;
|
|
|
|
if(vpScroll > _dvpView)
|
|
vpScroll = _dvpView;
|
|
|
|
vpScroll = _dvp - vpScroll;
|
|
}
|
|
#endif //0
|
|
|
|
return CalcScrollHeight(_dvp);
|
|
}
|
|
|
|
/*
|
|
* CDisplayML::ConvertScrollToVPos(vPos)
|
|
*
|
|
* @mfunc
|
|
* Calculate the real scroll position from the scroll position
|
|
*
|
|
* @rdesc
|
|
* Y position from scroll
|
|
*
|
|
* @devnote
|
|
* This routine exists because the thumb position messages
|
|
* are limited to 16-bits so we extrapolate when the V position
|
|
* gets greater than that.
|
|
*/
|
|
LONG CDisplayML::ConvertScrollToVPos(
|
|
LONG vPos) //@parm Scroll position
|
|
{
|
|
// Get maximum scroll range
|
|
LONG vpRange = GetMaxVpScroll();
|
|
|
|
// Has maximum scroll range exceeded 16-bits?
|
|
if(vpRange >= _UI16_MAX)
|
|
{
|
|
// Yes - Extrapolate to "real" vPos
|
|
vPos = MulDiv(vPos, vpRange, _UI16_MAX);
|
|
}
|
|
return vPos;
|
|
}
|
|
|
|
/*
|
|
* CDisplayML::ConvertVPosToScrollPos()
|
|
*
|
|
* @mfunc
|
|
* Calculate the scroll position from the V position in the document.
|
|
*
|
|
* @rdesc
|
|
* Scroll position from V position
|
|
*
|
|
* @devnote
|
|
* This routine exists because the thumb position messages
|
|
* are limited to 16-bits so we extrapolate when the V position
|
|
* gets greater than that.
|
|
*
|
|
*/
|
|
inline LONG CDisplayML::ConvertVPosToScrollPos(
|
|
LONG vPos) //@parm V position in document
|
|
{
|
|
// Get maximum scroll range
|
|
LONG vRange = GetMaxVpScroll();
|
|
|
|
// Has maximum scroll range exceeded 16-bits?
|
|
if(vRange >= _UI16_MAX)
|
|
{
|
|
// Yes - Extrapolate to "real" vPos
|
|
vPos = MulDiv(vPos, _UI16_MAX, vRange);
|
|
}
|
|
return vPos;
|
|
}
|
|
|
|
CDisplayML::CDisplayML (CTxtEdit* ped)
|
|
: CDisplay (ped), _pddTarget(NULL)
|
|
{
|
|
TRACEBEGIN(TRCSUBSYSDISP, TRCSCOPEINTERN, "CDisplayML::CDisplayML");
|
|
|
|
Assert(!_dulTarget && !_dvlTarget);
|
|
|
|
_fMultiLine = TRUE;
|
|
}
|
|
|
|
CDisplayML::~CDisplayML()
|
|
{
|
|
TRACEBEGIN(TRCSUBSYSDISP, TRCSCOPEINTERN, "CDisplayML::~CDisplayML");
|
|
|
|
delete _pddTarget;
|
|
}
|
|
|
|
/*
|
|
* CDisplayML::Init()
|
|
*
|
|
* @mfunc
|
|
* Init this display for the screen
|
|
*
|
|
* @rdesc
|
|
* TRUE iff initialization succeeded
|
|
*/
|
|
BOOL CDisplayML::Init()
|
|
{
|
|
TRACEBEGIN(TRCSUBSYSDISP, TRCSCOPEINTERN, "CDisplayML::Init");
|
|
|
|
// Initialize our base class
|
|
if(!CDisplay::Init())
|
|
return FALSE;
|
|
|
|
AssertSz(_ped, "CDisplayML::Init(): _ped not initialized in display");
|
|
// Verify allocation zeroed memory out
|
|
Assert(!_vpCalcMax && !_dupLineMax && !_dvp && !_cpMin);
|
|
Assert(!_fBgndRecalc && !_fVScrollEnabled && !_fUScrollEnabled);
|
|
|
|
// The printer view is not main, therefore we do this to make
|
|
// sure scroll bars are not created for print views.
|
|
DWORD dwScrollBars = _ped->TxGetScrollBars();
|
|
|
|
if(IsMain() && (dwScrollBars & ES_DISABLENOSCROLL))
|
|
{
|
|
if(dwScrollBars & WS_VSCROLL)
|
|
{
|
|
// This causes wlm to assert on the mac. something about
|
|
// scrollbar being disabled
|
|
_ped->TxSetScrollRange (SB_VERT, 0, 1, TRUE);
|
|
_ped->TxEnableScrollBar(SB_VERT, ESB_DISABLE_BOTH);
|
|
}
|
|
|
|
// Set horizontal scroll range and pos
|
|
if(dwScrollBars & WS_HSCROLL)
|
|
{
|
|
_ped->TxSetScrollRange (SB_HORZ, 0, 1, TRUE);
|
|
_ped->TxEnableScrollBar(SB_HORZ, ESB_DISABLE_BOTH);
|
|
}
|
|
}
|
|
|
|
SetWordWrap(_ped->TxGetWordWrap());
|
|
_cpFirstVisible = _cpMin;
|
|
|
|
Assert(!_upScroll && !_vpScroll && !_iliFirstVisible &&
|
|
!_cpFirstVisible && !_dvpFirstVisible);
|
|
|
|
_TEST_INVARIANT_
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
//================================ Device drivers ===================================
|
|
/*
|
|
* CDisplayML::SetMainTargetDC(hdc, dulTarget)
|
|
*
|
|
* @mfunc
|
|
* Sets a target device for this display and updates view
|
|
*
|
|
* @devnote
|
|
* Target device can't be a metafile (can't get char width out of a
|
|
* metafile)
|
|
*
|
|
* @rdesc
|
|
* TRUE if success
|
|
*/
|
|
BOOL CDisplayML::SetMainTargetDC (
|
|
HDC hdc, //@parm Target DC, NULL for same as rendering device
|
|
LONG dulTarget) //@parm Max line width (not used for screen)
|
|
{
|
|
TRACEBEGIN(TRCSUBSYSDISP, TRCSCOPEINTERN, "CDisplayML::SetMainTargetDC");
|
|
|
|
if(SetTargetDC(hdc))
|
|
{
|
|
// This is here because this is what RE 1.0 did.
|
|
SetWordWrap(hdc || !dulTarget);
|
|
|
|
// If dulTarget is greater than zero, then the caller is
|
|
// trying to set the maximum width of the window (for measuring,
|
|
// line breaking, etc.) However,in order to make our measuring
|
|
// algorithms more reasonable, we force the max size to be
|
|
// *at least* as wide as the width of a character.
|
|
// Note that dulTarget = 0 means use the view rect width
|
|
_dulTarget = (dulTarget <= 0) ? 0 : max(DXtoLX(GetDupSystemFont()), dulTarget);
|
|
// Need to do a full recalc. If it fails, it fails, the lines are
|
|
// left in a reasonable state. No need to call WaitForRecalc()
|
|
// because UpdateView() starts at position zero and we're always
|
|
// calc'd up to there
|
|
CDisplay::UpdateView();
|
|
|
|
// Caret/selection has most likely moved
|
|
CTxtSelection *psel = _ped->GetSelNC();
|
|
if(psel)
|
|
psel->UpdateCaret(FALSE);
|
|
return TRUE;
|
|
}
|
|
return FALSE;
|
|
}
|
|
|
|
// Useful for both main and printing devices. jonmat 6/08/1995
|
|
BOOL CDisplayML::SetTargetDC( HDC hdc, LONG dxpInch, LONG dypInch)
|
|
{
|
|
TRACEBEGIN(TRCSUBSYSDISP, TRCSCOPEINTERN, "CDisplayML::SetTargetDC");
|
|
|
|
CDevDesc *pddTarget = NULL;
|
|
|
|
// Don't allow metafiles to be set as the target device
|
|
if(hdc && GetDeviceCaps(hdc, TECHNOLOGY) == DT_METAFILE)
|
|
return FALSE;
|
|
|
|
if(hdc)
|
|
{
|
|
// Allocate device first to see if we can. We don't want to change
|
|
// our state if this is going to fail.
|
|
pddTarget = new CDevDesc(_ped);
|
|
if(!pddTarget)
|
|
return FALSE; // We couldn't so we are done
|
|
}
|
|
|
|
// Remove any cached information for the old target device
|
|
if(_pddTarget)
|
|
{
|
|
delete _pddTarget;
|
|
_pddTarget = NULL;
|
|
}
|
|
if(hdc)
|
|
{
|
|
_pddTarget = pddTarget; // Update device because we have one
|
|
_pddTarget->SetDC(hdc, dxpInch, dypInch);
|
|
}
|
|
return TRUE;
|
|
}
|
|
|
|
//================================= Line recalc ==============================
|
|
/*
|
|
* CDisplayML::RecalcScrollBars()
|
|
*
|
|
* @mfunc
|
|
* Recalculate the scroll bars if the view has changed.
|
|
*
|
|
*
|
|
* @devnote There is a possibility of recursion here, so we
|
|
* need to protect ourselves.
|
|
*
|
|
* To visualize this, consider two types of characters, 'a' characters
|
|
* which are small in height and 'A' 's which are really tall, but the same
|
|
* width as an 'a'. So if I have
|
|
*
|
|
* a a A <nl>
|
|
* A <nl>
|
|
*
|
|
* I'll get a calced size that's basically 2 * heightof(A).
|
|
* With a scrollbar, this could wordwrap to
|
|
*
|
|
* a a <nl>
|
|
* A A <nl>
|
|
*
|
|
* which is of calced size heightof(A) + heightof(a); this is
|
|
* obviously less than the height in the first case.
|
|
*/
|
|
void CDisplayML::RecalcScrollBars()
|
|
{
|
|
TRACEBEGIN(TRCSUBSYSDISP, TRCSCOPEINTERN, "CDisplayML::RecalcScrollBars");
|
|
|
|
if(_fViewChanged)
|
|
{
|
|
_fViewChanged = FALSE;
|
|
UpdateScrollBar(SB_VERT, TRUE);
|
|
UpdateScrollBar(SB_HORZ, TRUE);
|
|
}
|
|
}
|
|
|
|
/*
|
|
* CDisplayML::RecalcLines(rtp, fWait)
|
|
*
|
|
* @mfunc
|
|
* Recalc all line breaks.
|
|
* This method does a lazy calc after the last visible line
|
|
* except for a bottomless control
|
|
*
|
|
* @rdesc
|
|
* TRUE if success
|
|
*/
|
|
BOOL CDisplayML::RecalcLines (
|
|
CRchTxtPtr &rtp, //@parm Where change happened
|
|
BOOL fWait) //@parm Recalc lines down to _cpWait/_vpWait; then be lazy
|
|
{
|
|
TRACEBEGIN(TRCSUBSYSDISP, TRCSCOPEINTERN, "CDisplayML::RecalcLines");
|
|
|
|
LONG cliWait = cExtraBeforeLazy; // Extra lines before being lazy
|
|
BOOL fDone = TRUE;
|
|
BOOL fFirstInPara = TRUE;
|
|
CLine * pliNew = NULL;
|
|
LONG dupLineMax;
|
|
LONG dvp = 0;
|
|
LONG cchText = _ped->GetTextLength();
|
|
BOOL fWaitingForFirstVisible = TRUE;
|
|
LONG dvpView = _dvpView;
|
|
LONG dvpScrollOld = GetMaxVpScroll();
|
|
LONG dvpScrollNew;
|
|
|
|
DeleteSubLayouts(0, -1);
|
|
Remove(0, -1); // Remove all old lines from *this
|
|
_vpCalcMax = 0; // Set both maxes to start of text
|
|
_cpCalcMax = 0;
|
|
|
|
// Don't stop at bottom of view if we're bottomless and active.
|
|
if(!_ped->TxGetAutoSize() && IsActive())
|
|
{
|
|
// Be lazy - don't bother going past visible portion
|
|
_cpWait = -1;
|
|
_vpWait = -1;
|
|
fWait = TRUE;
|
|
}
|
|
|
|
CMeasurer me(this, rtp);
|
|
me.SetCp(0);
|
|
me.SetNumber(0);
|
|
|
|
// The following loop generates new lines
|
|
while(me.GetCp() < cchText)
|
|
{
|
|
// Add one new line
|
|
pliNew = Add(1, NULL);
|
|
if (!pliNew)
|
|
{
|
|
_ped->GetCallMgr()->SetOutOfMemory();
|
|
TRACEWARNSZ("Out of memory Recalc'ing lines");
|
|
goto err;
|
|
}
|
|
|
|
// Stuff text into new line
|
|
UINT uiFlags = MEASURE_BREAKATWORD |
|
|
(fFirstInPara ? MEASURE_FIRSTINPARA : 0);
|
|
|
|
Tracef(TRCSEVINFO, "Measuring new line from cp = %d", me.GetCp());
|
|
|
|
if(!Measure(me, pliNew, Count() - 1, uiFlags))
|
|
{
|
|
Assert(FALSE);
|
|
goto err;
|
|
}
|
|
|
|
fFirstInPara = pliNew->_fHasEOP;
|
|
dvp += pliNew->GetHeight();
|
|
_cpCalcMax = me.GetCp();
|
|
AssertSz(!IN_RANGE(STARTFIELD, me.GetPrevChar(), ENDFIELD), "Illegal cpCalcMax");
|
|
|
|
if(fWait)
|
|
{
|
|
// Do we want to do a background recalc? - the answer is yes if
|
|
// three things are true: (1) We have recalc'd beyond the old first
|
|
// visible character, (2) We have recalc'd beyond the visible
|
|
// portion of the screen and (3) we have gone beyond the next
|
|
// cExtraBeforeLazy lines to make page down go faster.
|
|
|
|
if(fWaitingForFirstVisible)
|
|
{
|
|
if(me.GetCp() > _cpFirstVisible)
|
|
{
|
|
_vpWait = dvp + dvpView;
|
|
fWaitingForFirstVisible = FALSE;
|
|
}
|
|
}
|
|
else if(dvp > _vpWait && cliWait-- <= 0 && me._rgpobjWrap.Count() == 0)
|
|
{
|
|
fDone = FALSE;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
//Create 1 line for empty controls
|
|
if(!Count())
|
|
CreateEmptyLine();
|
|
|
|
Paginate(0);
|
|
|
|
_vpCalcMax = dvp;
|
|
_fRecalcDone = fDone;
|
|
_fNeedRecalc = FALSE;
|
|
dvpScrollNew = CalcScrollHeight(dvp);
|
|
|
|
if(fDone && (dvp != _dvp || dvpScrollNew != dvpScrollOld)
|
|
|| dvpScrollNew > dvpScrollOld)
|
|
{
|
|
_fViewChanged = TRUE;
|
|
}
|
|
|
|
_dvp = dvp;
|
|
dupLineMax = CalcDisplayDup();
|
|
if(fDone && dupLineMax != _dupLineMax || dupLineMax > _dupLineMax)
|
|
{
|
|
_dupLineMax = dupLineMax;
|
|
_fViewChanged = TRUE;
|
|
}
|
|
|
|
Tracef(TRCSEVINFO, "CDisplayML::RecalcLine() - Done. Recalced down to line #%d", Count());
|
|
|
|
if(!fDone) // if not done, do rest in background
|
|
fDone = StartBackgroundRecalc();
|
|
|
|
if(fDone)
|
|
{
|
|
_vpWait = -1;
|
|
_cpWait = -1;
|
|
CheckLineArray();
|
|
_fLineRecalcErr = FALSE;
|
|
}
|
|
|
|
#if defined(DEBUG) && !defined(NOFULLDEBUG)
|
|
if( 1 )
|
|
{
|
|
_TEST_INVARIANT_
|
|
}
|
|
//Array memory allocation tracking
|
|
{
|
|
void **pv = (void**)((char*)this + sizeof(CDisplay) + sizeof(void*));
|
|
PvSet(*pv);
|
|
}
|
|
#endif
|
|
|
|
return TRUE;
|
|
|
|
err:
|
|
TRACEERRORSZ("CDisplayML::RecalcLines() failed");
|
|
|
|
if(!_fLineRecalcErr)
|
|
{
|
|
_cpCalcMax = me.GetCp();
|
|
AssertSz(!IN_RANGE(STARTFIELD, me.GetPrevChar(), ENDFIELD), "Illegal cpCalcMax");
|
|
_vpCalcMax = dvp;
|
|
_fLineRecalcErr = TRUE;
|
|
_ped->GetCallMgr()->SetOutOfMemory();
|
|
_fLineRecalcErr = FALSE; // fix up CArray & bail
|
|
}
|
|
return FALSE;
|
|
}
|
|
|
|
/*
|
|
* CDisplayML::RecalcLines(rtp, cchOld, cchNew, fBackground, fWait, pled)
|
|
*
|
|
* @mfunc
|
|
* Recompute line breaks after text modification
|
|
*
|
|
* @rdesc
|
|
* TRUE if success
|
|
*
|
|
* @devnote
|
|
* Most people call this the trickiest piece of code in RichEdit...
|
|
*/
|
|
BOOL CDisplayML::RecalcLines (
|
|
CRchTxtPtr &rtp, //@parm Where change happened
|
|
LONG cchOld, //@parm Count of chars deleted
|
|
LONG cchNew, //@parm Count of chars added
|
|
BOOL fBackground, //@parm This method called as background process
|
|
BOOL fWait, //@parm Recalc lines down to _cpWait/_vpWait; then be lazy
|
|
CLed *pled) //@parm Returns edit impact on lines (can be NULL)
|
|
{
|
|
TRACEBEGIN(TRCSUBSYSDISP, TRCSCOPEINTERN, "CDisplayML::RecalcLines");
|
|
|
|
LONG cchEdit;
|
|
LONG cchSkip;
|
|
LONG cliBackedUp = 0;
|
|
LONG cliWait = cExtraBeforeLazy;
|
|
BOOL fDone = TRUE;
|
|
BOOL fFirstInPara = TRUE;
|
|
LONG ili;
|
|
CLed led;
|
|
LONG lT = 0; // long Temporary
|
|
LONG iliMain;
|
|
CLine * pliMain;
|
|
CLine * pliNew;
|
|
CLinePtr rpOld(this);
|
|
LONG dupLineMax;
|
|
LONG dvp;
|
|
LONG dvpPrev = 0;
|
|
LONG cchText = _ped->GetTextLength();
|
|
UINT uiFlags;
|
|
BOOL fReplaceResult;
|
|
LONG dvpExtraLine = 0;
|
|
LONG dvpScrollOld = GetMaxVpScroll();
|
|
LONG dvpScrollNew;
|
|
WORD wNumber = 0;
|
|
CLineArray rgliNew;
|
|
DWORD dwBgndTickMax = fBackground ? GetTickCount() + cmsecBgndBusy : 0;
|
|
|
|
if(!pled)
|
|
pled = &led;
|
|
|
|
#if defined(DEBUG) || defined(_RELEASE_ASSERTS_)
|
|
LONG cp = rtp.GetCp();
|
|
|
|
if(cp > _cpCalcMax)
|
|
Tracef(TRCSEVERR, "rtp %ld, _cpCalcMax %ld", cp, _cpCalcMax);
|
|
|
|
AssertSz(cp <= _cpCalcMax, "CDisplayML::RecalcLines Caller didn't setup RecalcLines()");
|
|
AssertSz(!(fWait && fBackground), "CDisplayML::RecalcLines wait and background both true");
|
|
AssertSz(!(fWait && (-1 == _cpWait) && (-1 == _vpWait)),
|
|
"CDisplayML::RecalcLines background recalc parms invalid");
|
|
#endif
|
|
|
|
// We will not use background recalc if this is already a background recalc,
|
|
// or if the control is not active or if this is an auto sized control.
|
|
if(!IsActive() || _ped->TxGetAutoSize())
|
|
fWait = FALSE;
|
|
|
|
// Init line pointer on old CLayout and backup to start of line
|
|
rpOld.SetCp(rtp.GetCp(), FALSE);
|
|
cchSkip = rpOld.GetIch();
|
|
rpOld.Move(-cchSkip); // Point rp at 1st char in line
|
|
|
|
ili = rpOld; // Save line # at change for
|
|
if(!Elem(ili)->IsNestedLayout()) // numbering
|
|
{
|
|
if(ili && (IsInOutlineView() || // Back up if not first number
|
|
rtp.GetPF()->IsListNumbered())) // in list or if in OutlineView
|
|
{ // (Outline symbol may change)
|
|
ili--;
|
|
}
|
|
|
|
// Back up at least one line in case we can now fit more on it
|
|
// If on a line border, e.g., just inserted an EOP, backup 2; else 1
|
|
lT = !cchSkip + 1;
|
|
|
|
while(rpOld > 0 &&
|
|
((lT-- && (!rpOld[-1]._cchEOP || ili < rpOld)) ||
|
|
(rpOld[-1]._cObjectWrapLeft || rpOld[-1]._cObjectWrapRight)))
|
|
{
|
|
cliBackedUp++;
|
|
rpOld--;
|
|
cchSkip += rpOld->_cch;
|
|
}
|
|
}
|
|
|
|
// Init measurer at rtp
|
|
CMeasurer me(this, rtp);
|
|
|
|
me.Move(-cchSkip); // Point at start of text to measure
|
|
cchEdit = cchNew + cchSkip; // Number of chars affected by edit
|
|
me.SetNumber(rpOld.GetNumber()); // Initialize list number
|
|
|
|
// Determine whether we're on first line of paragraph
|
|
if(rpOld > 0)
|
|
{
|
|
fFirstInPara = rpOld[-1]._fHasEOP;
|
|
me.SetIhyphPrev(rpOld[-1]._ihyph);
|
|
}
|
|
|
|
dvp = VposFromLine(this, rpOld);
|
|
|
|
// Update first-affected and pre-edit-match lines in pled
|
|
pled->_iliFirst = rpOld;
|
|
pled->_cpFirst = pled->_cpMatchOld = me.GetCp();
|
|
pled->_vpFirst = pled->_vpMatchOld = dvp;
|
|
AssertSz(pled->_vpFirst >= 0, "CDisplayML::RecalcLines _vpFirst < 0");
|
|
|
|
Tracef(TRCSEVINFO, "Start recalcing from line #%d, cp=%d", pled->_iliFirst, pled->_cpFirst);
|
|
|
|
// In case of error, set both maxes to where we are now
|
|
_vpCalcMax = dvp;
|
|
_cpCalcMax = me.GetCp();
|
|
AssertSz(!IN_RANGE(STARTFIELD, me.GetPrevChar(), ENDFIELD), "Illegal cpCalcMax");
|
|
|
|
// If we are past the requested area to recalc and background recalc is
|
|
// allowed, then just go directly to background recalc. If there is no
|
|
// height, we just go ahead and calculate some lines anyway. This
|
|
// prevents any weird background recalcs from occuring when it is
|
|
// unnecessary to go into background recalc.
|
|
if(fWait && _vpWait > 0 && dvp > _vpWait && me.GetCp() > _cpWait)
|
|
{
|
|
_dvp = dvp;
|
|
DeleteSubLayouts((LONG)rpOld, -1);
|
|
rpOld.Remove(-1); // Remove all old lines from here on
|
|
StartBackgroundRecalc(); // Start up the background recalc
|
|
pled->SetMax(this);
|
|
return TRUE;
|
|
}
|
|
|
|
pliMain = NULL;
|
|
iliMain = rpOld.GetLineIndex();
|
|
if (iliMain)
|
|
{
|
|
iliMain--;
|
|
pliMain = rpOld.GetLine() - 1;
|
|
}
|
|
pliNew = NULL;
|
|
|
|
// The following loop generates new lines for each line we backed
|
|
// up over and for lines directly affected by edit
|
|
while(cchEdit > 0)
|
|
{
|
|
pliNew = rgliNew.Add(1, NULL); // Add one new line
|
|
if (!pliNew)
|
|
{
|
|
TRACEWARNSZ("CDisplayML::RecalcLines unable to alloc additional CLine in CLineArray");
|
|
goto errspace;
|
|
}
|
|
|
|
uiFlags = MEASURE_BREAKATWORD | (fFirstInPara ? MEASURE_FIRSTINPARA : 0);
|
|
|
|
// Stuff text into new line
|
|
Tracef(TRCSEVINFO, "Measuring new line from cp = %d", me.GetCp());
|
|
|
|
dvpExtraLine = 0;
|
|
if(!Measure(me, pliNew, rgliNew.Count() - 1, uiFlags, 0, iliMain, pliMain, &dvpExtraLine))
|
|
{
|
|
Assert(FALSE);
|
|
goto err;
|
|
}
|
|
|
|
Assert(pliNew->_cch);
|
|
|
|
fFirstInPara = pliNew->_fHasEOP;
|
|
dvpPrev = dvp;
|
|
dvp += pliNew->GetHeight();
|
|
cchEdit -= pliNew->_cch;
|
|
AssertSz(cchEdit + me.GetCp() <= cchText, "CDisplayML::RecalcLines: want to measure beyond EOD");
|
|
|
|
// Calculate on what line the edit started. We do this because
|
|
// we want to render the first edited line off screen so if
|
|
// the line is being edited via the keyboard we don't clip
|
|
// any characters.
|
|
if(cchSkip > 0)
|
|
{
|
|
// Check whether we backed up and the line we are examining
|
|
// changed at all. Even if it didn't change in outline view
|
|
// have to redraw in case outline symbol changes
|
|
if (cliBackedUp && cchSkip >= pliNew->_cch &&
|
|
pliNew->IsEqual(*(CLine *)(rpOld.GetLine())) && !IsInOutlineView()
|
|
&& !pliNew->_cObjectWrapLeft && !pliNew->_cObjectWrapRight)
|
|
{
|
|
// Perfect match, this line was not the first edited.
|
|
Tracef(TRCSEVINFO, "New line matched old line #%d", (LONG)rpOld);
|
|
|
|
cchSkip -= rpOld->_cch;
|
|
|
|
// Update first affected line and match in pled
|
|
pled->_iliFirst++;
|
|
pled->_cpFirst += rpOld->_cch;
|
|
pled->_cpMatchOld += rpOld->_cch;
|
|
pled->_vpFirst += rpOld->GetHeight();
|
|
AssertSz(pled->_vpFirst >= 0, "CDisplayML::RecalcLines _vpFirst < 0");
|
|
pled->_vpMatchOld += rpOld->GetHeight();
|
|
cliBackedUp--;
|
|
|
|
rgliNew.Clear(AF_KEEPMEM); // Discard new line
|
|
if(!(rpOld++)) // Next line
|
|
cchSkip = 0;
|
|
}
|
|
else // No match in the line, so
|
|
cchSkip = 0; // this line is the first to
|
|
} // be edited
|
|
|
|
if(fBackground && GetTickCount() >= dwBgndTickMax)
|
|
{
|
|
fDone = FALSE; // took too long, stop for now
|
|
goto no_match;
|
|
}
|
|
|
|
if (fWait && dvp > _vpWait && me.GetCp() > _cpWait && cliWait-- <= 0)
|
|
{
|
|
// Not really done, just past region we're waiting for
|
|
// so let background recalc take it from here
|
|
fDone = FALSE;
|
|
goto no_match;
|
|
}
|
|
} // while(cchEdit > 0) { }
|
|
|
|
Tracef(TRCSEVINFO, "Done recalcing edited text. Created %d new lines", rgliNew.Count());
|
|
|
|
// Edit lines have been exhausted. Continue breaking lines,
|
|
// but try to match new & old breaks
|
|
|
|
wNumber = me._wNumber;
|
|
|
|
while(me.GetCp() < cchText)
|
|
{
|
|
// We are trying for a match so assume that there
|
|
// is a match after all
|
|
BOOL frpOldValid = TRUE;
|
|
|
|
// Look for match in old line break CArray
|
|
lT = me.GetCp() - cchNew + cchOld;
|
|
while (rpOld.IsValid() && pled->_cpMatchOld < lT)
|
|
{
|
|
pled->_vpMatchOld += rpOld->GetHeight();
|
|
pled->_cpMatchOld += rpOld->_cch;
|
|
|
|
if(!rpOld.NextRun())
|
|
{
|
|
// No more line array entries so we can give up on
|
|
// trying to match for good.
|
|
frpOldValid = FALSE;
|
|
break;
|
|
}
|
|
}
|
|
|
|
// If perfect match, stop.
|
|
if (frpOldValid && rpOld.IsValid() && pled->_cpMatchOld == lT &&
|
|
rpOld->_cch && me._wNumber == rpOld->_bNumber)
|
|
{
|
|
Tracef(TRCSEVINFO, "Found match with old line #%d", rpOld.GetLineIndex());
|
|
|
|
// Update fliFirstInPara flag in 1st old line that matches. Note
|
|
// that if the new array doesn't have any lines, we have to look
|
|
// into the line array preceding the current change.
|
|
rpOld->_fFirstInPara = TRUE;
|
|
if(rgliNew.Count() > 0)
|
|
{
|
|
if(!(rgliNew.Elem(rgliNew.Count() - 1)->_fHasEOP))
|
|
rpOld->_fFirstInPara = FALSE;
|
|
}
|
|
else if(rpOld >= pled->_iliFirst && pled->_iliFirst)
|
|
{
|
|
if(!(rpOld[pled->_iliFirst - rpOld - 1]._fHasEOP))
|
|
rpOld->_fFirstInPara = FALSE;
|
|
}
|
|
|
|
pled->_iliMatchOld = rpOld;
|
|
|
|
// Replace old lines by new ones
|
|
lT = rpOld - pled->_iliFirst;
|
|
rpOld = pled->_iliFirst;
|
|
DeleteSubLayouts(pled->_iliFirst, lT);
|
|
if(!rpOld.Replace (lT, &rgliNew))
|
|
{
|
|
TRACEWARNSZ("CDisplayML::RecalcLines unable to alloc additional CLines in rpOld");
|
|
goto errspace;
|
|
}
|
|
frpOldValid = rpOld.ChgRun(rgliNew.Count());
|
|
rgliNew.Clear(AF_KEEPMEM); // Clear aux array
|
|
|
|
// Remember information about match after editing
|
|
Assert((cp = rpOld.CalculateCp()) == me.GetCp());
|
|
pled->_vpMatchOld += dvpExtraLine;
|
|
pled->_vpMatchNew = dvp + dvpExtraLine;
|
|
pled->_vpMatchNewTop = dvpPrev;
|
|
pled->_iliMatchNew = rpOld;
|
|
pled->_cpMatchNew = me.GetCp();
|
|
|
|
// Compute height and cp after all matches
|
|
_cpCalcMax = me.GetCp();
|
|
AssertSz(!IN_RANGE(STARTFIELD, me.GetPrevChar(), ENDFIELD), "Illegal cpCalcMax");
|
|
|
|
if(frpOldValid && rpOld.IsValid())
|
|
{
|
|
do
|
|
{
|
|
dvp += rpOld->GetHeight();
|
|
_cpCalcMax += rpOld->_cch;
|
|
}
|
|
while( rpOld.NextRun() );
|
|
#ifdef DEBUG
|
|
CTxtPtr tp(_ped, _cpCalcMax);
|
|
AssertSz(!IN_RANGE(STARTFIELD, tp.GetPrevChar(), ENDFIELD), "Illegal cpCalcMax");
|
|
#endif
|
|
}
|
|
|
|
// Make sure _cpCalcMax is sane after the above update
|
|
AssertSz(_cpCalcMax <= cchText, "CDisplayML::RecalcLines match extends beyond EOF");
|
|
|
|
// We stop calculating here.Note that if _cpCalcMax < size
|
|
// of text, this means a background recalc is in progress.
|
|
// We will let that background recalc get the arrays
|
|
// fully in sync.
|
|
|
|
AssertSz(_cpCalcMax == cchText || _fBgndRecalc,
|
|
"CDisplayML::Match less but no background recalc");
|
|
|
|
if(_cpCalcMax != cchText)
|
|
{
|
|
// This is going to be finished by the background recalc
|
|
// so set the done flag appropriately.
|
|
fDone = FALSE;
|
|
}
|
|
goto match;
|
|
}
|
|
|
|
// Add a new line
|
|
pliNew = rgliNew.Add(1, NULL);
|
|
if(!pliNew)
|
|
{
|
|
TRACEWARNSZ("CDisplayML::RecalcLines unable to alloc additional CLine in CLineArray");
|
|
goto errspace;
|
|
}
|
|
|
|
Tracef(TRCSEVINFO, "Measuring new line from cp = %d", me.GetCp());
|
|
|
|
// Stuff some text into new line
|
|
wNumber = me._wNumber;
|
|
if(!Measure(me, pliNew, rgliNew.Count() - 1,
|
|
MEASURE_BREAKATWORD | (fFirstInPara ? MEASURE_FIRSTINPARA : 0), 0,
|
|
iliMain, pliMain))
|
|
{
|
|
Assert(FALSE);
|
|
goto err;
|
|
}
|
|
|
|
fFirstInPara = pliNew->_fHasEOP;
|
|
dvp += pliNew->GetHeight();
|
|
|
|
if(fBackground && GetTickCount() >= (DWORD)dwBgndTickMax)
|
|
{
|
|
fDone = FALSE; // Took too long, stop for now
|
|
break;
|
|
}
|
|
|
|
if(fWait && dvp > _vpWait && me.GetCp() > _cpWait
|
|
&& cliWait-- <= 0 && me._rgpobjWrap.Count() == 0)
|
|
{ // Not really done, just past region we're
|
|
fDone = FALSE; // waiting for so let background recalc
|
|
break; // take it from here
|
|
}
|
|
} // while(me < cchText) ...
|
|
|
|
no_match:
|
|
// Didn't find match: whole line array from _iliFirst needs to be changed
|
|
pled->_iliMatchOld = Count();
|
|
pled->_cpMatchOld = cchText;
|
|
pled->_vpMatchNew = dvp;
|
|
pled->_vpMatchNewTop = dvpPrev;
|
|
pled->_vpMatchOld = _dvp;
|
|
_cpCalcMax = me.GetCp();
|
|
AssertSz(!IN_RANGE(STARTFIELD, me.GetPrevChar(), ENDFIELD), "Illegal cpCalcMax");
|
|
|
|
// Replace old lines by new ones
|
|
rpOld = pled->_iliFirst;
|
|
|
|
// We store the result from the replace because although it can fail the
|
|
// fields used for first visible must be set to something sensible whether
|
|
// the replace fails or not. Further, the setting up of the first visible
|
|
// fields must happen after the Replace because the lines could have
|
|
// changed in length which in turns means that the first visible position
|
|
// has failed.
|
|
|
|
DeleteSubLayouts(rpOld, -1);
|
|
fReplaceResult = rpOld.Replace(-1, &rgliNew);
|
|
|
|
// _iliMatchNew & _cpMatchNew are used for first visible constants so we
|
|
// need to set them to something reasonable. In particular the rendering
|
|
// logic expects _cpMatchNew to be set to the first character of the first
|
|
// visible line. rpOld is used because it is convenient.
|
|
|
|
// Note we can't use RpBindToCp at this point because the first visible
|
|
// information is screwed up because we may have changed the line that
|
|
// the first visible cp is on.
|
|
rpOld.BindToCp(me.GetCp(), cchText);
|
|
pled->_iliMatchNew = rpOld.GetLineIndex();
|
|
pled->_cpMatchNew = me.GetCp() - rpOld.GetIch();
|
|
|
|
if (!fReplaceResult)
|
|
{
|
|
TRACEERRORSZ("CDisplayML::RecalcLines rpOld.Replace() failed");
|
|
goto errspace;
|
|
}
|
|
|
|
// Adjust first affected line if this line is gone
|
|
// after replacing by new lines
|
|
if(pled->_iliFirst >= Count() && Count() > 0)
|
|
{
|
|
Assert(pled->_iliFirst == Count());
|
|
pled->_iliFirst = Count() - 1;
|
|
pliNew = Elem(pled->_iliFirst);
|
|
pled->_vpFirst -= pliNew->GetHeight();
|
|
AssertSz(pled->_vpFirst >= 0, "CDisplayML::RecalcLines _vpFirst < 0");
|
|
pled->_cpFirst -= pliNew->_cch;
|
|
}
|
|
|
|
#ifdef DEBUG
|
|
if (_ped->GetTextLength())
|
|
Assert(Count());
|
|
#endif
|
|
|
|
//Create 1 line for empty controls
|
|
if(!Count())
|
|
CreateEmptyLine();
|
|
|
|
match:
|
|
_fRecalcDone = fDone;
|
|
_fNeedRecalc = FALSE;
|
|
_vpCalcMax = dvp;
|
|
|
|
Tracef(TRCSEVINFO, "CDisplayML::RecalcLine(rtp, ...) - Done. Recalced down to line #%d", Count() - 1);
|
|
|
|
// Clear wait fields since we want caller's to set them up.
|
|
_vpWait = -1;
|
|
_cpWait = -1;
|
|
|
|
if(fDone && fBackground)
|
|
{
|
|
TRACEINFOSZ("Background line recalc done");
|
|
_ped->TxKillTimer(RETID_BGND_RECALC);
|
|
_fBgndRecalc = FALSE;
|
|
_fRecalcDone = TRUE;
|
|
}
|
|
|
|
// Determine display height and update scrollbar
|
|
dvpScrollNew = CalcScrollHeight(dvp);
|
|
|
|
if (_fViewChanged || fDone && (dvp != _dvp || dvpScrollNew != dvpScrollOld)
|
|
|| dvpScrollNew > dvpScrollOld)
|
|
{
|
|
//!NOTE:
|
|
// UpdateScrollBar can cause a resize of the window by hiding or showing
|
|
// scrollbars. As a consequence of resizing the lines may get recalculated
|
|
// therefore updating _dvp to a new value, something != to dvp.
|
|
_dvp = dvp;
|
|
UpdateScrollBar(SB_VERT, TRUE);
|
|
}
|
|
else
|
|
_dvp = dvp; // Guarantee heights agree
|
|
|
|
// Determine display width and update scrollbar
|
|
dupLineMax = CalcDisplayDup();
|
|
if(_fViewChanged || (fDone && dupLineMax != _dupLineMax) || dupLineMax > _dupLineMax)
|
|
{
|
|
_dupLineMax = dupLineMax;
|
|
UpdateScrollBar(SB_HORZ, TRUE);
|
|
}
|
|
|
|
_fViewChanged = FALSE;
|
|
|
|
// If not done, do the rest in background
|
|
if(!fDone && !fBackground)
|
|
fDone = StartBackgroundRecalc();
|
|
|
|
if(fDone)
|
|
{
|
|
CheckLineArray();
|
|
_fLineRecalcErr = FALSE;
|
|
}
|
|
|
|
#ifdef DEBUG
|
|
if( 1 )
|
|
{
|
|
_TEST_INVARIANT_
|
|
}
|
|
#endif // DEBUG
|
|
|
|
Paginate(pled->_iliFirst);
|
|
return TRUE;
|
|
|
|
errspace:
|
|
_ped->GetCallMgr()->SetOutOfMemory();
|
|
_fNeedRecalc = TRUE;
|
|
_cpCalcMax = _vpCalcMax = 0;
|
|
_fLineRecalcErr = TRUE;
|
|
|
|
err:
|
|
if(!_fLineRecalcErr)
|
|
{
|
|
_cpCalcMax = me.GetCp();
|
|
AssertSz(!IN_RANGE(STARTFIELD, me.GetPrevChar(), ENDFIELD), "Illegal cpCalcMax");
|
|
_vpCalcMax = dvp;
|
|
}
|
|
|
|
TRACEERRORSZ("CDisplayML::RecalcLines() failed");
|
|
|
|
if(!_fLineRecalcErr)
|
|
{
|
|
_fLineRecalcErr = TRUE;
|
|
_ped->GetCallMgr()->SetOutOfMemory();
|
|
_fLineRecalcErr = FALSE; // fix up CArray & bail
|
|
}
|
|
pled->SetMax(this);
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
/*
|
|
* CDisplayML::CalcDisplayDup()
|
|
*
|
|
* @mfunc
|
|
* Calculates width of this display by walking line CArray and
|
|
* returning widest line. Used for horizontal scrollbar routines.
|
|
*
|
|
* @rdesc
|
|
* Widest line width in display
|
|
*/
|
|
LONG CDisplayML::CalcDisplayDup()
|
|
{
|
|
TRACEBEGIN(TRCSUBSYSDISP, TRCSCOPEINTERN, "CDisplayML::CalcDisplayDup");
|
|
|
|
LONG dupLineMax = 0;
|
|
|
|
if (_ped->fInOurHost() && (_ped->GetHost())->TxGetHorzExtent(&dupLineMax) == S_OK)
|
|
{
|
|
return dupLineMax;
|
|
}
|
|
|
|
LONG ili = Count();
|
|
CLine *pli;
|
|
|
|
if(ili)
|
|
{
|
|
LONG dupLine;
|
|
pli = Elem(0);
|
|
|
|
for(dupLineMax = 0; ili--; pli++)
|
|
{
|
|
dupLine = pli->_upStart + pli->_dup;
|
|
dupLineMax = max(dupLineMax, dupLine);
|
|
}
|
|
}
|
|
return dupLineMax;
|
|
}
|
|
|
|
/*
|
|
* CDisplayML::StartBackgroundRecalc()
|
|
*
|
|
* @mfunc
|
|
* Starts background line recalc (at _cpCalcMax position)
|
|
*
|
|
* @rdesc
|
|
* TRUE if done with background recalc
|
|
*/
|
|
BOOL CDisplayML::StartBackgroundRecalc()
|
|
{
|
|
TRACEBEGIN(TRCSUBSYSDISP, TRCSCOPEINTERN, "CDisplayML::StartBackgroundRecalc");
|
|
|
|
if(_fBgndRecalc)
|
|
return FALSE; // Already in background recalc
|
|
|
|
AssertSz(_cpCalcMax <= _ped->GetTextLength(), "_cpCalcMax > text length");
|
|
|
|
if(_cpCalcMax == _ped->GetTextLength())
|
|
return TRUE; // Enough chars are recalc'd
|
|
|
|
if(!_ped->TxSetTimer(RETID_BGND_RECALC, cmsecBgndInterval))
|
|
{
|
|
// Could not instantiate a timer so wait for recalculation
|
|
WaitForRecalc(_ped->GetTextLength(), -1);
|
|
return TRUE;
|
|
}
|
|
|
|
_fRecalcDone = FALSE;
|
|
_fBgndRecalc = TRUE;
|
|
return FALSE;
|
|
}
|
|
|
|
/*
|
|
* CDisplayML::StepBackgroundRecalc()
|
|
*
|
|
* @mfunc
|
|
* Steps background line recalc (at _cpCalcMax position)
|
|
* Called by timer proc and also when going inactive.
|
|
*/
|
|
void CDisplayML::StepBackgroundRecalc()
|
|
{
|
|
TRACEBEGIN(TRCSUBSYSDISP, TRCSCOPEINTERN, "CDisplayML::StepBackgroundRecalc");
|
|
|
|
_TEST_INVARIANT_
|
|
|
|
if(!_fBgndRecalc) // Not in background recalc,
|
|
return; // so don't do anything
|
|
|
|
LONG cch = _ped->GetTextLength() - _cpCalcMax;
|
|
|
|
// Don't try recalc when processing OOM or had an error doing recalc or
|
|
// if we are asserting.
|
|
#ifdef DEBUG
|
|
if(_fInBkgndRecalc || _fLineRecalcErr)
|
|
{
|
|
if(_fInBkgndRecalc)
|
|
TRACEINFOSZ("avoiding reentrant background recalc");
|
|
else
|
|
TRACEINFOSZ("OOM: not stepping recalc");
|
|
return;
|
|
}
|
|
#else
|
|
if(_fInBkgndRecalc || _fLineRecalcErr)
|
|
return;
|
|
#endif
|
|
|
|
_fInBkgndRecalc = TRUE;
|
|
if(!IsActive())
|
|
{
|
|
// Background recalc is over if we are no longer active because
|
|
// we can no longer get the information we need for recalculating.
|
|
// But, if we are half recalc'd we need to set ourselves up to
|
|
// recalc again when we go active.
|
|
InvalidateRecalc();
|
|
cch = 0;
|
|
}
|
|
|
|
// Background recalc is over if no more chars or no longer active
|
|
if(cch <= 0)
|
|
{
|
|
TRACEINFOSZ("Background line recalc done");
|
|
_ped->TxKillTimer(RETID_BGND_RECALC);
|
|
_fBgndRecalc = FALSE;
|
|
_fRecalcDone = TRUE;
|
|
_fInBkgndRecalc = FALSE;
|
|
CheckLineArray();
|
|
return;
|
|
}
|
|
|
|
CRchTxtPtr rtp(_ped, _cpCalcMax);
|
|
AssertSz(!IN_RANGE(STARTFIELD, rtp.GetPrevChar(), ENDFIELD), "Illegal cpCalcMax");
|
|
RecalcLines(rtp, cch, cch, TRUE, FALSE, NULL);
|
|
|
|
_fInBkgndRecalc = FALSE;
|
|
}
|
|
|
|
/*
|
|
* CDisplayML::WaitForRecalc(cpMax, vpMax)
|
|
*
|
|
* @mfunc
|
|
* Ensures that lines are recalced until a specific character
|
|
* position or vPos.
|
|
*
|
|
* @rdesc
|
|
* success
|
|
*/
|
|
BOOL CDisplayML::WaitForRecalc(
|
|
LONG cpMax, //@parm Position recalc up to (-1 to ignore)
|
|
LONG vpMax) //@parm vPos to recalc up to (-1 to ignore)
|
|
{
|
|
TRACEBEGIN(TRCSUBSYSDISP, TRCSCOPEINTERN, "CDisplayML::WaitForRecalc");
|
|
|
|
_TEST_INVARIANT_
|
|
|
|
if(IsFrozen())
|
|
return TRUE;
|
|
|
|
BOOL fReturn = TRUE;
|
|
LONG cch;
|
|
|
|
if((vpMax < 0 || vpMax >= _vpCalcMax) &&
|
|
(cpMax < 0 || cpMax >= _cpCalcMax))
|
|
{
|
|
cch = _ped->GetTextLength() - _cpCalcMax;
|
|
if(cch > 0 || Count() == 0)
|
|
{
|
|
HCURSOR hcur = NULL;
|
|
|
|
_cpWait = cpMax;
|
|
_vpWait = vpMax;
|
|
|
|
if(cch > NUMCHARFORWAITCURSOR)
|
|
hcur = _ped->TxSetCursor(LoadCursor(0, IDC_WAIT));
|
|
TRACEINFOSZ("Lazy recalc");
|
|
|
|
CRchTxtPtr rtp(_ped, _cpCalcMax);
|
|
if(!_cpCalcMax || _fNeedRecalc)
|
|
{
|
|
fReturn = RecalcLines(rtp, TRUE);
|
|
RebindFirstVisible();
|
|
if(!fReturn)
|
|
InitVars();
|
|
}
|
|
else
|
|
fReturn = RecalcLines(rtp, cch, cch, FALSE, TRUE, NULL);
|
|
|
|
if(hcur)
|
|
_ped->TxSetCursor(hcur);
|
|
}
|
|
else if(!cch)
|
|
{
|
|
// If there was nothing else to calc, make sure that we think
|
|
// recalc is done.
|
|
#ifdef DEBUG
|
|
if( !_fRecalcDone )
|
|
{
|
|
TRACEWARNSZ("For some reason we didn't think background "
|
|
"recalc was done, but it was!!");
|
|
}
|
|
#endif // DEBUG
|
|
_fRecalcDone = TRUE;
|
|
}
|
|
}
|
|
|
|
// If view rect changed, make sure to update scrollbars
|
|
RecalcScrollBars();
|
|
|
|
return fReturn;
|
|
}
|
|
|
|
/*
|
|
* CDisplayML::WaitForRecalcIli(ili)
|
|
*
|
|
* @mfunc
|
|
* Wait until line array is recalculated up to line <p ili>
|
|
*
|
|
* @rdesc
|
|
* Returns TRUE if lines were recalc'd up to ili
|
|
*/
|
|
//REVIEW (keithcu) This recalcs up to the end! I'm not certain how great
|
|
//our background recalc, etc. stuff is. It seems not to work all that well for
|
|
//the complexity it adds to our codebase. I think we should either throw it
|
|
//away or redo it.
|
|
BOOL CDisplayML::WaitForRecalcIli (
|
|
LONG ili) //@parm Line index to recalculate line array up to
|
|
{
|
|
TRACEBEGIN(TRCSUBSYSDISP, TRCSCOPEINTERN, "CDisplayML::WaitForRecalcIli");
|
|
|
|
LONG cchGuess;
|
|
|
|
while(!_fRecalcDone && ili >= Count())
|
|
{
|
|
// just go ahead and recalc everything.
|
|
cchGuess = _ped->GetTextLength();
|
|
if(IsFrozen() || !WaitForRecalc(cchGuess, -1))
|
|
return FALSE;
|
|
}
|
|
return ili < Count();
|
|
}
|
|
|
|
/*
|
|
* CDisplayML::WaitForRecalcView()
|
|
*
|
|
* @mfunc
|
|
* Ensure visible lines are completly recalced
|
|
*
|
|
* @rdesc TRUE iff successful
|
|
*/
|
|
BOOL CDisplayML::WaitForRecalcView()
|
|
{
|
|
TRACEBEGIN(TRCSUBSYSDISP, TRCSCOPEINTERN, "CDisplayML::WaitForRecalcView");
|
|
|
|
return WaitForRecalc(-1, _vpScroll + _dvpView);
|
|
}
|
|
|
|
/*
|
|
* CDisplayML::InitLinePtr ( CLinePtr & plp )
|
|
*
|
|
* @mfunc
|
|
* Initialize a CLinePtr properly
|
|
*/
|
|
void CDisplayML::InitLinePtr (
|
|
CLinePtr & plp ) //@parm Ptr to line to initialize
|
|
{
|
|
TRACEBEGIN(TRCSUBSYSDISP, TRCSCOPEINTERN, "CDisplayML::InitLinePtr");
|
|
|
|
plp.Init( *this );
|
|
}
|
|
|
|
/*
|
|
* CDisplayML::GetLineText(ili, pchBuff, cchMost)
|
|
*
|
|
* @mfunc
|
|
* Copy given line of this display into a character buffer
|
|
*
|
|
* @rdesc
|
|
* number of character copied
|
|
*/
|
|
LONG CDisplayML::GetLineText(
|
|
LONG ili, //@parm Line to get text of
|
|
TCHAR *pchBuff, //@parm Buffer to stuff text into
|
|
LONG cchMost) //@parm Length of buffer
|
|
{
|
|
TRACEBEGIN(TRCSUBSYSDISP, TRCSCOPEINTERN, "CDisplayML::GetLineText");
|
|
|
|
_TEST_INVARIANT_
|
|
|
|
CTxtPtr tp (_ped, 0);
|
|
|
|
if(ili >= 0 && (ili < Count() || WaitForRecalcIli(ili)))
|
|
{
|
|
cchMost = min(cchMost, Elem(ili)->_cch);
|
|
if(cchMost > 0)
|
|
{
|
|
tp.SetCp(CpFromLine(ili, NULL));
|
|
return tp.GetText(cchMost, pchBuff);
|
|
}
|
|
}
|
|
*pchBuff = TEXT('\0');
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
* CDisplayML::LineCount
|
|
*
|
|
* @mfunc returns the number of lines in this control. Note that for plain
|
|
* text mode, we will add on an extra line of the last character is
|
|
* a CR. This is for compatibility with MLE
|
|
*
|
|
* @rdesc LONG
|
|
*/
|
|
LONG CDisplayML::LineCount() const
|
|
{
|
|
LONG cLine = Count();
|
|
|
|
if (!_ped->IsRich() && (!cLine || // If plain text with no lines
|
|
Elem(cLine - 1)->_cchEOP)) // or last line ending with a CR,
|
|
{ // then inc line count
|
|
cLine++;
|
|
}
|
|
return cLine;
|
|
}
|
|
|
|
// ================================ Line info retrieval ====================================
|
|
|
|
|
|
/*
|
|
* CDisplayML::CpFromLine(ili, pdvp)
|
|
*
|
|
* @mfunc
|
|
* Computes cp at start of given line
|
|
* (and top of line position relative to this display)
|
|
*
|
|
* @rdesc
|
|
* cp of given line
|
|
*/
|
|
LONG CDisplayML::CpFromLine (
|
|
LONG ili, //@parm Line we're interested in (if <lt> 0 means caret line)
|
|
LONG *pdvp) //@parm Returns top of line relative to display
|
|
// (NULL if don't want that info)
|
|
{
|
|
TRACEBEGIN(TRCSUBSYSDISP, TRCSCOPEINTERN, "CDisplayML::CpFromLine");
|
|
|
|
_TEST_INVARIANT_
|
|
|
|
LONG cli;
|
|
LONG vp = _vpScroll + _dvpFirstVisible;
|
|
LONG cp = _cpFirstVisible;
|
|
CLine *pli;
|
|
LONG iStart = _iliFirstVisible;
|
|
|
|
cli = ili - _iliFirstVisible;
|
|
if(cli < 0 && -cli >= ili)
|
|
{
|
|
// Closer to first line than to first visible line,
|
|
// so start at the first line
|
|
cli = ili;
|
|
vp = 0;
|
|
cp = 0;
|
|
iStart = 0;
|
|
}
|
|
else if( cli <= 0 )
|
|
{
|
|
CheckView();
|
|
for(ili = _iliFirstVisible-1; cli < 0; cli++, ili--)
|
|
{
|
|
pli = Elem(ili);
|
|
vp -= pli->GetHeight();
|
|
cp -= pli->_cch;
|
|
}
|
|
goto end;
|
|
}
|
|
|
|
for(ili = iStart; cli > 0; cli--, ili++)
|
|
{
|
|
pli = Elem(ili);
|
|
if(!IsMain() || !WaitForRecalcIli(ili))
|
|
break;
|
|
vp += pli->GetHeight();
|
|
cp += pli->_cch;
|
|
}
|
|
|
|
end:
|
|
if(pdvp)
|
|
*pdvp = vp;
|
|
|
|
return cp;
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
* CDisplayML::LineFromCp(cp, fAtEnd)
|
|
*
|
|
* @mfunc
|
|
* Computes line containing given cp.
|
|
*
|
|
* @rdesc
|
|
* index of line found, -1 if no line at that cp.
|
|
*/
|
|
LONG CDisplayML::LineFromCp(
|
|
LONG cp, //@parm cp to look for
|
|
BOOL fAtEnd) //@parm If true, return previous line for ambiguous cp
|
|
{
|
|
TRACEBEGIN(TRCSUBSYSDISP, TRCSCOPEINTERN, "CDisplayML::LineFromCp");
|
|
|
|
_TEST_INVARIANT_
|
|
|
|
CLinePtr rp(this);
|
|
|
|
if(!WaitForRecalc(cp, -1) || !rp.SetCp(cp, fAtEnd))
|
|
return -1;
|
|
|
|
return (LONG)rp;
|
|
}
|
|
|
|
/*
|
|
* CDisplayML::CpFromPoint(pt, prcClient, prtp, prp, fAllowEOL, phit,
|
|
* pdispdim, pcpActual)
|
|
* @mfunc
|
|
* Determine cp at given point
|
|
*
|
|
* @devnote
|
|
* --- Use when in-place active only ---
|
|
*
|
|
* @rdesc
|
|
* Computed cp, -1 if failed
|
|
*/
|
|
LONG CDisplayML::CpFromPoint(
|
|
POINTUV pt, //@parm Point to compute cp at (client coords)
|
|
const RECTUV *prcClient,//@parm Client rectangle (can be NULL if active).
|
|
CRchTxtPtr * const prtp,//@parm Returns text pointer at cp (may be NULL)
|
|
CLinePtr * const prp, //@parm Returns line pointer at cp (may be NULL)
|
|
BOOL fAllowEOL, //@parm Click at EOL returns cp after CRLF
|
|
HITTEST * phit, //@parm Out parm for hit-test value
|
|
CDispDim * pdispdim, //@parm Out parm for display dimensions
|
|
LONG *pcpActual, //@parm Out cp that pt is above
|
|
CLine * pliParent) //@parm Parent pli for table row displays
|
|
{
|
|
TRACEBEGIN(TRCSUBSYSDISP, TRCSCOPEINTERN, "CDisplayML::CpFromPoint");
|
|
CMeasurer me(this);
|
|
|
|
return CLayout::CpFromPoint(me, pt, prcClient, prtp, prp, fAllowEOL, phit, pdispdim, pcpActual);
|
|
}
|
|
|
|
/*
|
|
* CDisplayML::PointFromTp(rtp, prcClient, fAtEnd, pt, prp, taMode, pdispdim)
|
|
*
|
|
* @mfunc
|
|
* Determine coordinates at given tp
|
|
*
|
|
* @devnote
|
|
* --- Use when in-place active only ---
|
|
*
|
|
* @rdesc
|
|
* line index at cp, -1 if error
|
|
*/
|
|
LONG CDisplayML::PointFromTp(
|
|
const CRchTxtPtr &rtp, //@parm Text ptr to get coordinates at
|
|
const RECTUV *prcClient,//@parm Client rectangle (can be NULL if active).
|
|
BOOL fAtEnd, //@parm Return end of prev line for ambiguous cp
|
|
POINTUV & pt, //@parm Returns point at cp in client coords
|
|
CLinePtr * const prp, //@parm Returns line pointer at tp (may be null)
|
|
UINT taMode, //@parm Text Align mode: top, baseline, bottom
|
|
CDispDim * pdispdim) //@parm Out parm for display dimensions
|
|
{
|
|
TRACEBEGIN(TRCSUBSYSDISP, TRCSCOPEINTERN, "CDisplayML::PointFromTp");
|
|
CMeasurer me(this, rtp);
|
|
return CLayout::PointFromTp(me, rtp, prcClient, fAtEnd, pt, prp, taMode, pdispdim);
|
|
}
|
|
|
|
/*
|
|
* Render(rcView, rcRender)
|
|
*
|
|
* @mfunc
|
|
* Renders text.
|
|
*/
|
|
void CDisplayML::Render(
|
|
const RECTUV &rcView, //@parm View RECT
|
|
const RECTUV &rcRender) //@parm RECT to render (must be container in client rect)
|
|
{
|
|
TRACEBEGIN(TRCSUBSYSDISP, TRCSCOPEINTERN, "CDisplayML::Render");
|
|
|
|
_TEST_INVARIANT_
|
|
|
|
LONG cp;
|
|
LONG ili;
|
|
LONG lCount = Count();
|
|
CTxtSelection *psel = _ped->GetSelNC();
|
|
POINTUV pt;
|
|
LONG vpLine;
|
|
|
|
if(psel)
|
|
psel->ClearCchPending();
|
|
|
|
// Calculate line and cp to start display at
|
|
if(IsInPageView())
|
|
{
|
|
cp = _cpFirstVisible;
|
|
ili = _iliFirstVisible;
|
|
vpLine = _vpScroll;
|
|
}
|
|
else
|
|
ili = LineFromVpos(this, rcRender.top + _vpScroll - rcView.top, &vpLine, &cp);
|
|
|
|
CLine *pli = Elem(ili);
|
|
CLine *pliFirst = pli;
|
|
LONG dvpBottom = BottomOfRender(rcView, rcRender);
|
|
LONG vpLi = pli->GetHeight();
|
|
|
|
// Calculate point where text will start being displayed
|
|
pt.u = rcView.left - _upScroll;
|
|
pt.v = rcView.top - _vpScroll + vpLine;
|
|
|
|
// Create and prepare renderer
|
|
CRenderer re(this);
|
|
|
|
if(!re.StartRender(rcView, rcRender))
|
|
return;
|
|
|
|
// Init renderer at start of first line to render
|
|
re.SetCurPoint(pt);
|
|
POINTUV ptFirst = pt;
|
|
LONG cpFirst = cp = re.SetCp(cp);
|
|
vpLi = pt.v;
|
|
|
|
// Render each line in update rectangle
|
|
for (;; pli++, ili++)
|
|
{
|
|
BOOL fLastLine = ili == lCount - 1 ||
|
|
re.GetCurPoint().v + pli->GetHeight() >= dvpBottom ||
|
|
IsInPageView() && ili + 1 < lCount && (pli + 1)->_fFirstOnPage;
|
|
|
|
//Support khyphChangeAfter
|
|
if (ili > 0)
|
|
re.SetIhyphPrev((pli - 1)->_ihyph);
|
|
|
|
//Don't draw the line if it doesn't intersect the rendering area,
|
|
//but draw at least 1 line so that we erase the control
|
|
if (pt.v + pli->GetHeight() < rcRender.top && !fLastLine)
|
|
{
|
|
pt.v += pli->GetHeight();
|
|
re.SetCurPoint(pt);
|
|
re.Move(pli->_cch);
|
|
}
|
|
else if (!CLayout::Render(re, pli, &rcView, fLastLine, ili, lCount))
|
|
break;
|
|
|
|
if (fLastLine)
|
|
break;
|
|
|
|
#ifdef DEBUG
|
|
cp += pli->_cch;
|
|
vpLi += pli->GetHeight();
|
|
|
|
// Rich controls with password characters stop at EOPs,
|
|
// so re.GetCp() may be less than cp.
|
|
AssertSz(_ped->IsRich() && _ped->fUsePassword() || re.GetCp() == cp, "cp out of sync with line table");
|
|
#endif
|
|
pt = re.GetCurPoint();
|
|
AssertSz(pt.v == vpLi, "CDisplayML::RenderView() - y out of sync with line table");
|
|
|
|
}
|
|
|
|
re.EndRender(pliFirst, pli, cpFirst, ptFirst);
|
|
}
|
|
|
|
|
|
//=================================== View Updating ===================================
|
|
/*
|
|
* CDisplayML::RecalcView(fUpdateScrollBars)
|
|
*
|
|
* @mfunc
|
|
* Recalc all lines breaks and update first visible line
|
|
*
|
|
* @rdesc
|
|
* TRUE if success
|
|
*/
|
|
BOOL CDisplayML::RecalcView(
|
|
BOOL fUpdateScrollBars, RECTUV* prc)
|
|
{
|
|
TRACEBEGIN(TRCSUBSYSDISP, TRCSCOPEINTERN, "CDisplayML::RecalcView");
|
|
|
|
BOOL fRet = TRUE;
|
|
LONG dvpOld = _dvp;
|
|
LONG vpScrollHeightOld = GetMaxVpScroll();
|
|
LONG dupOld = _dupLineMax;
|
|
LONG vpScrollHeightNew;
|
|
|
|
// Full recalc lines
|
|
CRchTxtPtr rtp(_ped, 0);
|
|
if(!RecalcLines(rtp, FALSE))
|
|
{
|
|
// We're in deep crap now, the recalc failed. Let's try to get out
|
|
// of this with our head still mostly attached
|
|
InitVars();
|
|
fRet = FALSE;
|
|
goto Done;
|
|
}
|
|
|
|
// Force _upScroll = 0 if x scroll range is smaller than the view width
|
|
if(_dupLineMax <= _dupView)
|
|
_upScroll = 0;
|
|
|
|
vpScrollHeightNew = GetMaxVpScroll();
|
|
RebindFirstVisible(vpScrollHeightNew <= _dvpView);
|
|
|
|
CheckView();
|
|
|
|
// We only need to resize if the size needed to display the object has
|
|
// changed.
|
|
if (dvpOld != _dvp || vpScrollHeightOld != vpScrollHeightNew ||
|
|
dupOld != _dupLineMax)
|
|
{
|
|
if(FAILED(RequestResize()))
|
|
_ped->GetCallMgr()->SetOutOfMemory();
|
|
else if (prc && _ped->_fInOurHost)/*bug fix# 5830, forms3 relies on old behavior*/
|
|
_ped->TxGetClientRect(prc);
|
|
}
|
|
|
|
Done:
|
|
|
|
// Now update scrollbars
|
|
if(fUpdateScrollBars)
|
|
RecalcScrollBars();
|
|
|
|
return fRet;
|
|
}
|
|
|
|
/*
|
|
* CDisplayML::UpdateView(&rtp, cchOld, cchNew)
|
|
*
|
|
* @mfunc
|
|
* Recalc lines and update the visible part of the display
|
|
* (the "view") on the screen.
|
|
*
|
|
* @devnote
|
|
* --- Use when in-place active only ---
|
|
*
|
|
* @rdesc
|
|
* TRUE if success
|
|
*/
|
|
BOOL CDisplayML::UpdateView(
|
|
CRchTxtPtr &rtp, //@parm Text ptr where change happened
|
|
LONG cchOld, //@parm Count of chars deleted
|
|
LONG cchNew) //@parm Count of chars inserted
|
|
{
|
|
TRACEBEGIN(TRCSUBSYSDISP, TRCSCOPEINTERN, "CDisplayML::UpdateView");
|
|
|
|
BOOL fReturn = TRUE;
|
|
BOOL fRecalcVisible = TRUE;
|
|
RECTUV rcClient;
|
|
RECTUV rcView;
|
|
CLed led;
|
|
CTxtSelection *psel = _ped->GetSelNC();
|
|
LONG cpStartOfUpdate = rtp.GetCp();
|
|
BOOL fNeedViewChange = FALSE;
|
|
LONG dvpOld = _dvp;
|
|
LONG vpScrollHeightOld = GetMaxVpScroll();
|
|
LONG dupOld = _dupLineMax;
|
|
LONG vpScrollOld = _vpScroll;
|
|
LONG cpNewFirstVisible;
|
|
|
|
if(_fNoUpdateView)
|
|
return fReturn;
|
|
|
|
AssertSz(_ped->_fInPlaceActive, "CDisplayML::UpdateView called when inactive");
|
|
|
|
if(rtp.GetCp() > _cpCalcMax || _fNeedRecalc)
|
|
{
|
|
// We haven't even calc'ed this far, so don't bother with updating
|
|
// here. Background recalc will eventually catch up to us.
|
|
if(!rtp.GetCp())
|
|
{ // Changes started at start of doc
|
|
_cpCalcMax = 0; // so previous calc'd state is
|
|
_vpCalcMax = 0; // completely invalid
|
|
}
|
|
return TRUE;
|
|
}
|
|
|
|
AssertSz(rtp.GetCp() <= _cpCalcMax, "CDisplayML::UpdateView: rtp > _cpCalcMax");
|
|
|
|
_ped->TxGetClientRect(&rcClient);
|
|
GetViewRect(rcView, &rcClient);
|
|
|
|
if(psel && !psel->PuttingChar())
|
|
psel->ClearCchPending();
|
|
|
|
DeferUpdateScrollBar();
|
|
|
|
// In general, background recalc should not start until both the scroll
|
|
// position is beyond the visible view and the cp is beyond the first visible
|
|
// character. However, for the recalc we will only wait on the height.
|
|
// Later calls to WaitForRecalc will wait on cpFirstVisible if that is
|
|
// necessary.
|
|
_vpWait = _vpScroll + _dvpView;
|
|
_cpWait = -1;
|
|
|
|
if(!RecalcLines(rtp, cchOld, cchNew, FALSE, TRUE, &led))
|
|
{
|
|
// We're in deep crap now, the recalc failed. Let's try to get
|
|
// out of this with our head still mostly attached
|
|
InitVars();
|
|
fRecalcVisible = TRUE;
|
|
fReturn = FALSE;
|
|
_ped->TxInvalidate();
|
|
fNeedViewChange = TRUE;
|
|
goto Exit;
|
|
}
|
|
|
|
if(_dupLineMax <= _dupView)
|
|
{
|
|
// x scroll range is smaller than the view width, force x scrolling position = 0
|
|
// we have to redraw all when this means scrolling back to home.
|
|
// Problem lines are lines with trailing spaces crossing _dupView. UpdateCaret forces redraw
|
|
// only when such lines are growing, misses shrinking.
|
|
if (_upScroll != 0)
|
|
_ped->TxInvalidate(); //REVIEW: find a smaller rectangle?
|
|
|
|
_upScroll = 0;
|
|
}
|
|
|
|
if(led._vpFirst >= _vpScroll + _dvpView)
|
|
{
|
|
// Update is after view: don't do anything
|
|
fRecalcVisible = FALSE;
|
|
AssertNr(VerifyFirstVisible());
|
|
goto finish;
|
|
}
|
|
else if(led._vpMatchNew <= _vpScroll + _dvpFirstVisible &&
|
|
led._vpMatchOld <= _vpScroll + _dvpFirstVisible &&
|
|
_vpScroll < _dvp)
|
|
{
|
|
if (_dvp != 0)
|
|
{
|
|
// Update is entirely before view: just update scroll position
|
|
// but don't touch the screen
|
|
_vpScroll += led._vpMatchNew - led._vpMatchOld;
|
|
_iliFirstVisible += led._iliMatchNew - led._iliMatchOld;
|
|
_iliFirstVisible = max(_iliFirstVisible, 0);
|
|
|
|
_cpFirstVisible += led._cpMatchNew - led._cpMatchOld;
|
|
_cpFirstVisible = min(_ped->GetTextLength(), _cpFirstVisible);
|
|
_cpFirstVisible = max(0, _cpFirstVisible);
|
|
fRecalcVisible = FALSE;
|
|
Sync_yScroll();
|
|
}
|
|
else
|
|
{
|
|
// Odd outline case. Height of control can be recalc'd to zero due
|
|
// when outline mode collapses all lines to 0. Example of how to
|
|
// do this is tell outline to collapse to heading 1 and there is none.
|
|
_vpScroll = 0;
|
|
_iliFirstVisible = 0;
|
|
_cpFirstVisible = 0;
|
|
_sPage = 0;
|
|
}
|
|
|
|
AssertNr(VerifyFirstVisible());
|
|
}
|
|
else
|
|
{
|
|
// Update overlaps visible view
|
|
RECTUV rc = rcClient;
|
|
|
|
// Do we need to resync the first visible? Note that this if check
|
|
// is mostly an optmization; we could decide to _always_ recompute
|
|
// this _iliFirstVisible if we wanted to unless rtp is inside a table,
|
|
// in which case _cpFirstVisible won't change and the following may
|
|
// mess up _dvpFirstVisible.
|
|
const CParaFormat *pPF = rtp.GetPF();
|
|
|
|
if((!pPF->_bTableLevel || rtp._rpTX.IsAtTRD(0)) &&
|
|
(cpStartOfUpdate <= _cpFirstVisible ||
|
|
led._iliMatchOld <= _iliFirstVisible ||
|
|
led._iliMatchNew <= _iliFirstVisible ||
|
|
led._iliFirst <= _iliFirstVisible ))
|
|
{
|
|
// Edit overlaps the first visible. We try to maintain
|
|
// approximately the same place in the file visible.
|
|
cpNewFirstVisible = _cpFirstVisible;
|
|
|
|
if(_iliFirstVisible - 1 == led._iliFirst)
|
|
{
|
|
// Edit occurred on line before visible view. Most likely
|
|
// this means that the first character got pulled back to
|
|
// the previous line so we want that line to be visible.
|
|
cpNewFirstVisible = led._cpFirst;
|
|
}
|
|
|
|
// Change first visible entries because CLinePtr::SetCp() and
|
|
// VposFromLine() use them, but they're not valid
|
|
_dvpFirstVisible = 0;
|
|
_cpFirstVisible = 0;
|
|
_iliFirstVisible = 0;
|
|
_vpScroll = 0;
|
|
|
|
// With certain formatting changes, it's possible for
|
|
// cpNewFirstVisible to be less that what's been calculated so far
|
|
// in RecalcLines above. Wait for things to catch up.
|
|
|
|
WaitForRecalc(cpNewFirstVisible, -1);
|
|
Set_yScroll(cpNewFirstVisible);
|
|
}
|
|
AssertNr(VerifyFirstVisible());
|
|
|
|
// Is there a match in the display area? - this can only happen if the
|
|
// old match is on the screen and the new match will be on the screen
|
|
if (led._vpMatchOld < vpScrollOld + _dvpView &&
|
|
led._vpMatchNew < _vpScroll + _dvpView)
|
|
{
|
|
// We have a match inside visible view
|
|
// Scroll the part that is below the old y pos of the match
|
|
// or invalidate if the new y of the match is now below the view
|
|
rc.top = rcView.top + (led._vpMatchOld - vpScrollOld);
|
|
if(rc.top < rc.bottom)
|
|
{
|
|
// Calculate difference between new and old screen positions
|
|
const INT dvp = (led._vpMatchNew - _vpScroll) - (led._vpMatchOld - vpScrollOld);
|
|
|
|
if(dvp)
|
|
{
|
|
if(!IsTransparent() && _ped->GetBackgroundType() == -1)
|
|
{
|
|
LONG dxp, dyp;
|
|
GetDxpDypFromDupDvp(0, dvp, GetTflow(), dxp, dyp);
|
|
|
|
RECTUV rcClip = {rcClient.left, rcView.top, rcClient.right, rcView.bottom };
|
|
RECT rcxyClip, rcxy;
|
|
RectFromRectuv(rcxyClip, rcClip);
|
|
RectFromRectuv(rcxy, rc);
|
|
|
|
_ped->TxScrollWindowEx(dxp, dyp, &rcxy, &rcxyClip);
|
|
fNeedViewChange = TRUE;
|
|
|
|
if(dvp < 0)
|
|
{
|
|
rc.top = rc.bottom + dvp;
|
|
|
|
_ped->TxInvalidateRect(&rc);
|
|
fNeedViewChange = TRUE;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// Just invalidate cuz we don't scroll in transparent
|
|
// mode
|
|
RECTUV rcInvalidate = rc;
|
|
rcInvalidate.top += dvp;
|
|
|
|
_ped->TxInvalidateRect(&rcInvalidate);
|
|
fNeedViewChange = TRUE;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
rc.top = rcView.top + led._vpMatchNew - _vpScroll;
|
|
_ped->TxInvalidateRect(&rc);
|
|
fNeedViewChange = TRUE;
|
|
}
|
|
|
|
// Since we found that the new match falls on the screen, we can
|
|
// safely set the bottom to the new match since this is the most
|
|
// that can have changed.
|
|
rc.bottom = rcView.top + max(led._vpMatchNew, led._vpMatchOld) - _vpScroll;
|
|
}
|
|
|
|
rc.top = rcView.top + led._vpFirst - _vpScroll;
|
|
|
|
// Set first line edited to be rendered using off-screen bitmap
|
|
if (led._iliFirst < Count() && !IsTransparent() && !Elem(led._iliFirst)->_fUseOffscreenDC)
|
|
Elem(led._iliFirst)->_fOffscreenOnce = Elem(led._iliFirst)->_fUseOffscreenDC = TRUE;
|
|
|
|
// Invalidate part of update that is above match (if any)
|
|
_ped->TxInvalidateRect (&rc);
|
|
fNeedViewChange = TRUE;
|
|
}
|
|
|
|
finish:
|
|
if(fRecalcVisible)
|
|
{
|
|
fReturn = WaitForRecalcView();
|
|
if(!fReturn)
|
|
return FALSE;
|
|
}
|
|
if(fNeedViewChange)
|
|
_ped->GetHost()->TxViewChange(FALSE);
|
|
|
|
CheckView();
|
|
|
|
// We only need to resize if size needed to display object has changed
|
|
if (dvpOld != _dvp || vpScrollHeightOld != GetMaxVpScroll() ||
|
|
dupOld != _dupLineMax)
|
|
{
|
|
if(FAILED(RequestResize()))
|
|
_ped->GetCallMgr()->SetOutOfMemory();
|
|
}
|
|
if(DoDeferredUpdateScrollBar())
|
|
{
|
|
if(FAILED(RequestResize()))
|
|
_ped->GetCallMgr()->SetOutOfMemory();
|
|
DoDeferredUpdateScrollBar();
|
|
}
|
|
|
|
Exit:
|
|
return fReturn;
|
|
}
|
|
|
|
/*
|
|
* CDisplayML::RecalcLine(cp)
|
|
*
|
|
* @mfunc
|
|
* Show line
|
|
*/
|
|
void CDisplayML::RecalcLine(
|
|
LONG cp) //@parm cp line to recalc
|
|
{
|
|
CNotifyMgr *pnm = GetPed()->GetNotifyMgr();
|
|
if(pnm)
|
|
pnm->NotifyPostReplaceRange(NULL, cp, 0, 0, cp, cp);
|
|
}
|
|
|
|
void CDisplayML::InitVars()
|
|
{
|
|
TRACEBEGIN(TRCSUBSYSDISP, TRCSCOPEINTERN, "CDisplayML::InitVars");
|
|
|
|
_vpScroll = _upScroll = 0;
|
|
_iliFirstVisible = 0;
|
|
_cpFirstVisible = _cpMin = 0;
|
|
_dvpFirstVisible = 0;
|
|
_sPage = 0;
|
|
}
|
|
|
|
|
|
/*
|
|
* CDisplayML::GetCliVisible(pcpMostVisible)
|
|
*
|
|
* @mfunc
|
|
* Get count of visible lines and update _cpMostVisible for PageDown()
|
|
*
|
|
* @rdesc
|
|
* count of visible lines
|
|
*/
|
|
LONG CDisplayML::GetCliVisible(
|
|
LONG* pcpMostVisible, //@parm Returns cpMostVisible
|
|
BOOL fLastCharOfLastVisible) const //@parm Want cp of last visible char
|
|
{
|
|
TRACEBEGIN(TRCSUBSYSDISP, TRCSCOPEINTERN, "CDisplayML::GetCliVisible");
|
|
|
|
LONG cli = 0; // Initialize count
|
|
LONG ili = _iliFirstVisible; // Start with 1st visible line
|
|
LONG dvp = _dvpFirstVisible;
|
|
LONG cp;
|
|
const CLine *pli = Elem(ili);
|
|
|
|
for(cp = _cpFirstVisible;
|
|
dvp < _dvpView && ili < Count();
|
|
cli++, ili++, pli++)
|
|
{
|
|
dvp += pli->GetHeight();
|
|
|
|
//Note: I removed the support to give the last visible non-white character.
|
|
//Does anyone want that? It never worked in LS displays.
|
|
if (fLastCharOfLastVisible && dvp > _dvpView)
|
|
break;
|
|
|
|
if(IsInPageView() && cli && pli->_fFirstOnPage)
|
|
break;
|
|
|
|
cp += pli->_cch;
|
|
}
|
|
|
|
if(pcpMostVisible)
|
|
*pcpMostVisible = cp;
|
|
|
|
return cli;
|
|
}
|
|
|
|
//================================== Inversion (selection) ============================
|
|
|
|
/*
|
|
* CDisplayML::InvertRange(cp, cch)
|
|
*
|
|
* @mfunc
|
|
* Invert a given range on screen (for selection)
|
|
*
|
|
* @devnote
|
|
* --- Use when in-place active only ---
|
|
*
|
|
* @rdesc
|
|
* TRUE if success
|
|
*/
|
|
BOOL CDisplayML::InvertRange (
|
|
LONG cp, //@parm Active end of range to invert
|
|
LONG cch, //@parm Signed length of range
|
|
SELDISPLAYACTION selAction) //@parm Describes what we are doing to the selection
|
|
{
|
|
TRACEBEGIN(TRCSUBSYSDISP, TRCSCOPEINTERN, "CDisplayML::InvertRange");
|
|
|
|
LONG cpMost;
|
|
RECTUV rc, rcClient, rcView;
|
|
CLinePtr rp(this);
|
|
CRchTxtPtr rtp(_ped);
|
|
LONG y;
|
|
LONG cpActive = _ped->GetSel()->GetCp();
|
|
|
|
AssertSz(_ped->_fInPlaceActive, "CDisplayML::InvertRange() called when not in-place active");
|
|
|
|
if(cch < 0) // Define cpMost, set cp = cpMin,
|
|
{ // and cch = |cch|
|
|
cpMost = cp - cch;
|
|
cch = -cch;
|
|
}
|
|
else
|
|
{
|
|
cpMost = cp;
|
|
cp -= cch;
|
|
}
|
|
|
|
#ifndef NOLINESERVICES
|
|
if (g_pols)
|
|
g_pols->DestroyLine(this);
|
|
#endif
|
|
|
|
// If an object is being inverted, and nothing else is being inverted,
|
|
// delegate to the ObjectMgr. If fIgnoreObj is TRUE we highlight normally
|
|
if (cch == 1 && _ped->GetObjectCount() &&
|
|
(selAction == selSetNormal || selAction == selSetHiLite))
|
|
{
|
|
CObjectMgr* pobjmgr = _ped->GetObjectMgr();
|
|
|
|
rtp.SetCp(cp);
|
|
if(rtp.GetChar() == WCH_EMBEDDING)
|
|
{
|
|
if(pobjmgr)
|
|
pobjmgr->HandleSingleSelect(_ped, cp, selAction == selSetHiLite);
|
|
return TRUE;
|
|
}
|
|
}
|
|
|
|
// If display is frozen, just update recalc region and move on.
|
|
if(_padc)
|
|
{
|
|
AssertSz(cp >= 0, "CDisplayML::InvertRange: range (cp) goes below"
|
|
"zero!!" );
|
|
// Make sure these values are bounded.
|
|
if(cp > _ped->GetTextLength()) // Don't bother updating region;
|
|
return TRUE; // it's out of bounds
|
|
|
|
if(cp + cch > _ped->GetTextLength())
|
|
cch -= cp + cch - _ped->GetTextLength();
|
|
|
|
_padc->UpdateRecalcRegion(cp, cch, cch);
|
|
return TRUE;
|
|
}
|
|
|
|
if(!WaitForRecalcView()) // Ensure all visible lines are
|
|
return FALSE; // recalc'd
|
|
|
|
_ped->TxGetClientRect(&rcClient);
|
|
GetViewRect(rcView, &rcClient);
|
|
|
|
// Compute first line to invert and where to start on it
|
|
if(cp >= _cpFirstVisible)
|
|
{
|
|
POINTUV pt;
|
|
rtp.SetCp(cp);
|
|
if(PointFromTp(rtp, NULL, FALSE, pt, NULL, TA_TOP) < 0)
|
|
return FALSE;
|
|
|
|
//We don't use the rp returned from PointFromTp because
|
|
//we need the outermost rp for best results. In the future
|
|
//we could consider writing code which doesn't invalidate so much.
|
|
rp.SetCp(cp, FALSE, 0);
|
|
rc.top = pt.v;
|
|
}
|
|
else
|
|
{
|
|
cp = _cpFirstVisible;
|
|
rp = _iliFirstVisible;
|
|
rc.top = rcView.top + _dvpFirstVisible;
|
|
}
|
|
|
|
// Loop on all lines of range
|
|
while (cp < cpMost && rc.top < rcView.bottom && rp.IsValid())
|
|
{
|
|
// Calculate rc.bottom first because rc.top takes into account
|
|
// the dy of the first visible on the first loop.
|
|
y = rc.top;
|
|
y += rp->GetHeight();
|
|
rc.bottom = min(y, rcView.bottom);
|
|
rc.top = max(rc.top, rcView.top);
|
|
|
|
//If we are inverting the active end of the selection, draw it offscreen
|
|
//to minimize flicker.
|
|
if (IN_RANGE(cp - rp.GetIch(), cpActive, cp - rp.GetIch() + rp->_cch) &&
|
|
!IsTransparent() && !rp->_fUseOffscreenDC)
|
|
{
|
|
rp->_fOffscreenOnce = rp->_fUseOffscreenDC = TRUE;
|
|
}
|
|
|
|
cp += rp->_cch - rp.GetIch();
|
|
|
|
rc.left = rcClient.left;
|
|
rc.right = rcClient.right;
|
|
|
|
_ped->TxInvalidateRect(&rc);
|
|
rc.top = rc.bottom;
|
|
if(!rp.NextRun())
|
|
break;
|
|
}
|
|
_ped->TxUpdateWindow(); // Make sure window gets repainted
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
//=================================== Scrolling =============================
|
|
|
|
/*
|
|
* CDisplay::VScroll(wCode, vPos)
|
|
*
|
|
* @mfunc
|
|
* Scroll the view vertically in response to a scrollbar event
|
|
*
|
|
* @devnote
|
|
* --- Use when in-place active only ---
|
|
*
|
|
* @rdesc
|
|
* LRESULT formatted for WM_VSCROLL message
|
|
*/
|
|
LRESULT CDisplayML::VScroll(
|
|
WORD wCode, //@parm Scrollbar event code
|
|
LONG vPos) //@parm Thumb position (vPos <lt> 0 for EM_SCROLL behavior)
|
|
{
|
|
TRACEBEGIN(TRCSUBSYSDISP, TRCSCOPEINTERN, "CDisplayML::VScroll");
|
|
|
|
LONG cliVisible;
|
|
LONG dy = 0;
|
|
BOOL fTracking = FALSE;
|
|
LONG i;
|
|
const LONG iliSave = _iliFirstVisible;
|
|
CLine * pli = NULL;
|
|
INT dvpSys = GetDvpSystemFont();
|
|
LONG vpScroll = _vpScroll;
|
|
|
|
AssertSz(_ped->_fInPlaceActive, "CDisplay::VScroll() called when not in-place");
|
|
|
|
if(vPos)
|
|
{
|
|
// Convert this from 16-bit to 32-bit if necessary.
|
|
vPos = ConvertScrollToVPos(vPos);
|
|
}
|
|
|
|
vPos = min(vPos, _dvp);
|
|
|
|
if(IsInPageView())
|
|
{
|
|
BOOL fForward;
|
|
BOOL fFoundNewPage = FALSE;
|
|
LONG ili = _iliFirstVisible;
|
|
LONG nLine = Count();
|
|
CLine *pli = Elem(_iliFirstVisible);
|
|
|
|
AssertSz(Elem(_iliFirstVisible)->_fFirstOnPage,
|
|
"CDisplayML::VScroll: _iliFirstVisible not top of page");
|
|
|
|
if(wCode <= SB_PAGEDOWN)
|
|
{
|
|
fForward = (wCode & 1);
|
|
ili += fForward;
|
|
while(ili && ili < nLine)
|
|
{
|
|
if(fForward > 0)
|
|
{
|
|
vpScroll += pli->GetHeight();
|
|
|
|
if(ili == nLine - 1)
|
|
break;
|
|
pli++;
|
|
ili++;
|
|
}
|
|
else
|
|
{
|
|
pli--;
|
|
ili--;
|
|
vpScroll -= pli->GetHeight();
|
|
}
|
|
if(pli->_fFirstOnPage)
|
|
{
|
|
fFoundNewPage = TRUE;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
else if(wCode == SB_THUMBTRACK || wCode == SB_THUMBPOSITION)
|
|
{
|
|
if (vPos + _dvpView >= _dvp) // At last page?
|
|
vPos = _dvp;
|
|
|
|
if(vPos > vpScroll)
|
|
{
|
|
LONG iliFirst = ili;
|
|
LONG vpScrollPage = vpScroll;
|
|
|
|
if(ili < nLine)
|
|
{
|
|
while(vpScroll < vPos)
|
|
{
|
|
vpScroll += pli->GetHeight(); // Advance to vPos
|
|
|
|
if(ili == nLine - 1)
|
|
break;
|
|
|
|
pli++;
|
|
ili++;
|
|
|
|
if(pli->_fFirstOnPage)
|
|
{
|
|
fFoundNewPage = TRUE;
|
|
vpScrollPage = vpScroll;
|
|
iliFirst = ili;
|
|
}
|
|
}
|
|
}
|
|
vpScroll = vpScrollPage; // Move to top of page
|
|
ili = iliFirst;
|
|
}
|
|
else if(vPos < vpScroll)
|
|
{ // Go back to vPos
|
|
if(!ili)
|
|
{
|
|
vpScroll = 0;
|
|
fFoundNewPage = TRUE;
|
|
}
|
|
while(vpScroll > vPos && ili)
|
|
{
|
|
pli--;
|
|
ili--;
|
|
vpScroll -= pli->GetHeight();
|
|
if(pli->_fFirstOnPage)
|
|
fFoundNewPage = TRUE;
|
|
}
|
|
while(!pli->_fFirstOnPage && ili)
|
|
{
|
|
pli--;
|
|
ili--;
|
|
vpScroll -= pli->GetHeight();
|
|
}
|
|
}
|
|
AssertSz(Elem(ili)->_fFirstOnPage,
|
|
"CDisplayML::VScroll: ili not top of page");
|
|
}
|
|
if(!fFoundNewPage) // Nothing to scroll, early exit
|
|
return MAKELRESULT(0, TRUE);
|
|
}
|
|
else
|
|
{
|
|
switch(wCode)
|
|
{
|
|
case SB_BOTTOM:
|
|
if(vPos < 0)
|
|
return FALSE;
|
|
WaitForRecalc(_ped->GetTextLength(), -1);
|
|
vpScroll = _dvp;
|
|
break;
|
|
|
|
case SB_LINEDOWN:
|
|
cliVisible = GetCliVisible();
|
|
if(_iliFirstVisible + cliVisible < Count()
|
|
&& 0 == _dvpFirstVisible)
|
|
{
|
|
i = _iliFirstVisible + cliVisible;
|
|
pli = Elem(i);
|
|
if(IsInOutlineView())
|
|
{ // Scan for uncollapsed line
|
|
for(; pli->_fCollapsed && i < Count();
|
|
pli++, i++);
|
|
}
|
|
if(i < Count())
|
|
dy = pli->GetHeight();
|
|
}
|
|
else if(cliVisible > 1)
|
|
{
|
|
pli = Elem(_iliFirstVisible);
|
|
dy = _dvpFirstVisible;
|
|
// TODO: scan until find uncollapsed line
|
|
dy += pli->GetHeight();
|
|
}
|
|
else
|
|
dy = _dvp - _vpScroll;
|
|
|
|
if(dy >= _dvpView)
|
|
dy = dvpSys;
|
|
|
|
// Nothing to scroll, early exit
|
|
if ( !dy )
|
|
return MAKELRESULT(0, TRUE);
|
|
|
|
vpScroll += dy;
|
|
break;
|
|
|
|
case SB_LINEUP:
|
|
if(_iliFirstVisible > 0)
|
|
{
|
|
pli = Elem(_iliFirstVisible - 1);
|
|
// TODO: scan until find uncollapsed line
|
|
dy = pli->GetHeight();
|
|
}
|
|
else if(vpScroll > 0)
|
|
dy = min(vpScroll, dvpSys);
|
|
|
|
if(dy > _dvpView)
|
|
dy = dvpSys;
|
|
vpScroll -= dy;
|
|
break;
|
|
|
|
case SB_PAGEDOWN:
|
|
cliVisible = GetCliVisible();
|
|
vpScroll += _dvpView;
|
|
if(vpScroll < _dvp && cliVisible > 0)
|
|
{
|
|
// TODO: Scan until find uncollapsed line
|
|
dy = Elem(_iliFirstVisible + cliVisible - 1)->GetHeight();
|
|
if(dy >= _dvpView)
|
|
dy = dvpSys;
|
|
|
|
else if(dy > _dvpView - dy)
|
|
{
|
|
// Go at least a line if line is very big
|
|
dy = _dvpView - dy;
|
|
}
|
|
vpScroll -= dy;
|
|
}
|
|
break;
|
|
|
|
case SB_PAGEUP:
|
|
cliVisible = GetCliVisible();
|
|
vpScroll -= _dvpView;
|
|
|
|
if (vpScroll < 0)
|
|
{
|
|
// Scroll position can't be negative and we don't
|
|
// need to back up to be sure we display a full line.
|
|
vpScroll = 0;
|
|
}
|
|
else if(cliVisible > 0)
|
|
{
|
|
// TODO: Scan until find uncollapsed line
|
|
dy = Elem(_iliFirstVisible)->GetHeight();
|
|
if(dy >= _dvpView)
|
|
dy = dvpSys;
|
|
|
|
else if(dy > _dvpView - dy)
|
|
{
|
|
// Go at least a line if line is very big
|
|
dy = _dvpView - dy;
|
|
}
|
|
|
|
vpScroll += dy;
|
|
}
|
|
break;
|
|
|
|
case SB_THUMBTRACK:
|
|
case SB_THUMBPOSITION:
|
|
if(vPos < 0)
|
|
return FALSE;
|
|
|
|
vpScroll = vPos;
|
|
fTracking = TRUE;
|
|
break;
|
|
|
|
case SB_TOP:
|
|
if(vPos < 0)
|
|
return FALSE;
|
|
vpScroll = 0;
|
|
break;
|
|
|
|
case SB_ENDSCROLL:
|
|
UpdateScrollBar(SB_VERT);
|
|
return MAKELRESULT(0, TRUE);
|
|
|
|
default:
|
|
return FALSE;
|
|
}
|
|
}
|
|
|
|
BOOL fFractional = wCode != SB_PAGEDOWN && wCode != SB_PAGEUP;
|
|
LONG vpLimit = _dvp;
|
|
|
|
if(!IsInPageView() && fFractional)
|
|
vpLimit = max(_dvp - _dvpView, 0);
|
|
|
|
vpScroll = min(vpScroll, vpLimit);
|
|
|
|
ScrollView(_upScroll, vpScroll, fTracking, fFractional);
|
|
|
|
// Force position update if we just finished a track
|
|
if(wCode == SB_THUMBPOSITION)
|
|
UpdateScrollBar(SB_VERT);
|
|
|
|
// Return how many lines we scrolled
|
|
return MAKELRESULT((WORD) (_iliFirstVisible - iliSave), TRUE);
|
|
}
|
|
|
|
/*
|
|
* CDisplay::LineScroll(cli, cch)
|
|
*
|
|
* @mfunc
|
|
* Scroll view vertically in response to a scrollbar event
|
|
*/
|
|
void CDisplayML::LineScroll(
|
|
LONG cli, //@parm Count of lines to scroll vertically
|
|
LONG cch) //@parm Count of characters to scroll horizontally
|
|
{
|
|
TRACEBEGIN(TRCSUBSYSDISP, TRCSCOPEINTERN, "CDisplayML::LineScroll");
|
|
|
|
//Make sure the line to scroll to is valid
|
|
if (cli + _iliFirstVisible >= Count())
|
|
{
|
|
// change line count enough to display the last line
|
|
cli = Count() - _iliFirstVisible;
|
|
}
|
|
|
|
// Get the absolute vpScroll position by adding the difference of the line
|
|
// we want to go to and the current _vpScroll position
|
|
LONG dvpScroll = CalcVLineScrollDelta(cli, FALSE);
|
|
if(dvpScroll < 0 || _dvp - (_vpScroll + dvpScroll) > _dvpView - dvpScroll)
|
|
ScrollView(_upScroll, _vpScroll + dvpScroll, FALSE, FALSE);
|
|
}
|
|
|
|
/*
|
|
* CDisplayML::FractionalScrollView (vDelta)
|
|
*
|
|
* @mfunc
|
|
* Allow view to be scrolled by fractional lines.
|
|
*/
|
|
void CDisplayML::FractionalScrollView ( LONG vDelta )
|
|
{
|
|
TRACEBEGIN(TRCSUBSYSDISP, TRCSCOPEINTERN, "CDisplayML::FractionalScrollView");
|
|
|
|
if ( vDelta)
|
|
ScrollView(_upScroll, min(vDelta + _vpScroll, max(_dvp - _dvpView, 0)), FALSE, TRUE);
|
|
}
|
|
|
|
/*
|
|
* CDisplayML::ScrollToLineStart(iDirection)
|
|
*
|
|
* @mfunc
|
|
* If the view is scrolled so that only a partial line is at the
|
|
* top, then scroll the view so that the entire view is at the top.
|
|
*/
|
|
void CDisplayML::ScrollToLineStart(
|
|
LONG iDirection) //@parm the direction in which to scroll (negative
|
|
// means down the screen
|
|
{
|
|
TRACEBEGIN(TRCSUBSYSDISP, TRCSCOPEINTERN, "CDisplayML::ScrollToLineStart");
|
|
|
|
// This code originally lined things up on a line. However, it doesn't work
|
|
// very well with big objects especially at the end of the document. I am
|
|
// leaving the call here in case we discover problems later. (a-rsail).
|
|
|
|
#if 0
|
|
// If _dvpFirstVisible is zero, then we're aligned on a line, so
|
|
// nothing more to do.
|
|
|
|
if(_dvpFirstVisible)
|
|
{
|
|
LONG vpScroll = _vpScroll + _dvpFirstVisible;
|
|
|
|
if(iDirection <= 0)
|
|
{
|
|
vpScroll += Elem(_iliFirstVisible)->_dvp;
|
|
}
|
|
|
|
ScrollView(_upScroll, vpScroll, FALSE, TRUE);
|
|
}
|
|
#endif // 0
|
|
}
|
|
|
|
/*
|
|
* CDisplayML::CalcVLineScrollDelta (cli, fFractionalFirst)
|
|
*
|
|
* @mfunc
|
|
* Given a count of lines, positive or negative, calc the number
|
|
* of vertical units necessary to scroll the view to the start of
|
|
* the current line + the given count of lines.
|
|
*/
|
|
LONG CDisplayML::CalcVLineScrollDelta (
|
|
LONG cli,
|
|
BOOL fFractionalFirst )
|
|
{
|
|
TRACEBEGIN(TRCSUBSYSDISP, TRCSCOPEINTERN, "CDisplayML::CalcVLineScrollDelta");
|
|
|
|
LONG vpScroll = 0;
|
|
|
|
if(fFractionalFirst && _dvpFirstVisible) // Scroll partial for 1st.
|
|
{
|
|
Assert(_dvpFirstVisible <= 0); // get jonmat
|
|
if(cli < 0)
|
|
{
|
|
cli++;
|
|
vpScroll = _dvpFirstVisible;
|
|
}
|
|
else
|
|
{
|
|
cli--;
|
|
vpScroll = Elem(_iliFirstVisible)->GetHeight() + _dvpFirstVisible;
|
|
}
|
|
}
|
|
|
|
if(cli > 0)
|
|
{
|
|
// Scrolling down
|
|
cli = min(cli, Count() - _iliFirstVisible - 1);
|
|
|
|
if (!fFractionalFirst && (0 == cli))
|
|
{
|
|
// If we are scrolling down and on the last line but we haven't scrolled to
|
|
// the very bottom, then do so now.
|
|
AssertSz(0 == vpScroll,
|
|
"CDisplayML::CalcVLineScrollDelta last line & scroll");
|
|
vpScroll = _dvp - _vpScroll;
|
|
|
|
// Limit scroll length to approximately 3 lines.
|
|
vpScroll = min(vpScroll, 3 * GetDvpSystemFont());
|
|
}
|
|
}
|
|
else if(cli < 0)
|
|
{
|
|
// Scrolling up
|
|
cli = max(cli, -_iliFirstVisible);
|
|
|
|
// At the top.
|
|
if (!fFractionalFirst && (0 == cli))
|
|
{
|
|
// Make sure that we scroll back so first visible is 0.
|
|
vpScroll = _dvpFirstVisible;
|
|
|
|
// Limit scroll length to approximately 3 lines.
|
|
vpScroll = max(vpScroll, -3 * GetDvpSystemFont());
|
|
}
|
|
}
|
|
|
|
if(cli)
|
|
vpScroll += VposFromLine(this, _iliFirstVisible + cli) - VposFromLine(this, _iliFirstVisible);
|
|
return vpScroll;
|
|
}
|
|
|
|
/*
|
|
* CDisplayML::ScrollView(upScroll, vpScroll, fTracking, fFractionalScroll)
|
|
*
|
|
* @mfunc
|
|
* Scroll view to new x and y position
|
|
*
|
|
* @devnote
|
|
* This method tries to adjust the y scroll pos before
|
|
* scrolling to display complete line at top. x scroll
|
|
* pos is adjusted to avoid scrolling all text off the
|
|
* view rectangle.
|
|
*
|
|
* Must be able to handle vpScroll <gt> pdp->dvp and vpScroll <lt> 0
|
|
*
|
|
* @rdesc
|
|
* TRUE if actual scrolling occurred,
|
|
* FALSE if no change
|
|
*/
|
|
BOOL CDisplayML::ScrollView (
|
|
LONG upScroll, //@parm New x scroll position
|
|
LONG vpScroll, //@parm New y scroll position
|
|
BOOL fTracking, //@parm TRUE indicates we are tracking scrollbar thumb
|
|
BOOL fFractionalScroll)
|
|
{
|
|
TRACEBEGIN(TRCSUBSYSDISP, TRCSCOPEINTERN, "CDisplayML::ScrollView");
|
|
BOOL fTryAgain = TRUE;
|
|
LONG dupMax;
|
|
LONG dup = 0;
|
|
LONG dvp = 0;
|
|
RECTUV rcClient, rcClip;
|
|
CTxtSelection *psel = _ped->GetSelNC();
|
|
COleObject *pipo;
|
|
BOOL fRestoreCaret = FALSE;
|
|
LONG iliFirstVisible = _iliFirstVisible;
|
|
|
|
AssertSz(_ped->_fInPlaceActive, "CDisplayML::ScrollView() called when not in-place");
|
|
|
|
//For scrolling purposes, we clip to rcView's top and bottom, but rcClient's left and right
|
|
_ped->TxGetClientRect(&rcClient);
|
|
GetViewRect(rcClip, &rcClient);
|
|
rcClip.left = rcClient.left;
|
|
rcClip.right = rcClient.right;
|
|
|
|
if(upScroll == -1)
|
|
upScroll = _upScroll;
|
|
if(vpScroll == -1)
|
|
vpScroll = _vpScroll;
|
|
|
|
// Determine vertical scrolling pos
|
|
while(1)
|
|
{
|
|
BOOL fNothingBig = TRUE;
|
|
LONG vFirst;
|
|
LONG dvFirst;
|
|
LONG cpFirst;
|
|
LONG iliFirst;
|
|
LONG vpHeight;
|
|
LONG iliT;
|
|
|
|
vpScroll = min(vpScroll, GetMaxVpScroll());
|
|
vpScroll = max(0, vpScroll);
|
|
dvp = 0;
|
|
|
|
// Ensure all visible lines are recalced
|
|
if(!WaitForRecalcView())
|
|
return FALSE;
|
|
|
|
// Compute new first visible line
|
|
iliFirst = LineFromVpos(this, vpScroll, &vFirst, &cpFirst);
|
|
if(IsInPageView())
|
|
{
|
|
//REVIEW (keithcu) EBOOKS bug 424. Does this need to be here, or
|
|
//should the logic be somewhere else? Also, would it be better to round
|
|
//rather than to always round down?
|
|
CLine *pli = Elem(iliFirst);
|
|
for(; !pli->_fFirstOnPage && iliFirst; iliFirst--)
|
|
{
|
|
pli--; // Back up to previous line
|
|
vFirst -= pli->GetHeight();
|
|
vpScroll -= pli->GetHeight();
|
|
cpFirst -= pli->_cch;
|
|
}
|
|
}
|
|
|
|
if( cpFirst < 0 )
|
|
{
|
|
// FUTURE (alexgo) this is pretty bogus, we should try to do
|
|
// better in the next rel.
|
|
|
|
TRACEERRORSZ("Display calc hosed, trying again");
|
|
InitVars();
|
|
_fNeedRecalc = TRUE;
|
|
return FALSE;
|
|
}
|
|
|
|
if(iliFirst < 0)
|
|
{
|
|
// No line at _vpScroll, use last line instead
|
|
iliFirst = max(0, Count() - 1);
|
|
cpFirst = _ped->GetTextLength() - Elem(iliFirst)->_cch;
|
|
vpScroll = _dvp - Elem(iliFirst)->GetHeight();
|
|
vFirst = _vpScroll;
|
|
}
|
|
if(IsInPageView())
|
|
{
|
|
AssertSz(Elem(iliFirst)->_fFirstOnPage,
|
|
"CDisplayML::ScrollView: _iliFirstVisible not top of page");
|
|
if(vpScroll > vFirst) // Tried to scroll beyond start
|
|
vpScroll = vFirst; // of last line
|
|
goto scrollit;
|
|
}
|
|
|
|
dvFirst = vFirst - vpScroll;
|
|
|
|
// Figure whether there is a big line
|
|
// (more that a third of the view rect)
|
|
for(iliT = iliFirst, vpHeight = dvFirst;
|
|
vpHeight < _dvpView && iliT < Count();
|
|
iliT++)
|
|
{
|
|
const CLine *pli = Elem(iliT);
|
|
if(pli->GetHeight() >= _dvpView / 3)
|
|
fNothingBig = FALSE;
|
|
vpHeight += pli->GetHeight();
|
|
}
|
|
|
|
// If no big line and first pass, try to adjust
|
|
// scrolling pos to show complete line at top
|
|
if(!fFractionalScroll && fTryAgain && fNothingBig && dvFirst != 0)
|
|
{
|
|
fTryAgain = FALSE; // prevent any infinite loop
|
|
|
|
Assert(dvFirst < 0);
|
|
|
|
Tracef(TRCSEVINFO, "adjusting scroll for partial line at %d", dvFirst);
|
|
// partial line visible at top, try to get a complete line showing
|
|
vpScroll += dvFirst;
|
|
|
|
LONG dvpLine = Elem(iliFirst)->GetHeight();
|
|
|
|
// Adjust the height of the scroll by the height of the first
|
|
// visible line if we are scrolling down or if we are using the
|
|
// thumb (tracking) and we are on the last page of the view.
|
|
if ((fTracking && vpScroll + _dvpView + dvpLine > _dvp)
|
|
|| (!fTracking && _vpScroll <= vpScroll))
|
|
{
|
|
// Scrolling down so move down a little more
|
|
vpScroll += dvpLine;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
dvp = 0;
|
|
if(vpScroll != _vpScroll)
|
|
{
|
|
_dvpFirstVisible = dvFirst;
|
|
scrollit:
|
|
_iliFirstVisible = iliFirst;
|
|
_cpFirstVisible = cpFirst;
|
|
dvp = _vpScroll - vpScroll;
|
|
_vpScroll = vpScroll;
|
|
|
|
AssertSz(_vpScroll >= 0, "CDisplayML::ScrollView _vpScroll < 0");
|
|
AssertNr(VerifyFirstVisible());
|
|
if(!WaitForRecalcView())
|
|
return FALSE;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
CheckView();
|
|
|
|
// Determine horizontal scrolling pos.
|
|
|
|
dupMax = _dupLineMax;
|
|
|
|
// REVIEW (Victork) Restricting the range of the scroll is not really needed and could even be bad (bug 6104)
|
|
|
|
upScroll = min(upScroll, dupMax);
|
|
upScroll = max(0, upScroll);
|
|
|
|
dup = _upScroll - upScroll;
|
|
if(dup)
|
|
_upScroll = upScroll;
|
|
|
|
// Now perform the actual scrolling
|
|
if(IsMain() && (dvp || dup))
|
|
{
|
|
// Scroll only if scrolling < view dimensions and we are in-place
|
|
if(IsActive() && !IsTransparent() &&
|
|
dvp < _dvpView && dup < _dupView && !IsInPageView())
|
|
{
|
|
// FUTURE: (ricksa/alexgo): we may be able to get rid of
|
|
// some of these ShowCaret calls; they look bogus.
|
|
if (psel && psel->IsCaretShown())
|
|
{
|
|
_ped->TxShowCaret(FALSE);
|
|
fRestoreCaret = TRUE;
|
|
}
|
|
|
|
LONG dxp, dyp;
|
|
GetDxpDypFromDupDvp(dup, dvp, GetTflow(), dxp, dyp);
|
|
|
|
RECT rcxyClip;
|
|
RectFromRectuv(rcxyClip, rcClip);
|
|
_ped->TxScrollWindowEx(dxp, dyp, NULL, &rcxyClip);
|
|
|
|
if(fRestoreCaret)
|
|
_ped->TxShowCaret(FALSE);
|
|
}
|
|
else
|
|
_ped->TxInvalidateRect(&rcClip);
|
|
|
|
if(psel)
|
|
psel->UpdateCaret(FALSE);
|
|
|
|
if(!fTracking && dvp)
|
|
{
|
|
UpdateScrollBar(SB_VERT);
|
|
_ped->SendScrollEvent(EN_VSCROLL);
|
|
}
|
|
if(!fTracking && dup)
|
|
{
|
|
UpdateScrollBar(SB_HORZ);
|
|
_ped->SendScrollEvent(EN_HSCROLL);
|
|
}
|
|
|
|
// FUTURE: since we're now repositioning in place active
|
|
// objects every time we draw, this call seems to be
|
|
// superfluous (AndreiB)
|
|
|
|
// Tell object subsystem to reposition any in place objects
|
|
if(_ped->GetObjectCount())
|
|
{
|
|
pipo = _ped->GetObjectMgr()->GetInPlaceActiveObject();
|
|
if(pipo)
|
|
pipo->OnReposition();
|
|
}
|
|
}
|
|
bool fNotifyPageChange(false);
|
|
if(IsInPageView() && iliFirstVisible != _iliFirstVisible)
|
|
{
|
|
CalculatePage(iliFirstVisible);
|
|
fNotifyPageChange = true;
|
|
}
|
|
|
|
// Update the View after state has been updated
|
|
if(IsMain() && (dvp || dup))
|
|
_ped->TxUpdateWindow();
|
|
|
|
if(fNotifyPageChange)
|
|
GetPed()->TxNotify(EN_PAGECHANGE, NULL);
|
|
|
|
return dvp || dup;
|
|
}
|
|
|
|
/*
|
|
* CDisplayML::GetScrollRange(nBar)
|
|
*
|
|
* @mfunc
|
|
* Returns the max part of a scrollbar range for scrollbar <p nBar>
|
|
*
|
|
* @rdesc
|
|
* LONG max part of scrollbar range
|
|
*/
|
|
LONG CDisplayML::GetScrollRange(
|
|
INT nBar) const //@parm Scroll bar to interrogate (SB_VERT or SB_HORZ)
|
|
{
|
|
TRACEBEGIN(TRCSUBSYSDISP, TRCSCOPEINTERN, "CDisplayML::GetScrollRange");
|
|
|
|
Assert( IsMain() );
|
|
|
|
LONG lRange = 0;
|
|
|
|
if(nBar == SB_VERT && _fVScrollEnabled)
|
|
{
|
|
if(_ped->TxGetScrollBars() & WS_VSCROLL)
|
|
lRange = GetMaxVpScroll();
|
|
}
|
|
else if((_ped->TxGetScrollBars() & WS_HSCROLL) && _fUScrollEnabled)
|
|
{
|
|
// Scroll range is maximum width.
|
|
lRange = max(0, _dupLineMax + _ped->GetCaretWidth());
|
|
}
|
|
// Since thumb messages are limited to 16-bit, limit range to 16-bit
|
|
lRange = min(lRange, _UI16_MAX);
|
|
return lRange;
|
|
}
|
|
|
|
/*
|
|
* CDisplayML::UpdateScrollBar(nBar, fUpdateRange)
|
|
*
|
|
* @mfunc
|
|
* Update either the horizontal or the vertical scrollbar and
|
|
* figure whether the scrollbar should be visible or not.
|
|
*
|
|
* @rdesc
|
|
* BOOL
|
|
*/
|
|
BOOL CDisplayML::UpdateScrollBar(
|
|
INT nBar, //@parm Which scroll bar : SB_HORZ, SB_VERT
|
|
BOOL fUpdateRange) //@parm Should the range be recomputed and updated
|
|
{
|
|
TRACEBEGIN(TRCSUBSYSDISP, TRCSCOPEINTERN, "CDisplayML::UpdateScrollBar");
|
|
|
|
// Note: In the old days we didn't allow autosize & scroll bars, so to keep
|
|
// forms working, we need this special logic with respect to autosize.
|
|
if (!IsActive() || _fInRecalcScrollBars ||
|
|
!_ped->fInOurHost() && _ped->TxGetAutoSize())
|
|
{
|
|
// No scroll bars unless we are inplace active and we are not in the
|
|
// process of updating scroll bars already.
|
|
return TRUE;
|
|
}
|
|
|
|
const DWORD dwScrollBars = _ped->TxGetScrollBars();
|
|
const BOOL fHide = !(dwScrollBars & ES_DISABLENOSCROLL);
|
|
BOOL fReturn = FALSE;
|
|
BOOL fEnabled = TRUE;
|
|
BOOL fEnabledOld;
|
|
LONG lScroll;
|
|
CTxtSelection *psel = _ped->GetSelNC();
|
|
BOOL fShowCaret = FALSE;
|
|
|
|
// Get scrolling position
|
|
if(nBar == SB_VERT)
|
|
{
|
|
if(!(dwScrollBars & WS_VSCROLL))
|
|
return FALSE;
|
|
|
|
fEnabledOld = _fVScrollEnabled;
|
|
if(GetMaxVpScroll() <= _dvpView)
|
|
fEnabled = FALSE;
|
|
}
|
|
else
|
|
{
|
|
if(!(dwScrollBars & WS_HSCROLL))
|
|
{
|
|
// Even if we don't have scrollbars, we may allow horizontal
|
|
// scrolling.
|
|
if(!_fUScrollEnabled && _dupLineMax > _dupView)
|
|
_fUScrollEnabled = !!(dwScrollBars & ES_AUTOHSCROLL);
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
fEnabledOld = _fUScrollEnabled;
|
|
if(_dupLineMax <= _dupView)
|
|
fEnabled = FALSE;
|
|
}
|
|
|
|
// Don't allow ourselves to be re-entered.
|
|
// Be sure to turn this to FALSE on exit
|
|
_fInRecalcScrollBars = TRUE;
|
|
|
|
// !s beforehand because all true values aren't necessarily equal
|
|
if(!fEnabled != !fEnabledOld)
|
|
{
|
|
if(_fDeferUpdateScrollBar)
|
|
_fUpdateScrollBarDeferred = TRUE;
|
|
else
|
|
{
|
|
if (nBar == SB_HORZ)
|
|
_fUScrollEnabled = fEnabled;
|
|
else
|
|
_fVScrollEnabled = fEnabled;
|
|
}
|
|
|
|
if(!_fDeferUpdateScrollBar)
|
|
{
|
|
if(!fHide)
|
|
{
|
|
// Don't hide scrollbar, just disable
|
|
_ped->TxEnableScrollBar(nBar, fEnabled ? ESB_ENABLE_BOTH : ESB_DISABLE_BOTH);
|
|
|
|
if (!fEnabled)
|
|
{
|
|
// The scroll bar is disabled. Therefore, all the text fits
|
|
// on the screen so make sure the drawing reflects this.
|
|
_vpScroll = 0;
|
|
_dvpFirstVisible = 0;
|
|
_cpFirstVisible = 0;
|
|
_iliFirstVisible = 0;
|
|
_sPage = 0;
|
|
_ped->TxInvalidate();
|
|
}
|
|
}
|
|
else
|
|
{
|
|
fReturn = TRUE;
|
|
// Make sure to hide caret before showing scrollbar
|
|
if(psel)
|
|
fShowCaret = psel->ShowCaret(FALSE);
|
|
|
|
// Hide or show scroll bar
|
|
_ped->TxShowScrollBar(nBar, fEnabled);
|
|
// The scroll bar affects the window which in turn affects the
|
|
// display. Therefore, if word wrap, repaint
|
|
_ped->TxInvalidate();
|
|
// Needed for bug fix #5521
|
|
_ped->TxUpdateWindow();
|
|
|
|
if(fShowCaret)
|
|
psel->ShowCaret(TRUE);
|
|
}
|
|
}
|
|
}
|
|
|
|
// Set scrollbar range and thumb position
|
|
if(fEnabled)
|
|
{
|
|
if(fUpdateRange && !_fDeferUpdateScrollBar)
|
|
_ped->TxSetScrollRange(nBar, 0, GetScrollRange(nBar), FALSE);
|
|
|
|
if(_fDeferUpdateScrollBar)
|
|
_fUpdateScrollBarDeferred = TRUE;
|
|
else
|
|
{
|
|
lScroll = (nBar == SB_VERT)
|
|
? ConvertVPosToScrollPos(_vpScroll)
|
|
: ConvertUPosToScrollPos(_upScroll);
|
|
|
|
_ped->TxSetScrollPos(nBar, lScroll, TRUE);
|
|
}
|
|
}
|
|
_fInRecalcScrollBars = FALSE;
|
|
return fReturn;
|
|
}
|
|
|
|
/*
|
|
* CDisplayML::GetNaturalSize(hdcDraw, hicTarget, dwMode, pwidth, pheight)
|
|
*
|
|
* @mfunc
|
|
* Recalculate display to input width & height for TXTNS_FITTOCONTENT[2].
|
|
*
|
|
* @rdesc
|
|
* S_OK - Call completed successfully <nl>
|
|
*/
|
|
HRESULT CDisplayML::GetNaturalSize(
|
|
HDC hdcDraw, //@parm DC for drawing
|
|
HDC hicTarget, //@parm DC for information
|
|
DWORD dwMode, //@parm Type of natural size required
|
|
LONG *pwidth, //@parm Width in device units to use for fitting
|
|
LONG *pheight) //@parm Height in device units to use for fitting
|
|
{
|
|
TRACEBEGIN(TRCSUBSYSDISP, TRCSCOPEINTERN, "CDisplayML::GetNaturalSize");
|
|
|
|
HRESULT hr = S_OK;
|
|
|
|
// Set the height temporarily so the zoom factor will work out
|
|
LONG yOrigHeightClient = SetClientHeight(*pheight);
|
|
|
|
// Adjust height and width by view inset
|
|
LONG widthView = *pwidth;
|
|
LONG heightView = *pheight;
|
|
GetViewDim(widthView, heightView);
|
|
|
|
// Store adjustment so we can restore it to height & width
|
|
LONG widthAdj = *pwidth - widthView;
|
|
LONG heightAdj = *pheight - heightView;
|
|
|
|
// Init measurer at cp = 0
|
|
CMeasurer me(this);
|
|
CLine liNew;
|
|
LONG xWidth = 0, lineWidth;
|
|
LONG dvp = 0;
|
|
LONG cchText = _ped->GetTextLength();
|
|
BOOL fFirstInPara = TRUE;
|
|
|
|
LONG dulMax = GetWordWrap() ? DXtoLX(widthView) : duMax;
|
|
|
|
// The following loop generates new lines
|
|
do
|
|
{ // Stuff text into new line
|
|
UINT uiFlags = 0;
|
|
|
|
// If word wrap is turned on, then we want to break on
|
|
// words, otherwise, measure white space, etc.
|
|
if(GetWordWrap())
|
|
uiFlags = MEASURE_BREAKATWORD;
|
|
|
|
if(fFirstInPara)
|
|
uiFlags |= MEASURE_FIRSTINPARA;
|
|
|
|
me.SetDulLayout(dulMax);
|
|
if(!Measure(me, &liNew, 0, uiFlags))
|
|
{
|
|
hr = E_FAIL;
|
|
goto exit;
|
|
}
|
|
fFirstInPara = liNew._fHasEOP;
|
|
|
|
// Keep track of width of widest line
|
|
lineWidth = liNew._dup;
|
|
if(dwMode == TXTNS_FITTOCONTENT2)
|
|
lineWidth += liNew._upStart + me.GetRightIndent();
|
|
xWidth = max(xWidth, lineWidth);
|
|
dvp += liNew.GetHeight(); // Bump height
|
|
|
|
} while (me.GetCp() < cchText);
|
|
|
|
// Add caret size to width to guarantee that text fits. We don't
|
|
// want to word break because the caret won't fit when the caller
|
|
// tries a window this size.
|
|
xWidth += _ped->GetCaretWidth();
|
|
|
|
*pwidth = xWidth;
|
|
*pheight = dvp;
|
|
|
|
// Restore insets so output reflects true client rect needed
|
|
*pwidth += widthAdj;
|
|
*pheight += heightAdj;
|
|
|
|
exit:
|
|
SetClientHeight(yOrigHeightClient);
|
|
return hr;
|
|
}
|
|
|
|
/*
|
|
* CDisplayML::Clone()
|
|
*
|
|
* @mfunc
|
|
* Make a copy of this object
|
|
*
|
|
* @rdesc
|
|
* NULL - failed
|
|
* CDisplay *
|
|
*
|
|
* @devnote
|
|
* Caller of this routine is the owner of the new display object.
|
|
*/
|
|
CDisplay *CDisplayML::Clone() const
|
|
{
|
|
TRACEBEGIN(TRCSUBSYSDISP, TRCSCOPEINTERN, "CDisplayML::Clone");
|
|
|
|
CDisplayML *pdp = new CDisplayML(_ped);
|
|
|
|
if(pdp)
|
|
{
|
|
// Initialize our base class
|
|
if(pdp->CDisplay::Init())
|
|
{
|
|
pdp->InitFromDisplay(this);
|
|
pdp->_upScroll = _upScroll;
|
|
pdp->_fVScrollEnabled = _fVScrollEnabled;
|
|
pdp->_fUScrollEnabled = _fUScrollEnabled;
|
|
pdp->_fWordWrap = _fWordWrap;
|
|
pdp->_cpFirstVisible = _cpFirstVisible;
|
|
pdp->_iliFirstVisible = _iliFirstVisible;
|
|
pdp->_vpScroll = _vpScroll;
|
|
pdp->ResetDrawInfo(this);
|
|
|
|
if(_pddTarget)
|
|
{
|
|
// Create a duplicate target device for this object
|
|
pdp->SetMainTargetDC(_pddTarget->GetDC(), _dulTarget);
|
|
}
|
|
|
|
// This can't be the active view since it is a clone
|
|
// of some view.
|
|
pdp->SetActiveFlag(FALSE);
|
|
}
|
|
}
|
|
return pdp;
|
|
}
|
|
|
|
void CDisplayML::DeferUpdateScrollBar()
|
|
{
|
|
TRACEBEGIN(TRCSUBSYSDISP, TRCSCOPEINTERN, "CDisplayML::DeferUpdateScrollBar");
|
|
|
|
_fDeferUpdateScrollBar = TRUE;
|
|
_fUpdateScrollBarDeferred = FALSE;
|
|
}
|
|
|
|
BOOL CDisplayML::DoDeferredUpdateScrollBar()
|
|
{
|
|
TRACEBEGIN(TRCSUBSYSDISP, TRCSCOPEINTERN, "CDisplayML::DoDeferredUpdateScrollBar");
|
|
|
|
_fDeferUpdateScrollBar = FALSE;
|
|
if(!_fUpdateScrollBarDeferred)
|
|
return FALSE;
|
|
|
|
_fUpdateScrollBarDeferred = FALSE;
|
|
BOOL fHorizontalUpdated = UpdateScrollBar(SB_HORZ, TRUE);
|
|
|
|
return UpdateScrollBar(SB_VERT, TRUE) || fHorizontalUpdated;
|
|
}
|
|
|
|
/*
|
|
* CDisplayML::GetMaxUScroll()
|
|
*
|
|
* @mfunc
|
|
* Get the maximum x scroll value
|
|
*
|
|
* @rdesc
|
|
* Maximum x scroll value
|
|
*
|
|
*/
|
|
LONG CDisplayML::GetMaxUScroll() const
|
|
{
|
|
return _dupLineMax + _ped->GetCaretWidth();
|
|
}
|
|
|
|
/*
|
|
* CDisplayML::CreateEmptyLine()
|
|
*
|
|
* @mfunc
|
|
* Create an empty line
|
|
*
|
|
* @rdesc
|
|
* TRUE - iff successful
|
|
*/
|
|
BOOL CDisplayML::CreateEmptyLine()
|
|
{
|
|
TRACEBEGIN(TRCSUBSYSDISP, TRCSCOPEINTERN, "CDisplayML::CreateEmptyLine");
|
|
|
|
// Make sure that this is being called appropriately
|
|
AssertSz(_ped->GetTextLength() == 0,
|
|
"CDisplayML::CreateEmptyLine called inappropriately");
|
|
|
|
CMeasurer me(this); // Create a measurer
|
|
CLine * pliNew = Add(1, NULL); // Add one new line
|
|
|
|
if(!pliNew)
|
|
{
|
|
_ped->GetCallMgr()->SetOutOfMemory();
|
|
TRACEWARNSZ("CDisplayML::CreateEmptyLine unable to add CLine to CLineArray");
|
|
return FALSE;
|
|
}
|
|
|
|
// Measure the empty line
|
|
me.SetDulLayout(1);
|
|
if(!pliNew->Measure(me, MEASURE_BREAKATWORD | MEASURE_FIRSTINPARA))
|
|
{
|
|
Assert(FALSE);
|
|
return FALSE;
|
|
}
|
|
return TRUE;
|
|
}
|
|
|
|
/*
|
|
* CDisplayML::AdjustToDisplayLastLine()
|
|
*
|
|
* @mfunc
|
|
* Calculate the vpScroll necessary to get the last line to display
|
|
*
|
|
* @rdesc
|
|
* Updated vpScroll
|
|
*
|
|
*/
|
|
LONG CDisplayML::AdjustToDisplayLastLine(
|
|
LONG yBase, //@parm actual vpScroll to display
|
|
LONG vpScroll) //@parm proposed amount to scroll
|
|
{
|
|
LONG iliFirst;
|
|
LONG vFirst;
|
|
|
|
if(yBase >= _dvp)
|
|
{
|
|
// Want last line to be entirely displayed.
|
|
// Compute new first visible line
|
|
iliFirst = LineFromVpos(this, vpScroll, &vFirst, NULL);
|
|
|
|
// Is top line partial?
|
|
if(vpScroll != vFirst)
|
|
{
|
|
// Yes - bump scroll to the next line so the ScrollView
|
|
// won't bump the scroll back to display the entire
|
|
// partial line since we want the bottom to display.
|
|
vpScroll = VposFromLine(this, iliFirst + 1);
|
|
}
|
|
}
|
|
return vpScroll;
|
|
}
|
|
|
|
/*
|
|
* CDisplayML::GetResizeHeight()
|
|
*
|
|
* @mfunc
|
|
* Calculates height to return for a request resize
|
|
*
|
|
* @rdesc
|
|
* Updated vpScroll
|
|
*/
|
|
LONG CDisplayML::GetResizeHeight() const
|
|
{
|
|
TRACEBEGIN(TRCSUBSYSDISP, TRCSCOPEINTERN, "CDisplayML::GetResizeHeight");
|
|
|
|
return CalcScrollHeight(_dvp);
|
|
}
|
|
|
|
/*
|
|
* CDisplayML::RebindFirstVisible(fResetCp)
|
|
*
|
|
* @mfunc
|
|
* rebind the first visible line
|
|
*
|
|
*/
|
|
void CDisplayML::RebindFirstVisible(
|
|
BOOL fResetCp) //@parm If TRUE, reset cp to 0
|
|
{
|
|
LONG cp = fResetCp ? 0 : _cpFirstVisible;
|
|
|
|
// Change first visible entries because CLinePtr::SetCp() and
|
|
// YPosFromLine() use them, but they're not valid
|
|
_dvpFirstVisible = 0;
|
|
_cpFirstVisible = 0;
|
|
_iliFirstVisible = 0;
|
|
_vpScroll = 0;
|
|
|
|
// Recompute scrolling position and first visible values after edit
|
|
Set_yScroll(cp);
|
|
}
|
|
|
|
/*
|
|
* CDisplayML::Set_yScroll(cp)
|
|
*
|
|
* @mfunc
|
|
* Set _yScroll corresponding to cp, making sure that in PageView
|
|
* the display starts at the top of a page
|
|
*/
|
|
void CDisplayML::Set_yScroll(
|
|
LONG cp) //@parm cp at which to set valid _yScroll
|
|
{
|
|
// Recompute scrolling position and first visible values after edit
|
|
CLinePtr rp(this);
|
|
|
|
if(!rp.SetCp(cp, FALSE)) // Couldn't get to cp, so find out
|
|
cp = rp.CalculateCp(); // cp we got to
|
|
|
|
_vpScroll = VposFromLine(this, rp);
|
|
_cpFirstVisible = cp - rp.GetIch();
|
|
_iliFirstVisible = rp;
|
|
Sync_yScroll(); // Make sure _yScroll, _sPage, etc.,
|
|
} // are valid in PageView
|
|
|
|
/*
|
|
* CDisplayML::Sync_yScroll()
|
|
*
|
|
* @mfunc
|
|
* Make sure that in PageView the display starts at the top of a page.
|
|
* Notify client if page number changes
|
|
*/
|
|
void CDisplayML::Sync_yScroll()
|
|
{
|
|
if(IsInPageView()) // _yScroll must be to line at
|
|
{ // top of page
|
|
CLine *pli = Elem(_iliFirstVisible);
|
|
for(; !pli->_fFirstOnPage && _iliFirstVisible; _iliFirstVisible--)
|
|
{
|
|
pli--; // Back up to previous line
|
|
_vpScroll -= pli->GetHeight();
|
|
_cpFirstVisible -= pli->_cch;
|
|
}
|
|
LONG sPage = _sPage;
|
|
if(sPage != CalculatePage(0))
|
|
{
|
|
_ped->TxInvalidate();
|
|
_ped->TxNotify(EN_PAGECHANGE, NULL);
|
|
}
|
|
}
|
|
}
|
|
|
|
/*
|
|
* CDisplayML::Paginate(ili, fRebindFirstVisible)
|
|
*
|
|
* @mfunc
|
|
* Recompute page breaks from ili on
|
|
*
|
|
* @rdesc
|
|
* TRUE if success
|
|
*/
|
|
BOOL CDisplayML::Paginate (
|
|
LONG ili, //@parm Line to redo pagination from
|
|
BOOL fRebindFirstVisible) //@parm If TRUE, call RebindFirstVisible()
|
|
{
|
|
LONG cLine = Count();
|
|
|
|
if(!IsInPageView() || ili >= cLine || ili < 0)
|
|
return FALSE;
|
|
|
|
LONG iliSave = ili;
|
|
CLine * pli = Elem(ili);
|
|
|
|
// Synchronize to top of current page
|
|
for(; ili && !pli->_fFirstOnPage; pli--, ili--)
|
|
;
|
|
// Guard against widow-orphan changes by backing up an extra page
|
|
if(ili && iliSave - ili < 2)
|
|
{
|
|
for(pli--, ili--; ili && !pli->_fFirstOnPage; pli--, ili--)
|
|
;
|
|
}
|
|
|
|
LONG cLinePage = 1; // One line on new page
|
|
LONG dvpHeight = pli->GetHeight(); // Height on new page
|
|
|
|
pli->_fFirstOnPage = TRUE; // First line on page
|
|
ili++; // One less line to consider
|
|
pli++; // Advance to next line
|
|
|
|
for(; ili < cLine; ili++, pli++) // Process all lines from ili to EOD
|
|
{
|
|
dvpHeight += pli->GetHeight(); // Add in current line height
|
|
cLinePage++; // One more line on page (maybe)
|
|
pli->_fFirstOnPage = FALSE;
|
|
|
|
CLine *pliPrev = pli - 1; // Point at previous line
|
|
|
|
if(dvpHeight > _dvpView || pliPrev->_fHasFF || pli->_fPageBreakBefore)
|
|
{
|
|
cLinePage--;
|
|
if(cLinePage > 1 && !pliPrev->_fHasFF) // && fWidowOrphanControl)
|
|
{
|
|
if(pli->_fHasFF && pli->_cch == 1) // FF line height causing
|
|
continue; // eject, so leave it on current page
|
|
|
|
//If we are in the middle of a wrapped object, bump it to next page
|
|
//We do not do widow/orphan if it could divide wrapped objects between pages
|
|
if (_ped->IsRich())
|
|
{
|
|
if (pli->_cObjectWrapLeft || pli->_cObjectWrapRight)
|
|
{
|
|
CLine *pliOrig = pli;
|
|
if (pli->_cObjectWrapLeft && !pli->_fFirstWrapLeft)
|
|
{
|
|
while (!pli->_fFirstWrapLeft)
|
|
pli--;
|
|
}
|
|
int cLineBack = pliOrig - pli;
|
|
pli = pliOrig;
|
|
|
|
if (pli->_cObjectWrapRight && !pli->_fFirstWrapRight)
|
|
{
|
|
while (!pli->_fFirstWrapRight)
|
|
pli--;
|
|
}
|
|
cLineBack = max(cLineBack, (int)(pliOrig - pli));
|
|
pli = pliOrig;
|
|
|
|
if (cLineBack < cLinePage) //Don't do this if object is larger than page
|
|
{
|
|
cLinePage -= cLineBack;
|
|
pliPrev -= cLineBack;
|
|
pli -= cLineBack;
|
|
ili -= cLineBack;
|
|
}
|
|
}
|
|
|
|
// If this line and the previous one are in the same para,
|
|
// we might need widow/orphan logic
|
|
if (!pli->_fFirstInPara && !pliPrev->_cObjectWrapLeft &&
|
|
!pliPrev->_cObjectWrapRight && (cLinePage > 1) )
|
|
{
|
|
// If this line ends in an EOP bump both to following page
|
|
// (widow/orphan), but only if either the line is short, or
|
|
// we absolutely know that there will only be one line on
|
|
// the page. Do the same if prev line ends in a hyphenated
|
|
// word, and the preceding line does not
|
|
if (pli->_cchEOP && (pli->_dup < _dupView/2 || ili >= cLine - 1) || // Do we need -2 instead of -1?
|
|
pliPrev->_ihyph && ili > 1 && !pliPrev->_fFirstOnPage && !pliPrev[-1]._ihyph)
|
|
{
|
|
cLinePage--; // Point to previous line
|
|
pliPrev--;
|
|
pli--;
|
|
ili--;
|
|
}
|
|
}
|
|
|
|
// Don't end a page with a heading.
|
|
if(cLinePage > 1 && pliPrev->_nHeading &&
|
|
!pliPrev->_cObjectWrapLeft && !pliPrev->_cObjectWrapRight)
|
|
{
|
|
cLinePage--;
|
|
pliPrev--;
|
|
pli--;
|
|
ili--;
|
|
}
|
|
}
|
|
}
|
|
pli->_fFirstOnPage = TRUE; // Define first line on page
|
|
cLinePage = 1; // One line on new page
|
|
dvpHeight = pli->GetHeight(); // Current height of new page
|
|
}
|
|
}
|
|
if(fRebindFirstVisible)
|
|
RebindFirstVisible();
|
|
return TRUE;
|
|
}
|
|
|
|
/*
|
|
* CDisplayML::CalculatePage(iliFirst)
|
|
*
|
|
* @mfunc
|
|
* Compute page number for _iliFirstVisible starting with iliFirst
|
|
*
|
|
* @rdesc
|
|
* Page number calculated
|
|
*/
|
|
LONG CDisplayML::CalculatePage (
|
|
LONG iliFirst)
|
|
{
|
|
if(Count() < 2 || !IsInPageView())
|
|
{
|
|
_sPage = 0;
|
|
return 0;
|
|
}
|
|
|
|
if(iliFirst < 1)
|
|
_sPage = 0;
|
|
|
|
Assert(iliFirst >= 0 && iliFirst < Count());
|
|
|
|
LONG iDir = 1;
|
|
LONG n = _iliFirstVisible - iliFirst;
|
|
CLine *pli = Elem(iliFirst); // Point at next/previous line
|
|
|
|
if(n < 0)
|
|
{
|
|
n = -n;
|
|
iDir = -1;
|
|
}
|
|
else
|
|
pli++;
|
|
|
|
for(; n--; pli += iDir)
|
|
if(pli->_fFirstOnPage)
|
|
{
|
|
_sPage += iDir;
|
|
if(_sPage < 0)
|
|
_sPage = 0;
|
|
}
|
|
|
|
AssertSz(Elem(_iliFirstVisible)->_fFirstOnPage,
|
|
"CDisplayML::CalculatePage: _iliFirstVisible not top of page");
|
|
|
|
return _sPage;
|
|
}
|
|
|
|
/*
|
|
* CDisplayML::GetPage(piPage, dwFlags, pcrg)
|
|
*
|
|
* @mfunc
|
|
* Get page number for _iliFirstVisible
|
|
*
|
|
* @rdesc
|
|
* HRESULT = !piPage ? E_INVALIDARG :
|
|
* IsInPageView() ? NOERROR : E_FAIL
|
|
*/
|
|
HRESULT CDisplayML::GetPage(
|
|
LONG *piPage, //@parm Out parm for page number
|
|
DWORD dwFlags, //@parm Flags for which page to use
|
|
CHARRANGE *pcrg) //@parm Out parm for CHARRANGE for page
|
|
{
|
|
if(!piPage)
|
|
return E_INVALIDARG;
|
|
|
|
*piPage = 0;
|
|
|
|
if(dwFlags) // No flags defined yet
|
|
return E_INVALIDARG;
|
|
|
|
if(!IsInPageView())
|
|
return E_FAIL;
|
|
|
|
#ifdef DEBUG
|
|
if(_sPage < 20)
|
|
{
|
|
LONG sPage = _sPage;
|
|
CalculatePage(0);
|
|
AssertSz(sPage == _sPage, "CDisplayML::GetPage: invalid cached page number");
|
|
}
|
|
#endif
|
|
|
|
*piPage = _sPage;
|
|
if(pcrg)
|
|
{
|
|
pcrg->cpMin = _cpFirstVisible;
|
|
GetCliVisible(&pcrg->cpMost, TRUE);
|
|
}
|
|
return NOERROR;
|
|
}
|
|
|
|
/*
|
|
* CDisplayML::SetPage(iPage)
|
|
*
|
|
* @mfunc
|
|
* Go to page iPage
|
|
*
|
|
* @rdesc
|
|
* HRESULT
|
|
*/
|
|
HRESULT CDisplayML::SetPage (
|
|
LONG iPage)
|
|
{
|
|
if(!IsInPageView())
|
|
return E_FAIL;
|
|
|
|
LONG nLine = Count();
|
|
|
|
if(iPage < 0 || !nLine)
|
|
return E_INVALIDARG;
|
|
|
|
CLine *pli = Elem(0); // Scroll from page 0
|
|
LONG vpScroll = 0;
|
|
LONG vpScrollLast = 0;
|
|
|
|
nLine--; // Decrement nLine so pli++ below will always be valid
|
|
for(LONG ili = 0; ili < nLine && iPage; ili++)
|
|
{
|
|
vpScroll += pli->GetHeight();
|
|
|
|
pli++;
|
|
if(pli->_fFirstOnPage) // Start of new page
|
|
{
|
|
vpScrollLast = vpScroll;
|
|
iPage--; // One less to go
|
|
}
|
|
}
|
|
if(!_iliFirstVisible) // This shouldn't be necessary...
|
|
_vpScroll = 0;
|
|
|
|
ScrollView(_upScroll, vpScrollLast, FALSE, FALSE);
|
|
return NOERROR;
|
|
}
|
|
|
|
/*
|
|
* CDisplayML::GetCurrentPageHeight()
|
|
*
|
|
* @mfunc
|
|
* Return page height of current page in PageView mode
|
|
*
|
|
* @rdesc
|
|
* page height of current page in PageView mode; else 0;
|
|
*/
|
|
LONG CDisplayML::GetCurrentPageHeight() const
|
|
{
|
|
if(!IsInPageView())
|
|
return 0;
|
|
|
|
LONG cLine = Count();
|
|
LONG dvp = 0;
|
|
LONG i = _iliFirstVisible;
|
|
CLine * pli = Elem(i);
|
|
|
|
do
|
|
{
|
|
dvp += pli->GetHeight(); // Add in first line's height in any
|
|
pli++; // case
|
|
i++;
|
|
}
|
|
while(i < cLine && !pli->_fFirstOnPage);
|
|
|
|
return dvp;
|
|
}
|
|
|
|
|
|
// ================================ DEBUG methods ============================================
|
|
|
|
#ifdef DEBUG
|
|
/*
|
|
* CDisplayML::CheckLineArray()
|
|
*
|
|
* @mfunc
|
|
* DEBUG routine that Asserts unless:
|
|
* 1) sum of all line counts equals count of characters in story
|
|
* 2) sum of all line heights equals height of display galley
|
|
*/
|
|
void CDisplayML::CheckLineArray() const
|
|
{
|
|
TRACEBEGIN(TRCSUBSYSDISP, TRCSCOPEINTERN, "CDisplayML::CheckLineArray");
|
|
|
|
LONG ili = Count();
|
|
|
|
// If we are marked as needing a recalc or if we are in the process of a
|
|
// background recalc, we cannot verify the line array
|
|
if(!_fRecalcDone || _fNeedRecalc || !ili)
|
|
return;
|
|
|
|
LONG cchText = _ped->GetTextLength();
|
|
|
|
if (!cchText)
|
|
return;
|
|
|
|
LONG cp = 0;
|
|
BOOL fFirstInPara;
|
|
BOOL fPrevLineEOP = TRUE;
|
|
LONG dvp = 0;
|
|
CLine const *pli = Elem(0);
|
|
CTxtPtr tp(_ped, 0);
|
|
|
|
while(ili--)
|
|
{
|
|
fFirstInPara = pli->_fFirstInPara;
|
|
if(fPrevLineEOP ^ fFirstInPara)
|
|
{
|
|
tp.SetCp(cp);
|
|
AssertSz(fFirstInPara && IsASCIIEOP(tp.GetPrevChar()),
|
|
"CDisplayML::CheckLineArray: Invalid first/prev flags");
|
|
}
|
|
AssertSz(pli->_cch, "CDisplayML::CheckLineArray: cch == 0");
|
|
|
|
dvp += pli->GetHeight();
|
|
cp += pli->_cch;
|
|
fPrevLineEOP = pli->_fHasEOP;
|
|
pli++;
|
|
}
|
|
|
|
if((cp != cchText) && (cp != _cpCalcMax))
|
|
{
|
|
Tracef(TRCSEVINFO, "sigma (*this)[]._cch = %ld, cchText = %ld", cp, cchText);
|
|
AssertSz(FALSE,
|
|
"CDisplayML::CheckLineArray: sigma(*this)[]._cch != cchText");
|
|
}
|
|
|
|
if(dvp != _dvp)
|
|
{
|
|
Tracef(TRCSEVINFO, "sigma (*this)[]._dvp = %ld, _dvp = %ld", dvp, _dvp);
|
|
AssertSz(FALSE,
|
|
"CDisplayML::CheckLineArray: sigma(*this)[]._dvp != _dvp");
|
|
}
|
|
}
|
|
|
|
void CDisplayML::DumpLines(
|
|
LONG iliFirst,
|
|
LONG cli)
|
|
{
|
|
TRACEBEGIN(TRCSUBSYSDISP, TRCSCOPEINTERN, "CDisplayML::DumpLines");
|
|
|
|
LONG cch;
|
|
LONG ili;
|
|
TCHAR rgch[512];
|
|
|
|
if(Count() == 1)
|
|
wcscpy(rgch, TEXT("1 line"));
|
|
else
|
|
wsprintf(rgch, TEXT("%d lines"), Count());
|
|
|
|
#ifdef UNICODE
|
|
// TraceTag needs to take UNICODE...
|
|
#else
|
|
TRACEINFOSZ(TRCSEVINFO, rgch);
|
|
#endif
|
|
|
|
if(cli < 0)
|
|
cli = Count();
|
|
else
|
|
cli = min(cli, Count());
|
|
if(iliFirst < 0)
|
|
iliFirst = Count() - cli;
|
|
else
|
|
cli = min(cli, Count() - iliFirst);
|
|
|
|
for(ili = iliFirst; cli > 0; ili++, cli--)
|
|
{
|
|
const CLine * const pli = Elem(ili);
|
|
|
|
wsprintf(rgch, TEXT("Line %d (%ldc%ldw%ldh): \""), ili, pli->_cch,
|
|
pli->_dup, pli->GetHeight());
|
|
cch = wcslen(rgch);
|
|
cch += GetLineText(ili, rgch + cch, CchOfCb(sizeof(rgch)) - cch - 4);
|
|
rgch[cch++] = TEXT('\"');
|
|
rgch[cch] = TEXT('\0');
|
|
#ifdef UNICODE
|
|
// TraceTag needs to take UNICODE...
|
|
#else
|
|
TRACEINFOSZ(TRCSEVINFO, rgch);
|
|
#endif
|
|
}
|
|
}
|
|
|
|
/*
|
|
* CDisplayML::CheckView()
|
|
*
|
|
* @mfunc
|
|
* DEBUG routine that checks coherence between _iliFirstVisible,
|
|
* _cpFirstVisible, and _dvpFirstVisible
|
|
*/
|
|
void CDisplayML::CheckView()
|
|
{
|
|
TRACEBEGIN(TRCSUBSYSDISP, TRCSCOPEINTERN, "CDisplayML::CheckView");
|
|
|
|
LONG dvp;
|
|
VerifyFirstVisible(&dvp);
|
|
|
|
if(dvp != _vpScroll + _dvpFirstVisible && !IsInPageView())
|
|
{
|
|
Tracef(TRCSEVINFO, "sigma CLine._dvp = %ld, CDisplay.vFirstLine = %ld", dvp, _vpScroll + _dvpFirstVisible);
|
|
AssertSz(FALSE, "CLine._dvp != VIEW.vFirstLine");
|
|
}
|
|
}
|
|
|
|
/*
|
|
* CDisplayML::VerifyFirstVisible(pHeight)
|
|
*
|
|
* @mfunc
|
|
* DEBUG routine that checks coherence between _iliFirstVisible
|
|
* and _cpFirstVisible
|
|
*
|
|
* @rdesc TRUE if things are hunky dory; FALSE otherwise
|
|
*/
|
|
BOOL CDisplayML::VerifyFirstVisible(
|
|
LONG *pHeight)
|
|
{
|
|
LONG cchSum;
|
|
LONG ili = _iliFirstVisible;
|
|
CLine const *pli = Elem(0);
|
|
LONG dvp;
|
|
|
|
for(cchSum = dvp = 0; ili--; pli++)
|
|
{
|
|
cchSum += pli->_cch;
|
|
dvp += pli->GetHeight();
|
|
}
|
|
|
|
if(pHeight)
|
|
*pHeight = dvp;
|
|
|
|
if(cchSum != _cpFirstVisible)
|
|
{
|
|
Tracef(TRCSEVINFO, "sigma CLine._cch = %ld, CDisplay.cpFirstVisible = %ld", cchSum, _cpMin);
|
|
AssertSz(FALSE, "sigma CLine._cch != VIEW.cpMin");
|
|
|
|
return FALSE;
|
|
}
|
|
return TRUE;
|
|
}
|
|
|
|
#endif // DEBUG
|
|
|
|
|