able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/windows/richedit/re41/select.cpp

4540 lines
122 KiB
C++
Raw Normal View History

Add source files
2020-09-26 03:20:57 -05:00
/*
* @doc INTERNAL
*
* @module SELECT.CPP -- Implement the CTxtSelection class |
*
* This module implements the internal CTxtSelection methods.
* See select2.c and range2.c for the ITextSelection methods
*
* Authors: <nl>
* RichEdit 1.0 code: David R. Fulmer
* Christian Fortini (initial conversion to C++)
* Murray Sargent <nl>
*
* @devnote
* The selection UI is one of the more intricate parts of an editor.
* One common area of confusion is the "ambiguous cp", that is,
* a cp at the beginning of one line, which is also the cp at the
* end of the previous line. We control which location to use by
* the _fCaretNotAtBOL flag. Specifically, the caret is OK at the
* beginning of the line (BOL) (_fCaretNotAtBOL = FALSE) except in
* three cases:
*
* 1) the user clicked at or past the end of a wrapped line,
* 2) the user typed End key on a wrapped line,
* 3) the active end of a nondegenerate selection is at the EOL.
*
* Copyright (c) 1995-2000, Microsoft Corporation. All rights reserved.
*/
#include "_common.h"
#include "_select.h"
#include "_edit.h"
#include "_disp.h"
#include "_measure.h"
#include "_font.h"
#include "_rtfconv.h"
#include "_antievt.h"
#ifndef NOLINESERVICES
#include "_ols.h"
#endif
ASSERTDATA
// ======================= Invariant stuff and Constructors ======================================================
#define DEBUG_CLASSNAME CTxtSelection
#include "_invar.h"
#ifdef DEBUG
BOOL
CTxtSelection::Invariant() const
{
// FUTURE: maybe add some thoughtful asserts...
static LONG numTests = 0;
numTests++; // how many times we've been called
if(IsInOutlineView() && _cch)
{
LONG cpMin, cpMost;
GetRange(cpMin, cpMost);
CTxtPtr tp(_rpTX); // Scan range for an EOP
tp.SetCp(cpMin);
// _fSelHasEop flag may be off when last cr selected so don't
// assert in that case.
if (GetPed()->GetAdjustedTextLength() != cpMost)
{
AssertSz((unsigned)(tp.FindEOP(cpMost - cpMin) != 0) == _fSelHasEOP,
"Incorrect CTxtSelection::_fSelHasEOP");
}
}
return CTxtRange::Invariant();
}
#endif
CTxtSelection::CTxtSelection(CDisplay * const pdp) :
CTxtRange(pdp->GetPed())
{
TRACEBEGIN(TRCSUBSYSSEL, TRCSCOPEINTERN, "CTxtSelection::CTxtSelection");
Assert(pdp);
Assert(GetPed());
_fSel = TRUE; // This range is a selection
_pdp = pdp;
_hbmpCaret = NULL;
_fEOP = FALSE; // Haven't typed a CR
// Set show-selection flag to inverse of hide-selection flag in ped
_fShowSelection = !GetPed()->fHideSelection();
// When we are initialized we don't have a selection therefore,
// we do want to show caret.
_fShowCaret = TRUE;
}
void SelectionNull(CTxtEdit *ped)
{
TRACEBEGIN(TRCSUBSYSSEL, TRCSCOPEINTERN, "SelectionNull");
if(ped)
ped->SetSelectionToNull();
}
CTxtSelection::~CTxtSelection()
{
TRACEBEGIN(TRCSUBSYSSEL, TRCSCOPEINTERN, "CTxtSelection::~CTxtSelection");
DeleteCaretBitmap(FALSE);
// Notify edit object that we are gone (if there's a nonNULL ped, i.e.,
// if the selection isn't a zombie).
SelectionNull(GetPed());
}
//////////////////////////////// Assignments /////////////////////////////////////////
CRchTxtPtr& CTxtSelection::operator =(const CRchTxtPtr& rtp)
{
TRACEBEGIN(TRCSUBSYSSEL, TRCSCOPEINTERN, "CTxtSelection::operator =");
_TEST_INVARIANT_
return CTxtRange::operator =(rtp);
}
CTxtRange& CTxtSelection::operator =(const CTxtRange &rg)
{
TRACEBEGIN(TRCSUBSYSSEL, TRCSCOPEINTERN, "CTxtSelection::operator =");
_TEST_INVARIANT_
return CTxtRange::operator =(rg);
}
////////////////////// Update caret & selection mechanism ///////////////////////////////
/*
* CTxtSelection::Update(fScrollIntoView)
*
* @mfunc
* Update selection and/or caret on screen. As a side
* effect, this methods ends deferring updates.
*
* @rdesc
* TRUE if success, FALSE otherwise
*/
BOOL CTxtSelection::Update (
BOOL fScrollIntoView) //@parm TRUE if should scroll caret into view
{
TRACEBEGIN(TRCSUBSYSSEL, TRCSCOPEINTERN, "CTxtSelection::Update");
LONG cch;
LONG cchSave = _cch;
LONG cchText = GetTextLength();
LONG cp, cpMin, cpMost;
LONG cpSave = GetCp();
BOOL fMoveBack = _fMoveBack;
CTxtEdit *ped = GetPed();
_fUpdatedFromCp0 = FALSE;
if(!ped->fInplaceActive() || ped->IsStreaming())
{
// Nothing to do while inactive or streaming in text or RTF data
return TRUE;
}
if(!_cch) // Update _cpAnchor, etc.
{
while(GetPF()->IsTableRowDelimiter() && _rpTX.GetChar() != ENDFIELD)
{
if(_fMoveBack)
{
if(!BackupCRLF(CSC_NORMAL, FALSE)) // Don't leave at table row start
_fMoveBack = FALSE;
}
else
AdvanceCRLF(CSC_NORMAL, FALSE); // Bypass table row start
}
UpdateForAutoWord();
}
if(_cch && (_nSelExpandLevel || _fSelExpandCell))
{
BOOL fInTable = GetPF()->InTable();
if(!fInTable)
{
CFormatRunPtr rp(_rpPF);
rp.Move(-_cch);
fInTable = (ped->GetParaFormat(rp.GetFormat()))->InTable();
}
if(fInTable)
{
if(_nSelExpandLevel)
FindRow(&cpMin, &cpMost, _nSelExpandLevel);
else
FindCell(&cpMin, &cpMost);
Set(cpMost, cpMost - cpMin);
if(!_fSelExpandCell)
_nSelExpandLevel = 0;
}
}
if(GetPF()->InTable()) // Don't leave IP in cell
{ // that's vertically merged
if(fMoveBack) // with cell above
{
while(GetPrevChar() == NOTACHAR)
{ // Move before NOTACHAR and
Move(-2, _cch); // either CELL or TRD's CR
if(CRchTxtPtr::GetChar() != CELL)
{
Assert(GetPrevChar() == STARTFIELD);
Move(-3, _cch); // Move before TRD START and
break; // preceding TRD END
}
}
}
else
while(CRchTxtPtr::GetChar() == NOTACHAR)
Move(2, _cch); // Move past NOTACHAR CELL
}
if(IsInOutlineView() && !ped->IsMouseDown() && _rpPF.IsValid())
{
CPFRunPtr rp(*this);
cp = GetCp();
GetRange(cpMin, cpMost);
if(_cch && (cpMin || cpMost < cchText))
{
LONG *pcpMin = &cpMin;
LONG *pcpMost = &cpMost;
// If selection contains an EOP, expand to para boundaries
if(_fSelHasEOP)
{
if(_fMoveBack ^ (_cch < 0)) // Decreasing selection
{ // size: move active end
if(_fMoveBack)
pcpMost = NULL; // to StartOf para
else
pcpMin = NULL; // to EndOf para
}
Expander(tomParagraph, TRUE, NULL, pcpMin, pcpMost);
}
LONG cpMinSave = cpMin; // Save initial cp's to see if
LONG cpMostSave = cpMost; // we need to Set() below
// The following handles selection expansion correctly, but
// not compression; need logic like that preceding Expander()
rp.Move(cpMin - cp); // Start at cpMin
if(rp.IsCollapsed())
cpMin += rp.FindExpandedBackward();
rp.AdjustForward();
BOOL fCpMinCollapsed = rp.IsCollapsed();
rp.Move(cpMost - cpMin); // Go to cpMost
Assert(cpMost == rp.CalculateCp());
if(rp.IsCollapsed())
cpMost += rp.FindExpandedForward();
if(fCpMinCollapsed || rp.IsCollapsed() && cpMost < cchText)
{
if(rp.IsCollapsed())
{
rp.Move(cpMin - cpMost);
rp.AdjustForward();
cpMost = cpMin;
}
else
cpMin = cpMost;
}
if(cpMin != cpMinSave || cpMost != cpMostSave)
Set(cpMost, cpMost - cpMin);
}
if(!_cch && rp.IsCollapsed()) // Note: above may have collapsed
{ // selection...
cch = fMoveBack ? rp.FindExpandedBackward() : 0;
if(rp.IsCollapsed())
cch = rp.FindExpanded();
Move(cch, FALSE);
rp.AdjustForward();
if(cch <= 0 && rp.IsCollapsed() && _rpTX.IsAfterEOP())
BackupCRLF(CSC_NORMAL, FALSE);
_fCaretNotAtBOL = FALSE;
}
}
// Don't let active end be in hidden text, unless selection is
// nondegenerate with active end at cp 0 and other end unhidden.
CCFRunPtr rp(*this);
cp = GetCp();
GetRange(cpMin, cpMost);
if(_cch && (cpMin || cpMost < cchText))
{
rp.Move(cpMin - cp); // Start at cpMin
BOOL fHidden = cpMin && rp.IsInHidden();
rp.Move(cpMost - cpMin); // Go to cpMost
if(fHidden) // It's hidden, so collapse
Collapser(tomEnd); // selection at End for treatment
else if(rp.IsInHidden() && // cpMin OK, how about cpMost?
cpMost < cchText)
{ // Check both sides of edge
Collapser(tomEnd); // collapse selection at end
}
}
if(!_cch && rp.IsInHidden()) // Note: above may have collapsed
{ // selection...
cch = fMoveBack ? rp.FindUnhiddenBackward() : 0;
if(!fMoveBack || rp.IsHidden())
cch = rp.FindUnhidden();
Move(cch, FALSE);
_fCaretNotAtBOL = FALSE;
}
if((cchSave ^ _cch) < 0) // Don't change active end
FlipRange();
if(!_cch && cchSave) // Fixups changed nondegenerate
{ // selection to IP. Update
Update_iFormat(-1); // _iFormat and _fCaretNotAtBOL
_fCaretNotAtBOL = FALSE;
}
if(!_cch && _fCaretNotAtBOL // For IP case, make sure it is on new line if
&& _rpTX.IsAfterEOP()) // IP after EOP
_fCaretNotAtBOL = FALSE;
_TEST_INVARIANT_
CheckTableIP(TRUE); // If IP bet TRED & CELL, ensure
// CELL displayed on own line
// Recalc up to active end (caret)
if(!_pdp->WaitForRecalc(GetCp(), -1)) // Line recalc failure
Set(0, 0); // Put caret at start of text
ShowCaret(ped->_fFocus);
UpdateCaret(fScrollIntoView); // Update Caret position, possibly
// scrolling it into view
ped->TxShowCaret(FALSE);
UpdateSelection(); // Show new selection
ped->TxShowCaret(TRUE);
if(!cpSave && GetCp() && !_cch) // If insertion point & moved away
_fUpdatedFromCp0 = TRUE; // from cp = 0, set flag so that
// nonUI inserts can go back to 0
return TRUE;
}
/*
* CTxtSelection::CheckSynchCharSet(dwCharFlags)
*
* @mfunc
* Check if the current keyboard matches the current font's charset;
* if not, call CheckChangeFont to find the right font
*
* @rdesc
* Current keyboard codepage
*/
UINT CTxtSelection::CheckSynchCharSet(
QWORD qwCharFlags)
{
CTxtEdit *ped = GetPed();
LONG iFormat = GetiFormat();
const CCharFormat *pCF = ped->GetCharFormat(iFormat);
BYTE iCharRep = pCF->_iCharRep;
HKL hkl = GetKeyboardLayout(0xFFFFFFFF); // Force refresh
WORD wlidKbd = LOWORD(hkl);
BYTE iCharRepKbd = CharRepFromLID(wlidKbd);
UINT uCodePageKbd = CodePageFromCharRep(iCharRepKbd);
// If current font is not set correctly,
// change to a font preferred by current keyboard.
// To summarize the logic below:
// Check that lcidKbd is valid
// Check that current charset differs from current keyboard
// Check that current keyboard is legit in a single codepage control
// Check that current charset isn't SYMBOL, DEFAULT, or OEM
if (wlidKbd && iCharRep != iCharRepKbd &&
(!ped->_fSingleCodePage || iCharRepKbd == ANSI_INDEX ||
uCodePageKbd == (ped->_pDocInfo ?
ped->_pDocInfo->_wCpg :
GetSystemDefaultCodePage())) &&
iCharRep != SYMBOL_INDEX && iCharRep != OEM_INDEX &&
!(IsFECharRep(iCharRepKbd) && iCharRep == ANSI_INDEX))
{
CheckChangeFont(hkl, iCharRepKbd, iFormat, qwCharFlags);
}
return uCodePageKbd;
}
/*
* CTxtSelection::MatchKeyboardToPara()
*
* @mfunc
* Match the keyboard to the current paragraph direction. If the paragraph
* is an RTL paragraph then the keyboard will be switched to an RTL
* keyboard, and vice versa.
*
* @rdesc
* TRUE iff a keyboard was changed
*
* @devnote
* We use the following tests when trying to find a keyboard to match the
* paragraph direction:
*
* See if the current keyboard matches the direction of the paragraph.
*
* Search backward from rtp looking for a charset that matches the
* direction of the paragraph.
*
* Search forward from rtp looking for a charset that matches the
* direction of the paragraph.
*
* See if the default charformat charset matches the direction of the
* paragraph.
*
* See if there's only a single keyboard that matches the paragraph
* direction.
*
* If all this fails, just leave the keyboard alone.
*/
BOOL CTxtSelection::MatchKeyboardToPara()
{
CTxtEdit *ped = GetPed();
if(!ped->IsBiDi() || !GetPed()->_fFocus || GetPed()->_fIMEInProgress)
return FALSE;
const CParaFormat *pPF = GetPF();
if(pPF->IsTableRowDelimiter())
return FALSE;
BOOL fRTLPara = (pPF->_wEffects & PFE_RTLPARA) != 0;// Get paragraph direction
if(W32->IsBiDiLcid(LOWORD(GetKeyboardLayout(0))) == fRTLPara)
return FALSE;
// Current keyboard direction didn't match paragraph direction...
BYTE iCharRep;
HKL hkl = 0;
const CCharFormat * pCF;
CFormatRunPtr rpCF(_rpCF);
// Look backward in text, trying to find a CharSet that matches
// the paragraph direction.
do
{
pCF = ped->GetCharFormat(rpCF.GetFormat());
iCharRep = pCF->_iCharRep;
if(IsRTLCharRep(iCharRep) == fRTLPara)
hkl = W32->CheckChangeKeyboardLayout(iCharRep);
} while (!hkl && rpCF.PrevRun());
if(!hkl)
{
// Didn't find an appropriate charformat so reset run pointer
// and look forward instead
rpCF = _rpCF;
while (!hkl && rpCF.NextRun())
{
pCF = ped->GetCharFormat(rpCF.GetFormat());
iCharRep = pCF->_iCharRep;
if(IsRTLCharRep(iCharRep) == fRTLPara)
hkl = W32->CheckChangeKeyboardLayout(iCharRep);
}
if(!hkl)
{
// Still didn't find an appropriate charformat so see if
// default charformat matches paragraph direction.
pCF = ped->GetCharFormat(rpCF.GetFormat());
iCharRep = pCF->_iCharRep;
if(IsRTLCharRep(iCharRep) == fRTLPara)
hkl = W32->CheckChangeKeyboardLayout(iCharRep);
if(!hkl)
{
// If even that didn't work, walk through the list of
// keyboards and grab the first one we come to that matches
// the paragraph direction.
pCF = NULL;
hkl = W32->FindDirectionalKeyboard(fRTLPara);
}
}
}
if (hkl && ped->_fFocus && IsCaretShown())
{
CreateCaret();
ped->TxShowCaret(TRUE);
}
return hkl ? TRUE : FALSE;
}
/*
* CTxtSelection::GetCaretPoint(&rcClient, pt, &rp, fBeforeCp)
*
* @mfunc
* This routine determines where the caret should be positioned
* on screen.
* This routine is just a call to PointFromTp(), except for the Bidi
* case. In that case if we are told to retrieve formatting from the
* forward CP, we draw the caret at the logical left edge of the CP.
* Else, we draw it at the logical right edge of the previous CP.
*
* @rdesc
* TRUE if we didn't OOM.
*/
BOOL CTxtSelection::GetCaretPoint(
RECTUV &rcClient,
POINTUV &pt,
CLinePtr *prp,
BOOL fBeforeCp)
{
CDispDim dispdim;
CRchTxtPtr rtp(*this);
UINT taMode = TA_BASELINE | TA_LOGICAL;
if(GetPed()->IsBiDi() && _rpCF.IsValid())
{
if(_fHomeOrEnd) // Home/End
taMode |= _fCaretNotAtBOL ? TA_ENDOFLINE : TA_STARTOFLINE;
else if(!GetIchRunCF() || !GetCchLeftRunCF())
{
// In a Bidi context on a run boundary where the reverse level
// changes, then we should respect the fBeforeCp flag.
BYTE bLevelBwd, bLevelFwd;
BOOL fStart = FALSE;
LONG cp = rtp._rpTX.GetCp();
CBiDiLevel level;
bLevelBwd = bLevelFwd = rtp.IsParaRTL() ? 1 : 0;
rtp._rpCF.AdjustBackward();
if (cp)
bLevelBwd = rtp._rpCF.GetLevel();
rtp._rpCF.AdjustForward();
if (cp != rtp._rpTX.GetTextLength())
{
bLevelFwd = rtp._rpCF.GetLevel(&level);
fStart = level._fStart;
}
if((bLevelBwd != bLevelFwd || fStart) && !fBeforeCp && rtp.Move(-1))
{
// Direction change at cp, caret in prev CF run, and can
// backspace to previous char: then get to the right of
// previous char
taMode |= TA_RIGHT;
_fCaretNotAtBOL = !rtp._rpTX.IsAfterEOP();
}
}
}
if (_pdp->PointFromTp(rtp, &rcClient, _fCaretNotAtBOL, pt, prp, taMode, &dispdim) < 0)
return FALSE;
return TRUE;
}
/*
* CTxtSelection::UpdateCaret(fScrollIntoView, bForceCaret)
*
* @mfunc
* This routine updates caret/selection active end on screen.
* It figures its position, size, clipping, etc. It can optionally
* scroll the caret into view.
*
* @rdesc
* TRUE if view was scrolled, FALSE otherwise
*
* @devnote
* The caret is actually shown on screen only if _fShowCaret is TRUE.
*/
BOOL CTxtSelection::UpdateCaret (
BOOL fScrollIntoView, //@parm If TRUE, scroll caret into view if we have
BOOL bForceCaret) // focus or if not and selection isn't hidden
{
TRACEBEGIN(TRCSUBSYSSEL, TRCSCOPEINTERN, "CTxtSelection::UpdateCaret");
_TEST_INVARIANT_
if(_pdp->IsFrozen()) // If display is currently frozen
{ // save call for another time
_pdp->SaveUpdateCaret(fScrollIntoView);
return FALSE;
}
CTxtEdit *ped = GetPed();
if(ped->IsStreaming()) // Don't bother doing anything if we
return FALSE; // are loading in text or RTF data
if(!ped->fInplaceActive()) // If not inplace active, set up
{ // for when focus is regained
if(fScrollIntoView)
ped->_fScrollCaretOnFocus = TRUE;
return FALSE;
}
while(!_cch && _rpTX.IsAtTRD(STARTFIELD))
{
// Don't leave selection at start of a row; move it to start of first
// cell. REVIEW: this restriction could be relaxed with some work, and
// it would be nice to do so for ease of programmability. Specifically,
// Whenever text would be inserted immediately before a table row,
// one would be sure that doesn't become part of the table row-start
// delimiter paragraph, i.e., is inserted in the previous paragraph
// (if that one isn't a TRD para), or is inserted in its own paragraph.
AdvanceCRLF(CSC_NORMAL, FALSE);
}
DWORD dwScrollBars = ped->TxGetScrollBars();
BOOL fAutoVScroll = FALSE;
BOOL fAutoUScroll = FALSE;
BOOL fBeforeCp = _rpTX.IsAfterEOP();
POINTUV pt;
CLinePtr rp(_pdp);
RECTUV rcClient;
RECTUV rcView;
LONG dupView, dvpView;
LONG upScroll = _pdp->GetUpScroll();
LONG vpScroll = _pdp->GetVpScroll();
INT dvpAbove = 0; // Ascent of line above & beyond IP
INT dvpAscent; // Ascent of IP
INT dvpAscentLine;
LONG vpBase; // Base of IP & line
INT vpBelow = 0; // Descent of line below & beyond IP
INT dvpDescent; // Descent of IP
INT dvpDescentLine;
INT vpSum;
LONG vpViewTop, vpViewBottom;
if(ped->_fFocus && (_fShowCaret || bForceCaret))
{
_fShowCaret = TRUE; // We're trying to force caret to display so set this flag to true
if(!_fDualFontMode && !_fNoKeyboardUpdate && !_fIsChar && !_fHomeOrEnd)
{
// Avoid re-entrance to CheckChangeKeyboardLayout
_fNoKeyboardUpdate = TRUE;
// If we're in "dual font" mode, charset change is only
// temporary and we don't want to change keyboard layout
CheckChangeKeyboardLayout();
if(!fBeforeCp && ped->IsBiDi() && _rpCF.IsValid() &&
(!_rpCF.GetIch() || !_rpCF.GetCchLeft()))
{
_rpCF.AdjustBackward();
BOOL fRTLPrevRun = IsRTLCharRep(GetCF()->_iCharRep);
_rpCF.AdjustForward();
if (fRTLPrevRun != IsRTLCharRep(GetCF()->_iCharRep) &&
fRTLPrevRun != W32->IsBiDiLcid(GetKeyboardLCID()))
{
fBeforeCp = TRUE;
}
}
_fNoKeyboardUpdate = FALSE;
}
}
// Get client rectangle once to save various callers getting it
ped->TxGetClientRect(&rcClient);
_pdp->GetViewRect(rcView, &rcClient);
// View can be bigger than client rect because insets can be negative.
// We don't want the caret to be any bigger than the client view otherwise
// the caret will leave pixel dust on other windows.
vpViewTop = max(rcView.top, rcClient.top);
vpViewBottom = min(rcView.bottom, rcClient.bottom);
if(ped->IsInPageView())
{
LONG vpHeight = _pdp->GetCurrentPageHeight();
if(vpHeight)
{
vpHeight += rcView.top;
if(vpHeight < vpViewBottom)
vpViewBottom = vpHeight;
}
}
dupView = rcView.right - rcView.left;
dvpView = vpViewBottom - vpViewTop;
if(fScrollIntoView)
{
fAutoVScroll = (dwScrollBars & ES_AUTOVSCROLL) != 0;
fAutoUScroll = (dwScrollBars & ES_AUTOHSCROLL) != 0;
// If we're not forcing a scroll, only scroll if window has focus
// or selection isn't hidden
if (!ped->Get10Mode() || !GetForceScrollCaret())
fScrollIntoView = ped->_fFocus || !ped->fHideSelection();
}
if(!fScrollIntoView && (fAutoVScroll || fAutoUScroll))
{ // Would scroll but don't have
ped->_fScrollCaretOnFocus = TRUE; // focus. Signal to scroll
if (!ped->Get10Mode() || !GetAutoVScroll())
fAutoVScroll = fAutoUScroll = FALSE; // when we do get focus
}
SetAutoVScroll(FALSE);
if (!_cch && IsInOutlineView() && IsCollapsed())
goto not_visible;
if (!GetCaretPoint(rcClient, pt, &rp, fBeforeCp))
goto not_visible;
// HACK ALERT - Because plain-text multiline controls do not have the
// automatic EOP, we need to special case their processing here because
// if you are at the end of the document and last character is an EOP,
// you need to be on the next line in the display not the current line.
if(CheckPlainTextFinalEOP()) // Terminated by an EOP
{
LONG Align = GetPF()->_bAlignment;
LONG dvpHeight;
pt.u = rcView.left; // Default left
if(Align == PFA_CENTER)
pt.u = (rcView.left + rcView.right)/2;
else if(Align == PFA_RIGHT)
pt.u = rcView.right;
pt.u -= upScroll; // Absolute coordinate
// Bump the y up a line. We get away with the calculation because
// the document is plain text so all lines have the same height.
// Also, note that the rp below is used only for height
// calculations, so it is perfectly valid for the same reason
// even though it is not actually pointing to the correct line.
// (I told you this is a hack.)
dvpHeight = rp->GetHeight();
pt.v += dvpHeight;
// Apply hack to PageView case as well
if (ped->IsInPageView())
vpViewBottom += dvpHeight;
}
_upCaret = pt.u;
vpBase = pt.v;
// Compute caret height, ascent, and descent
dvpAscent = GetCaretHeight(&dvpDescent);
dvpAscent -= dvpDescent;
// Default to line empty case. Use what came back from the default
// calculation above.
dvpDescentLine = dvpDescent;
dvpAscentLine = dvpAscent;
if(rp.IsValid())
{
if(rp->GetDescent() != -1)
{
// Line has been measured so we can use the line's values
dvpDescentLine = rp->GetDescent();
dvpAscentLine = rp->GetHeight() - dvpDescentLine;
}
}
if(dvpAscent + dvpDescent == 0)
{
dvpAscent = dvpAscentLine;
dvpDescent = dvpDescentLine;
}
else
{
// This is a bit counter-intuitive at first. Basically, even if
// the caret should be large (e.g., due to a large font at the
// insertion point), we can only make it as big as the line. If
// a character is inserted, then the line becomes bigger, and we
// can make the caret the correct size.
dvpAscent = min(dvpAscent, dvpAscentLine);
dvpDescent = min(dvpDescent, dvpDescentLine);
}
if(fAutoVScroll)
{
Assert(dvpDescentLine >= dvpDescent);
Assert(dvpAscentLine >= dvpAscent);
vpBelow = dvpDescentLine - dvpDescent;
dvpAbove = dvpAscentLine - dvpAscent;
vpSum = dvpAscent;
// Scroll as much as possible into view, giving priorities
// primarily to IP and secondarily ascents
if(vpSum > dvpView)
{
dvpAscent = dvpView;
dvpDescent = 0;
dvpAbove = 0;
vpBelow = 0;
}
else if((vpSum += dvpDescent) > dvpView)
{
dvpDescent = dvpView - dvpAscent;
dvpAbove = 0;
vpBelow = 0;
}
else if((vpSum += dvpAbove) > dvpView)
{
dvpAbove = dvpView - (vpSum - dvpAbove);
vpBelow = 0;
}
else if((vpSum += vpBelow) > dvpView)
vpBelow = dvpView - (vpSum - vpBelow);
}
else
{
AssertSz(dvpAbove == 0, "dvpAbove non-zero");
AssertSz(vpBelow == 0, "vpBelow non-zero");
}
// Update real caret x pos (constant during vertical moves)
_upCaretReally = _upCaret - rcView.left + upScroll;
if (!(dwScrollBars & ES_AUTOHSCROLL) && // Not auto UScrolling
!_pdp->IsUScrollEnabled()) // and no scrollbar
{
if (_upCaret < rcView.left) // Caret off left edge
_upCaret = rcView.left;
else if(_upCaret + GetCaretDelta() > rcView.right)// Caret off right edge
_upCaret = rcView.right - duCaret; // Back caret up to
} // exactly the right edge
// From this point on we need a new caret
_fCaretCreated = FALSE;
if(ped->_fFocus)
ped->TxShowCaret(FALSE); // Hide old caret before
// making a new one
if(vpBase + dvpDescent + vpBelow > vpViewTop &&
vpBase - dvpAscent - dvpAbove < vpViewBottom)
{
if(vpBase - dvpAscent - dvpAbove < vpViewTop) // Caret is partially
{ // visible
if(fAutoVScroll) // Top isn't visible
goto scrollit;
Assert(dvpAbove == 0);
dvpAscent = vpBase - vpViewTop; // Change ascent to amount
if(vpBase < vpViewTop) // visible
{ // Move base to top
dvpDescent += dvpAscent;
dvpAscent = 0;
vpBase = vpViewTop;
}
}
if(vpBase + dvpDescent + vpBelow > vpViewBottom)
{
if(fAutoVScroll) // Bottom isn't visible
goto scrollit;
Assert(vpBelow == 0);
dvpDescent = vpViewBottom - vpBase; // Change descent to amount
if(vpBase > vpViewBottom) // visible
{ // Move base to bottom
dvpAscent += dvpDescent;
dvpDescent = 0;
vpBase = vpViewBottom;
}
}
// Anything still visible?
if(dvpAscent <= 0 && dvpDescent <= 0)
goto not_visible;
// If left or right isn't visible, scroll or set non_visible
if (_upCaret < rcView.left || // Left isn't visible
_upCaret + GetCaretDelta() > rcView.right)// Right isn't visible
{
if(fAutoUScroll)
goto scrollit;
goto not_visible;
}
_vpCaret = vpBase - dvpAscent;
_dvpCaret = (INT) dvpAscent + dvpDescent;
}
else if(fAutoUScroll || fAutoVScroll) // Caret isn't visible
goto scrollit; // scroll it into view
else
{
not_visible:
// Caret isn't visible, don't show it
_upCaret = -32000;
_vpCaret = -32000;
_dvpCaret = 1;
}
// Now update caret for real on screen. We only want to show the caret
// if it is in the view and there is no selection.
if(ped->_fFocus && _fShowCaret)
{
CreateCaret();
ped->TxShowCaret(TRUE);
}
return FALSE;
scrollit:
if(fAutoVScroll)
{
// Scroll to top for cp = 0. This is important if the first line
// contains object(s) taller than the client area is high. The
// resulting behavior agrees with the Word UI in all ways except in
// Backspacing (deleting) the char at cp = 0 when it is followed by
// other chars that preceed the large object.
if(!GetCp())
vpScroll = 0;
else if(ped->IsInPageView())
vpScroll += vpBase - dvpAscent - dvpAbove;
else if(vpBase - dvpAscent - dvpAbove < vpViewTop) // Top invisible
vpScroll -= vpViewTop - (vpBase - dvpAscent - dvpAbove); // Make it so
else if(vpBase + dvpDescent + vpBelow > vpViewBottom) // Bottom invisible
{
vpScroll += vpBase + dvpDescent + vpBelow - vpViewBottom; // Make it so
// Don't do following special adjust if the current line is bigger
// than the client area
if(rp->GetHeight() < vpViewBottom - vpViewTop)
{
vpScroll = _pdp->AdjustToDisplayLastLine(vpBase + rp->GetHeight(),
vpScroll);
}
}
}
if(fAutoUScroll)
{
// We don't scroll in chunks since sytem edit control doesn't
if(_upCaret < rcView.left) // Left invisible
upScroll -= rcView.left - _upCaret; // Make it visible
else if(_upCaret + GetCaretDelta() > rcView.right)// Right invisible
upScroll += _upCaret + duCaret - rcView.left - dupView;// Make it visible
}
if(vpScroll != _pdp->GetVpScroll() || upScroll != _pdp->GetUpScroll())
{
if (_pdp->ScrollView(upScroll, vpScroll, FALSE, FALSE) == FALSE)
{
if(ped->_fFocus && _fShowCaret)
{
CreateCaret();
ped->TxShowCaret(TRUE);
}
return FALSE;
}
return TRUE;
}
return FALSE;
}
/*
* CTxtSelection::GetCaretHeight(pdvpDescent)
*
* @mfunc
* Calculate the height of the caret
*
* @rdesc
* Caret height, <lt> 0 if failed
*/
INT CTxtSelection::GetCaretHeight (
INT *pdvpDescent) const //@parm Out parm to receive caret descent
{
TRACEBEGIN(TRCSUBSYSSEL, TRCSCOPEINTERN, "CTxtSelection::GetCaretHeight");
// (undefined if the return value is <lt> 0)
_TEST_INVARIANT_
CLock lock; // Uses global (shared) FontCache
CTxtEdit *ped = GetPed();
const CCharFormat *pCF = ped->GetCharFormat(_iFormat);
const CDevDesc *pdd = _pdp->GetDdRender();
HDC hdc = pdd->GetDC();
if(!hdc)
return -1;
LONG yHeight = -1;
LONG dypInch = MulDiv(GetDeviceCaps(hdc, LOGPIXELSY), _pdp->GetZoomNumerator(), _pdp->GetZoomDenominator());
CCcs *pccs = ped->GetCcs(pCF, dypInch);
if(!pccs)
goto ret;
LONG yOffset, yAdjust;
pccs->GetOffset(pCF, dypInch, &yOffset, &yAdjust);
SHORT yAdjustFE;
yAdjustFE = pccs->AdjustFEHeight(!fUseUIFont() && ped->_pdp->IsMultiLine());
if(pdvpDescent)
*pdvpDescent = pccs->_yDescent + yAdjustFE - yAdjust - yOffset;
yHeight = pccs->_yHeight + (yAdjustFE << 1);
pccs->Release();
ret:
pdd->ReleaseDC(hdc);
return yHeight;
}
/*
* CTxtSelection::ShowCaret(fShow)
*
* @mfunc
* Hide or show caret
*
* @rdesc
* TRUE if caret was previously shown, FALSE if it was hidden
*/
BOOL CTxtSelection::ShowCaret (
BOOL fShow) //@parm TRUE for showing, FALSE for hiding
{
TRACEBEGIN(TRCSUBSYSSEL, TRCSCOPEINTERN, "CTxtSelection::ShowCaret");
_TEST_INVARIANT_
const BOOL fRet = _fShowCaret;
if(fRet != fShow)
{
_fShowCaret = fShow;
if(GetPed()->_fFocus || GetPed()->fInOurHost())
{
if(fShow && !_fCaretCreated)
CreateCaret();
GetPed()->TxShowCaret(fShow);
}
}
return fRet;
}
/*
* CTxtSelection::IsCaretInView()
*
* @mfunc
* Returns TRUE iff caret is inside visible view
*/
BOOL CTxtSelection::IsCaretInView() const
{
TRACEBEGIN(TRCSUBSYSSEL, TRCSCOPEINTERN, "CTxtSelection::IsCaretInView");
_TEST_INVARIANT_
RECTUV rc;
_pdp->GetViewRect(rc);
return (_upCaret + duCaret > rc.left) &&
(_upCaret < rc.right) &&
(_vpCaret + _dvpCaret > rc.top) &&
(_vpCaret < rc.bottom);
}
/*
* CTxtSelection::IsCaretHorizontal()
*
* @mfunc
* Returns TRUE iff caret is horizontal
* FUTURE murrays (keithcu) The selection needs to keep track
* of what layout the selection is in so it can answer these
* kinds of questions
*/
BOOL CTxtSelection::IsCaretHorizontal() const
{
return !IsUVerticalTflow(_pdp->GetTflow());
}
/*
* CTxtSelection::CaretNotAtBOL()
*
* @mfunc
* Returns TRUE iff caret is not allowed at BOL
*/
BOOL CTxtSelection::CaretNotAtBOL() const
{
TRACEBEGIN(TRCSUBSYSSEL, TRCSCOPEINTERN, "CTxtSelection::CaretNotAtBOL");
_TEST_INVARIANT_
return _cch ? (_cch > 0) : _fCaretNotAtBOL;
}
/*
* CTxtSelection::CheckTableIP(fShowCellLine)
*
* @mfunc
* Open/close up display line if selection is an insertion point
* at a CELL mark preceded by table-row end delimiter for fOpenLine
* = TRUE/FALSE, respectively
*/
void CTxtSelection::CheckTableIP(
BOOL fShowCellLine) //@parm Open/close up line for CELL if preceded by TRED
{
TRACEBEGIN(TRCSUBSYSSEL, TRCSCOPEINTERN, "CTxtSelection::CheckTableIP");
if (!_cch && (fShowCellLine ^ _fShowCellLine) &&
_rpTX.GetChar() == CELL && _rpTX.IsAfterTRD(ENDFIELD))
{
_fShowCellLine = fShowCellLine;
_pdp->RecalcLine(GetCp());
}
}
/*
* CTxtSelection::LineLength(pcp)
*
* @mfunc
* get # unselected chars on lines touched by current selection
*
* @rdesc
* said number of chars
*/
LONG CTxtSelection::LineLength(
LONG *pcp) const
{
TRACEBEGIN(TRCSUBSYSSEL, TRCSCOPEINTERN, "CTxtSelection::LineLength");
_TEST_INVARIANT_
LONG cch;
CLinePtr rp(_pdp);
if(!_cch) // Insertion point
{
rp.SetCp(GetCp(), _fCaretNotAtBOL);
cch = rp.GetAdjustedLineLength();
*pcp = GetCp() - rp.GetIch();
}
else
{
LONG cpMin, cpMost, cchLast;
GetRange(cpMin, cpMost);
rp.SetCp(cpMin, FALSE); // Selections can't start at EOL
cch = rp.GetIch();
*pcp = cpMin - cch;
rp.SetCp(cpMost, TRUE); // Selections can't end at BOL
// Remove trailing EOP, if it exists and isn't already selected
cchLast = rp.GetAdjustedLineLength() - rp.GetIch();
if(cchLast > 0)
cch += cchLast;
}
return cch;
}
/*
* CTxtSelection::ShowSelection(fShow)
*
* @mfunc
* Update, hide or show selection on screen
*
* @rdesc
* TRUE iff selection was previously shown
*/
BOOL CTxtSelection::ShowSelection (
BOOL fShow) //@parm TRUE for showing, FALSE for hiding
{
TRACEBEGIN(TRCSUBSYSSEL, TRCSCOPEINTERN, "CTxtSelection::ShowSelection");
_TEST_INVARIANT_
const BOOL fShowPrev = _fShowSelection;
const BOOL fInplaceActive = GetPed()->fInplaceActive();
LONG cpSelSave = _cpSel;
LONG cchSelSave = _cchSel;
// Sleep(1000);
_fShowSelection = fShow;
if(fShowPrev && !fShow)
{
if(cchSelSave) // Hide old selection
{
// Set up selection before telling the display to update
_cpSel = 0;
_cchSel = 0;
if(fInplaceActive)
_pdp->InvertRange(cpSelSave, cchSelSave, selSetNormal);
}
}
else if(!fShowPrev && fShow)
{
if(_cch) // Show new selection
{
// Set up selection before telling the display to update
_cpSel = GetCp();
_cchSel = _cch;
if(fInplaceActive)
_pdp->InvertRange(GetCp(), _cch, selSetHiLite);
}
}
return fShowPrev;
}
/*
* CTxtSelection::UpdateSelection()
*
* @mfunc
* Updates selection on screen
*
* Note:
* This method inverts the delta between old and new selections
*/
void CTxtSelection::UpdateSelection()
{
TRACEBEGIN(TRCSUBSYSSEL, TRCSCOPEINTERN, "CTxtSelection::UpdateSelection");
_TEST_INVARIANT_
LONG cp = GetCp();
LONG cpNA = cp - _cch;
LONG cpSelNA = _cpSel - _cchSel;
LONG cpMin, cpMost;
LONG cpMinSel = 0;
LONG cpMostSel = 0;
CObjectMgr* pobjmgr = NULL;
LONG NumObjInSel = 0, NumObjInOldSel = 0;
LONG cpSelSave = _cpSel;
LONG cchSelSave = _cchSel;
GetRange(cpMin, cpMost);
//We need to know if there were objects is the previous and current
//selections to determine how they should be selected.
if(GetPed()->HasObjects())
{
pobjmgr = GetPed()->GetObjectMgr();
if(pobjmgr)
{
CTxtRange tr(GetPed(), _cpSel, _cchSel);
tr.GetRange(cpMinSel, cpMostSel);
NumObjInSel = pobjmgr->CountObjectsInRange(cpMin, cpMost);
NumObjInOldSel = pobjmgr->CountObjectsInRange(cpMinSel, cpMostSel);
}
}
//If the old selection contained a single object and nothing else
//we need to notify the object manager that this is no longer the
//case if the selection is changing.
if (NumObjInOldSel && (abs(_cchSel) == 1) &&
!(cpMin == cpMinSel && cpMost == cpMostSel))
{
if(pobjmgr)
pobjmgr->HandleSingleSelect(GetPed(), cpMinSel, /* fHilite */ FALSE);
}
// Update selection data before the invert so the selection can be
// painted by the render
_cpSel = GetCp();
_cchSel = _cch;
if(_fShowSelection)
{
if(!_cch || !cchSelSave || // Old/new selection missing,
cpMost < min(cpSelSave, cpSelNA) || // or new preceeds old,
cpMin > max(cpSelSave, cpSelNA)) // or new follows old, so
{ // they don't intersect
if(_cch)
_pdp->InvertRange(cp, _cch, selSetHiLite);
if(cchSelSave)
_pdp->InvertRange(cpSelSave, cchSelSave, selSetNormal);
}
else
{
if(cpNA != cpSelNA) // Old & new dead ends differ
{ // Invert text between them
_pdp->InvertRange(cpNA, cpNA - cpSelNA, selUpdateNormal);
}
if(cp != cpSelSave) // Old & new active ends differ
{ // Invert text between them
_pdp->InvertRange(cp, cp - cpSelSave, selUpdateHiLite);
}
}
}
// If new selection contains a single object and nothing else, we need
// to notify object manager as long as it's not the same object.
if (NumObjInSel && abs(_cch) == 1 &&
(cpMin != cpMinSel || cpMost != cpMostSel))
{
if(pobjmgr)
pobjmgr->HandleSingleSelect(GetPed(), cpMin, /* fHiLite */ TRUE);
}
}
/*
* CTxtSelection::SetSelection(cpFirst, cpMost)
*
* @mfunc
* Set selection between two cp's
*
* @devnote
* <p cpFirst> and <p cpMost> must be greater than 0, but may extend
* past the current max cp. In that case, the cp will be truncated to
* the max cp (at the end of the text).
*/
void CTxtSelection::SetSelection (
LONG cpMin, //@parm Start of selection and dead end
LONG cpMost) //@parm End of selection and active end
{
TRACEBEGIN(TRCSUBSYSSEL, TRCSCOPEINTERN, "CTxtSelection::SetSelection");
_TEST_INVARIANT_
CTxtEdit *ped = GetPed();
StopGroupTyping();
if(ped->HasObjects())
{
CObjectMgr* pobjmgr = GetPed()->GetObjectMgr();
if(pobjmgr)
{
COleObject *pobjactive = pobjmgr->GetInPlaceActiveObject();
if (pobjactive)
{
if (pobjactive != pobjmgr->GetObjectFromCp(cpMin) || cpMost - cpMin > 1)
pobjactive->DeActivateObj();
}
}
}
_fCaretNotAtBOL = FALSE; // Put caret for ambiguous cp at BOL
Set(cpMost, cpMost - cpMin); // Set() validates cpMin, cpMost
if(GetPed()->fInplaceActive()) // Inplace active:
Update(!ped->Get10Mode() ? TRUE : !ped->fHideSelection()); // update selection now
else
{
// Update selection data used for screen display so whenever we
// get displayed the selection will be displayed.
_cpSel = GetCp();
_cchSel = _cch;
if(!ped->fHideSelection())
{
// Selection isn't hidden so tell container to update display
// when it feels like.
ped->TxInvalidate();
ped->TxUpdateWindow();
}
}
CancelModes(); // Cancel word selection mode
}
/*
* CTxtSelection::PointInSel(pt, prcClient, Hit)
*
* @mfunc
* Figures whether a given point is within the selection
*
* @rdesc
* TRUE if point inside selection, FALSE otherwise
*/
BOOL CTxtSelection::PointInSel (
const POINTUV pt, //@parm Point in containing window client coords
RECTUV *prcClient, //@parm Client rectangle can be NULL if active
HITTEST Hit) const //@parm May be computer Hit value
{
TRACEBEGIN(TRCSUBSYSSEL, TRCSCOPEINTERN, "CTxtSelection::PointInSel");
_TEST_INVARIANT_
if(!_cch || Hit && Hit < HT_Text) // Degenerate range (no selection):
return FALSE; // mouse can't be in, or Hit not
// in text
LONG cpActual;
_pdp->CpFromPoint(pt, prcClient, NULL, NULL, FALSE, &Hit, NULL, &cpActual);
if(Hit < HT_Text)
return FALSE;
LONG cpMin, cpMost;
GetRange(cpMin, cpMost);
return cpActual >= cpMin && cpActual < cpMost;
}
////////////////////////////////// Selection with the mouse ///////////////////////////////////
/*
* CTxtSelection::SetCaret(pt, fUpdate)
*
* @mfunc
* Sets caret at a given point
*
* @devnote
* In the plain-text case, placing the caret at the beginning of the
* line following the final EOP requires some extra code, since the
* underlying rich-text engine doesn't assign a line to a final EOP
* (plain-text doesn't currently have the rich-text final EOP). We
* handle this by checking to see if the count of lines times the
* plain-text line height is below the actual y position. If so, we
* move the cp to the end of the story.
*/
void CTxtSelection::SetCaret(
const POINTUV pt, //@parm Point of click
BOOL fUpdate) //@parm If TRUE, update the selection/caret
{
TRACEBEGIN(TRCSUBSYSSEL, TRCSCOPEINTERN, "CTxtSelection::SetCaret");
_TEST_INVARIANT_
LONG cp, cpActual;
CDispDim dispdim;
HITTEST Hit;
RECTUV rcView;
CLinePtr rp(_pdp);
CRchTxtPtr rtp(GetPed());
LONG vp;
StopGroupTyping();
// Set caret at point
if(_pdp->CpFromPoint(pt, NULL, &rtp, &rp, FALSE, &Hit, &dispdim, &cpActual) >= 0)
{
cp = rtp.GetCp();
// If the resolved CP is greater than the cp we are above, then we
// want to stay backwards.
BOOL fBeforeCp = cp <= cpActual;
// Set selection to the correct location. If plain-text
// multiline control, we need to check to see if pt.v is below
// the last line of text. If so and if the text ends with an EOP,
// we need to set the cp at the end of the story and set up to
// display the caret at the beginning of the line below the last
// line of text
if(!IsRich() && _pdp->IsMultiLine()) // Plain-text,
{ // multiline control
_pdp->GetViewRect(rcView, NULL);
vp = pt.v + _pdp->GetVpScroll() - rcView.top;
if(vp > _pdp->LineCount()*rp->GetHeight()) // Below last line of
{ // text
rtp.Move(tomForward); // Move rtp to end of text
if(rtp._rpTX.IsAfterEOP()) // If text ends with an
{ // EOP, set up to move
cp = rtp.GetCp(); // selection there
rp.Move(-rp.GetIch()); // Set rp._ich = 0 to
} // set _fCaretNotAtBOL
} // = FALSE to display
} // caret at next BOL
Set(cp, 0);
if(GetPed()->IsBiDi())
{
if(!fBeforeCp)
_rpCF.AdjustBackward();
else
_rpCF.AdjustForward();
Set_iCF(_rpCF.GetFormat());
}
_fCaretNotAtBOL = rp.GetIch() != 0; // Caret OK at BOL if click
if(fUpdate)
Update(TRUE);
else
UpdateForAutoWord();
_SelMode = smNone; // Cancel word selection mode
}
}
/*
* CTxtSelection::SelectWord(pt)
*
* @mfunc
* Select word around a given point
*/
void CTxtSelection::SelectWord (
const POINTUV pt) //@parm Point of click
{
TRACEBEGIN(TRCSUBSYSSEL, TRCSCOPEINTERN, "CTxtSelection::SelectWord");
_TEST_INVARIANT_
// Get rp where the hit is
if(_pdp->CpFromPoint(pt, NULL, this, NULL, FALSE) >= 0)
{
if(GetPF()->IsTableRowDelimiter()) // Select table row
{
_cch = 0; // Start with IP at pt
Expander(tomRow, TRUE, NULL, &_cpAnchorMin, &_cpAnchorMost);
}
else
{ // Select word at IP
if(GetCp() == GetAdjustedTextLength())
{ // Special case since
LONG cpMax = GetTextLength(); // FindWordBreak() can't
Set(cpMax, cpMax - GetCp()); // move forward in this case
}
else
{
_cch = 0; // Start with IP at pt
FindWordBreak(WB_MOVEWORDRIGHT, FALSE); // Go to end of word
FindWordBreak(WB_MOVEWORDLEFT, TRUE); // Extend to start of word
}
GetRange(_cpAnchorMin, _cpAnchorMost);
GetRange(_cpWordMin, _cpWordMost);
if(!_fInAutoWordSel)
_SelMode = smWord;
// cpMost needs to be the active end
if(_cch < 0)
FlipRange();
}
Update(FALSE);
}
}
/*
* CTxtSelection::SelectUnit(pt, Unit)
*
* @mfunc
* Select line/paragraph around a given point and enter
* line/paragraph selection mode. In Outline View, convert
* SelectLine to SelectPara, and SelectPara to SelectPara
* along with all subordinates
*/
void CTxtSelection::SelectUnit (
const POINTUV pt, //@parm Point of click
LONG Unit) //@parm tomLine or tomParagraph
{
TRACEBEGIN(TRCSUBSYSSEL, TRCSCOPEINTERN, "CTxtSelection::SelectPara");
_TEST_INVARIANT_
AssertSz(Unit == tomLine || Unit == tomParagraph,
"CTxtSelection::SelectPara: Unit must equal tomLine/tomParagraph");
LONG nHeading;
CLinePtr rp(_pdp);
// Get rp and selection active end where the hit is
if(_pdp->CpFromPoint(pt, NULL, this, &rp, FALSE) >= 0)
{
LONG cchBackward, cchForward;
BOOL fOutline = IsInOutlineView();
if(Unit == tomLine && !fOutline) // SelectLine
{
_cch = 0; // Start with insertion
cchBackward = -rp.GetIch(); // point at pt
cchForward = rp->_cch;
_SelMode = smLine;
}
else // SelectParagraph
{
cchBackward = rp.FindParagraph(FALSE); // Go to start of para
cchForward = rp.FindParagraph(TRUE); // Extend to end of para
_SelMode = smPara;
}
Move(cchBackward, FALSE);
if(Unit == tomParagraph && fOutline) // Move para in outline
{ // view
rp.AdjustBackward(); // If heading, include
nHeading = rp.GetHeading(); // subordinate paras
if(nHeading)
{
for(; rp.NextRun(); cchForward += rp->_cch)
{
LONG n = rp.GetHeading();
if(n && n <= nHeading)
break;
}
}
}
Move(cchForward, TRUE);
GetRange(_cpAnchorMin, _cpAnchorMost);
Update(FALSE);
}
}
/*
* CTxtSelection::SelectAll()
*
* @mfunc
* Select all text in story
*/
void CTxtSelection::SelectAll()
{
TRACEBEGIN(TRCSUBSYSSEL, TRCSCOPEINTERN, "CTxtSelection::SelectAll");
_TEST_INVARIANT_
StopGroupTyping();
LONG cchText = GetTextLength();
Set(cchText, cchText);
Update(FALSE);
}
/*
* CTxtSelection::ExtendSelection(pt)
*
* @mfunc
* Extend/Shrink selection (moves active end) to given point
*/
void CTxtSelection::ExtendSelection (
const POINTUV pt) //@parm Point to extend to
{
TRACEBEGIN(TRCSUBSYSSEL, TRCSCOPEINTERN, "CTxtSelection::ExtendSelection");
_TEST_INVARIANT_
LONG cch;
LONG cchPrev = _cch;
LONG cp;
LONG cpMin, cpMost;
BOOL fAfterEOP;
const BOOL fWasInAutoWordSel = _fInAutoWordSel;
HITTEST hit;
INT iDir = 0;
CTxtEdit * ped = GetPed();
CLinePtr rp(_pdp);
CRchTxtPtr rtp(ped);
StopGroupTyping();
// Get rp and rtp at the point pt
if(_pdp->CpFromPoint(pt, NULL, &rtp, &rp, TRUE, &hit) < 0 || hit == HT_RightOfText)
return;
// If we are in word, line, or paragraph select mode, we need to make
// sure the active end is correct. If we are extending backward from
// the first Unit selected, we want the active end to be at cpMin. If
// we are extending forward from the first Unit selected, we want the
// active end to be at cpMost.
if(_SelMode != smNone)
{
cch = _cpAnchorMost - _cpAnchorMin;
GetRange(cpMin, cpMost);
cp = rtp.GetCp();
if(cp <= cpMin && _cch > 0) // If active end changes,
Set(_cpAnchorMin, -cch); // select the original
// Unit (will be extended
if(cp >= cpMost && _cch < 0) // below)
Set(_cpAnchorMost, cch);
}
cch = rp.GetIch();
if(_SelMode > smWord && cch == rp->_cch) // If in line or para select
{ // modes and pt at EOL,
rtp.Move(-cch); // make sure we stay on that
rp.Move(-cch); // line
cch = 0;
}
SetCp(rtp.GetCp(), TRUE); // Move active end to pt
// Caret OK at BOL _unless_
_fCaretNotAtBOL = _cch > 0 || cch == rp->_cch;// forward selection
// Now adjust selection
if(_SelMode == smLine) // depending on mode
{ // Extend selection by line
if(_cch >= 0) // Active end at cpMost
cch -= rp->_cch; // Setup to add chars to EOL
Move(-cch, TRUE);
}
else if(_SelMode == smPara)
Move(rp.FindParagraph(_cch >= 0), TRUE);// Extend selection by para
else
{
// If the sign of _cch has changed this means that the direction
// of the selection is changing and we want to reset the auto
// selection information.
if((_cch ^ cchPrev) < 0)
{
_fAutoSelectAborted = FALSE;
_cpWordMin = _cpAnchorMin;
_cpWordMost = _cpAnchorMost;
}
cp = rtp.GetCp();
fAfterEOP = rtp._rpTX.IsAfterEOP();
_fInAutoWordSel = _SelMode != smWord && GetPed()->TxGetAutoWordSel()
&& !_fAutoSelectAborted
&& (cp < _cpWordMin || cp > _cpWordMost);
if(_fInAutoWordSel && !fWasInAutoWordSel)
{
CTxtPtr txtptr(GetPed(), _cpAnchor);
// Extend both ends dead to word boundaries
ExtendToWordBreak(fAfterEOP,
_cch < 0 ? WB_MOVEWORDLEFT : WB_MOVEWORDRIGHT);
if(_cch < 0)
{
// Direction is left so update word border on left
_cpWordPrev = _cpWordMin;
_cpWordMin = GetCp();
}
else
{
// Direction is right so update word border on right
_cpWordPrev = _cpWordMost;
_cpWordMost = GetCp();
}
// If we are at start of a word already, we don't need to extend
// selection in other direction
if(!txtptr.IsAtBOWord() && txtptr.GetChar() != ' ')
{
FlipRange();
Move(_cpAnchor - GetCp(), TRUE);// Extend from anchor
FindWordBreak(_cch < 0 ? WB_MOVEWORDLEFT : WB_MOVEWORDRIGHT, TRUE);
if(_cch > 0) // Direction is right so
_cpWordMost = GetCp(); // update word border on right
else // Direction is left so
_cpWordMin = GetCp(); // update word border on left
FlipRange();
}
}
else if(_fInAutoWordSel || _SelMode == smWord)
{
// Save direction
iDir = cp <= _cpWordMin ? WB_MOVEWORDLEFT : WB_MOVEWORDRIGHT;
if(_SelMode == smWord) // Extend selection by word
{
if(cp > _cpAnchorMost || cp < _cpAnchorMin)
FindWordBreak(iDir, TRUE);
else if(_cch <= 0) // Maintain current active end
Set(_cpAnchorMin, _cpAnchorMin - _cpAnchorMost);
else
Set(_cpAnchorMost, _cpAnchorMost - _cpAnchorMin);
}
else
ExtendToWordBreak(fAfterEOP, iDir);
if(_fInAutoWordSel)
{
if(WB_MOVEWORDLEFT == iDir)
{
// Direction is left so update word border on left
_cpWordPrev = _cpWordMin;
_cpWordMin = GetCp();
}
else
{
// Direction is right so update word border on right
_cpWordPrev = _cpWordMost;
_cpWordMost = GetCp();
}
}
}
else if(fWasInAutoWordSel)
{
// If we are in between where the previous word ended and
// the cp we auto selected to, then we want to stay in
// auto select mode.
if(_cch < 0)
{
if(cp >= _cpWordMin && cp < _cpWordPrev)
{
// Set direction for end of word search
iDir = WB_MOVEWORDLEFT;
// Mark that we are still in auto select mode
_fInAutoWordSel = TRUE;
}
}
else if(cp <= _cpWordMost && cp >= _cpWordPrev)
{
// Mark that we are still in auto select mode
_fInAutoWordSel = TRUE;
// Set direction for end of word search
iDir = WB_MOVEWORDRIGHT;
}
//We have to check to see if we are on the boundary between
//words because we don't want to extend the selection until
//we are actually beyond the current word.
if(cp != _cpWordMost && cp != _cpWordMin)
{
if(_fInAutoWordSel)
{
// Auto selection still on so make sure we have the
// entire word we are on selected
ExtendToWordBreak(fAfterEOP, iDir);
}
else
{
// FUTURE: Word has a behavior where it extends the
// selection one word at a time unless you back up
// and then start extending the selection again, in
// which case it extends one char at a time. We
// follow this behavior. However, Word will resume
// extending a word at a time if you continue extending
// for several words. We just keep extending on char
// at a time. We might want to change this sometime.
_fAutoSelectAborted = TRUE;
}
}
}
if(_fAutoSelectAborted)
{
// If we are in the range of a word we previously selected
// we want to leave that selected. If we have moved back
// a word we want to pop back an entire word. Otherwise,
// leave the cp were it is.
if(_cch < 0)
{
if(cp > _cpWordMin && cp < _cpWordPrev)
{
// In the range leave the range at the beginning of the word
ExtendToWordBreak(fAfterEOP, WB_MOVEWORDLEFT);
}
else if(cp >= _cpWordPrev)
{
AutoSelGoBackWord(&_cpWordMin,
WB_MOVEWORDRIGHT, WB_MOVEWORDLEFT);
}
}
else if(cp < _cpWordMost && cp >= _cpWordPrev)
{
// In the range leave the range at the beginning of the word
ExtendToWordBreak(fAfterEOP, WB_MOVEWORDRIGHT);
}
else if(cp < _cpWordPrev)
{
AutoSelGoBackWord(&_cpWordMost,
WB_MOVEWORDLEFT, WB_MOVEWORDRIGHT);
}
}
}
// An OLE object cannot have an anchor point <b> inside </b> it,
// but sometimes we'd like it to behave like a word. So, if
// the direction changed, the object has to stay selected --
// this is the "right thing" (kind of word selection mode)
// If we had something selected and the direction changed
if(cchPrev && (_cch ^ cchPrev) < 0)
{
FlipRange();
// See if an object was selected on the other end
BOOL fObjectWasSelected = (_cch > 0 ? _rpTX.GetChar() : GetPrevChar())
== WCH_EMBEDDING;
// If it was, we want it to stay selected
if(fObjectWasSelected)
Move(_cch > 0 ? 1 : -1, TRUE);
FlipRange();
}
Update(TRUE);
}
/*
* CTxtSelection::ExtendToWordBreak (fAfterEOP, iAction)
*
* @mfunc
* Moves active end of selection to the word break in the direction
* given by iDir unless fAfterEOP = TRUE. When this is TRUE, the
* cursor just follows an EOP marker and selection should be suppressed.
* Otherwise moving the cursor to the left of the left margin would
* select the EOP on the line above, and moving the cursor to the
* right of the right margin would select the first word in the line
* below.
*/
void CTxtSelection::ExtendToWordBreak (
BOOL fAfterEOP, //@parm Cursor is after an EOP
INT iAction) //@parm Word break action (WB_MOVEWORDRIGHT/LEFT)
{
if(!fAfterEOP)
FindWordBreak(iAction, TRUE);
}
/*
* CTxtSelection::CancelModes(fAutoWordSel)
*
* @mfunc
* Cancel either all modes or Auto Select Word mode only
*/
void CTxtSelection::CancelModes (
BOOL fAutoWordSel) //@parm TRUE cancels Auto Select Word mode only
{ // FALSE cancels word, line and para sel mode
TRACEBEGIN(TRCSUBSYSSEL, TRCSCOPEINTERN, "CTxtSelection::CancelModes");
_TEST_INVARIANT_
if(fAutoWordSel)
{
if(_fInAutoWordSel)
{
_fInAutoWordSel = FALSE;
_fAutoSelectAborted = FALSE;
}
}
else
_SelMode = smNone;
}
/////////////////////////////////// Keyboard movements ////////////////////////////////////
/*
* CTxtSelection::Left(fCtrl, fExtend)
*
* @mfunc
* do what cursor-keypad left-arrow key is supposed to do
*
* @rdesc
* TRUE iff movement occurred
*
* @comm
* Left/Right-arrow IPs can go to within one character (treating CRLF
* as a character) of EOL. They can never be at the actual EOL, so
* _fCaretNotAtBOL is always FALSE for these cases. This includes
* the case with a right-arrow collapsing a selection that goes to
* the EOL, i.e, the caret ends up at the next BOL. Furthermore,
* these cases don't care whether the initial caret position is at
* the EOL or the BOL of the next line. All other cursor keypad
* commands may care.
*
* @devnote
* fExtend is TRUE iff Shift key is pressed or being simulated
*/
BOOL CTxtSelection::Left (
BOOL fCtrl, //@parm TRUE iff Ctrl key is pressed (or being simulated)
BOOL fExtend) //@parm Extend range iff TRUE
{
TRACEBEGIN(TRCSUBSYSSEL, TRCSCOPEINTERN, "CTxtSelection::Left");
_TEST_INVARIANT_
CancelModes();
StopGroupTyping();
if(!fExtend && _cch) // Collapse selection to
{ // nearest whole Unit before
LONG cp; // cpMin
if(fCtrl)
Expander(tomWord, FALSE, NULL, &cp, NULL);
Collapser(tomStart); // Collapse to cpMin
}
else // Not collapsing selection
{
if (!GetCp() || // Already at beginning of
!BypassHiddenText(tomBackward, fExtend))// story
{
Beep();
return FALSE;
}
if(IsInOutlineView() && (_fSelHasEOP || // If outline view with EOP
fExtend && _rpTX.IsAfterEOP())) // now or will have after
{ // this command,
return Up(FALSE, fExtend); // treat as up arrow
}
if(fCtrl) // WordLeft
FindWordBreak(WB_MOVEWORDLEFT, fExtend);
else // CharLeft
BackupCRLF(CSC_SNAPTOCLUSTER, fExtend);
}
_fCaretNotAtBOL = FALSE; // Caret always OK at BOL
Update(TRUE);
return TRUE;
}
/*
* CTxtSelection::Right(fCtrl, fExtend)
*
* @mfunc
* do what cursor-keypad right-arrow key is supposed to do
*
* @rdesc
* TRUE iff movement occurred
*
* @comm
* Right-arrow selection can go to the EOL, but the cp of the other
* end identifies whether the selection ends at the EOL or starts at
* the beginning of the next line. Hence here and in general for
* selections, _fCaretNotAtBOL is not needed to resolve EOL/BOL
* ambiguities. It should be set to FALSE to get the correct
* collapse character. See also comments for Left() above.
*
* @devnote
* fExtend is TRUE iff Shift key is pressed or being simulated
*/
BOOL CTxtSelection::Right (
BOOL fCtrl, //@parm TRUE iff Ctrl key is pressed (or being simulated)
BOOL fExtend) //@parm Extend range iff TRUE
{
TRACEBEGIN(TRCSUBSYSSEL, TRCSCOPEINTERN, "CTxtSelection::Right");
_TEST_INVARIANT_
CancelModes();
StopGroupTyping();
if(!fExtend && _cch) // Collapse selection to
{ // nearest whole Unit after
LONG cp; // cpMost
if(fCtrl)
Expander(tomWord, FALSE, NULL, NULL, &cp);
Collapser(tomEnd);
}
else // Not collapsing selection
{
LONG cchText = fExtend ? GetTextLength() : GetAdjustedTextLength();
if (GetCp() >= cchText || // Already at end of story
!BypassHiddenText(tomForward, fExtend))
{
Beep(); // Tell the user
return FALSE;
}
if(IsInOutlineView() && _fSelHasEOP) // If outline view with EOP
return Down(FALSE, fExtend); // Treat as down arrow
if(fCtrl) // WordRight
FindWordBreak(WB_MOVEWORDRIGHT, fExtend);
else // CharRight
AdvanceCRLF(CSC_SNAPTOCLUSTER, fExtend);
}
_fCaretNotAtBOL = fExtend; // If extending to EOL, need
Update(TRUE); // TRUE to get _upCaretReally
return TRUE; // at EOL
}
/*
* CTxtSelection::Up(fCtrl, fExtend)
*
* @mfunc
* do what cursor-keypad up-arrow key is supposed to do
*
* @rdesc
* TRUE iff movement occurred
*
* @comm
* Up arrow doesn't go to EOL regardless of _upCaretPosition (stays
* to left of EOL break character), so _fCaretNotAtBOL is always FALSE
* for Up arrow. Ctrl-Up/Down arrows always end up at BOPs or the EOD.
*
* @devnote
* fExtend is TRUE iff Shift key is pressed or being simulated
*/
BOOL CTxtSelection::Up (
BOOL fCtrl, //@parm TRUE iff Ctrl key is pressed (or being simulated)
BOOL fExtend) //@parm Extend range iff TRUE
{
TRACEBEGIN(TRCSUBSYSSEL, TRCSCOPEINTERN, "CTxtSelection::Up");
_TEST_INVARIANT_
LONG cch;
LONG cchSave = _cch; // Save starting position for
LONG cpSave = GetCp(); // change check
BOOL fCollapse = _cch && !fExtend; // Collapse nondegenerate sel
BOOL fPTNotAtEnd;
POINTUV pt;
CLinePtr rp(_pdp);
LONG upCaretReally = _upCaretReally; // Save desired caret x pos
CancelModes();
StopGroupTyping();
if(fCollapse) // Collapse selection at cpMin
{
Collapser(tomTrue);
_fCaretNotAtBOL = FALSE; // Selections can't begin at
} // EOL
if(_pdp->PointFromTp(*this, NULL, _fCaretNotAtBOL, pt, &rp, 0, NULL) < 0)
return FALSE;
if(fCtrl) // Move to beginning of para
{
if (!fCollapse && // If no selection collapsed
rp > 0 && !rp.GetIch()) // and are at BOL,
{ // backup to prev BOL to make
rp.PrevRun(); // sure we move to prev. para
Move(-rp->_cch, fExtend);
}
Move(rp.FindParagraph(FALSE), fExtend); // Go to beginning of para
_fCaretNotAtBOL = FALSE; // Caret always OK at BOL
}
else // Move up a line
{ // If on first line, can't
Assert(rp >= 0); // go up
if(InTable())
{
WCHAR ch;
LONG cpRowStart;
CTxtRange rg(*this); // Need rg for rg.FindRow()
rg.Move(-rp.GetIch(), fExtend); // Move to beginning of line
rp.SetIch(0);
LONG cpBOL = rg.GetCp(); // Save current cp for check
while(1) // While previous char is
{ // CELL or start of row,
cch = 0; // move to start of row
do
{ // Look at previous char &
cch = rg.BackupCRLF(CSC_NORMAL, fExtend);// save cch moved
ch = rg._rpTX.GetChar();
} // Backup over span of table
while(rg.GetCp() && ch == STARTFIELD);// row starts
if(ch != CELL)
{
if(cch < 0 && ch != STARTFIELD)
rg.AdvanceCRLF(CSC_NORMAL, fExtend);// Prev char not CELL
break; // or row start: move past it
}
rg.FindRow(&cpRowStart, NULL); // Backup to start of
rg.SetCp(cpRowStart, fExtend); // current table row
}
if(rg.GetCp() < cpBOL) // Moved back
{
CLinePtr rp0(_pdp); // Move rp to new position
rp0.SetCp(rg.GetCp(), FALSE, 1);
rp = rp0;
}
if(rp > 0) // Row above exists, so move
SetCp(rg.GetCp(), fExtend); // selection to start of row
}
fPTNotAtEnd = !CheckPlainTextFinalEOP();// Always TRUE for rich text
if(rp == 0 && fPTNotAtEnd) // Can't move up
UpdateCaret(TRUE); // Be sure caret in view
else
{
BOOL fSelHasEOPInOV = IsInOutlineView() && _fSelHasEOP;
if(fSelHasEOPInOV && _cch > 0)
{
rp.AdjustBackward();
cch = rp->_cch;
rp.Move(-cch); // Go to start of line
Assert(!rp.GetIch());
cch -= rp.FindParagraph(FALSE); // Ensure start of para in
} // case of word wrap
else
{
cch = 0;
if(fPTNotAtEnd)
{
cch = rp.GetIch();
rp--;
}
cch += rp->_cch;
}
Move(-cch, fExtend); // Move to previous BOL
if(fSelHasEOPInOV && !_fSelHasEOP) // If sel had EOP but doesn't
{ // after Move, must be IP
Assert(!_cch); // Suppress restore of
upCaretReally = -1; // _upCaretReally
}
else if(!SetUpPosition(upCaretReally,// Set this cp corresponding
rp, TRUE, fExtend)) // to upCaretReally here, but
{ // agree on Down()
Set(cpSave, cchSave); // Failed: restore selection
}
}
}
if(GetCp() == cpSave && _cch == cchSave)
{
// Continue to select to the beginning of the first line
// This is what 1.0 is doing
if(fExtend)
return Home(fCtrl, TRUE);
_upCaretReally = upCaretReally;
Beep(); // Nothing changed, so beep
return FALSE;
}
Update(TRUE); // Update and then restore
if(!_cch && !fCtrl && upCaretReally >= 0) // _upCaretReally conditionally
_upCaretReally = upCaretReally; // Need to use _cch instead of
// cchSave in case of collapse
return TRUE;
}
/*
* CTxtSelection::Down(fCtrl, fExtend)
*
* @mfunc
* do what cursor-keypad down-arrow key is supposed to do
*
* @rdesc
* TRUE iff movement occurred
*
* @comm
* Down arrow can go to the EOL if the _upCaretPosition (set by
* horizontal motions) is past the end of the line, so
* _fCaretNotAtBOL needs to be TRUE for this case.
*
* @devnote
* fExtend is TRUE iff Shift key is pressed or being simulated
*/
BOOL CTxtSelection::Down (
BOOL fCtrl, //@parm TRUE iff Ctrl key is pressed (or being simulated)
BOOL fExtend) //@parm Extend range iff TRUE
{
TRACEBEGIN(TRCSUBSYSSEL, TRCSCOPEINTERN, "CTxtSelection::Down");
_TEST_INVARIANT_
LONG cch;
LONG cchSave = _cch; // Save starting position for
LONG cpSave = GetCp(); // change check
BOOL fCollapse = _cch && !fExtend; // Collapse nondegenerate sel
POINTUV pt;
CLinePtr rp(_pdp);
LONG upCaretReally = _upCaretReally; // Save _upCaretReally
CancelModes();
StopGroupTyping();
if(fCollapse) // Collapse at cpMost
{
Collapser(tomEnd);
_fCaretNotAtBOL = TRUE; // Selections can't end at BOL
}
LONG ili = _pdp->PointFromTp(*this, NULL, _fCaretNotAtBOL, pt, &rp, 0, NULL);
if(ili < 0)
return FALSE;
if(fCtrl) // Move to next para
{
Move(rp.FindParagraph(TRUE), fExtend); // Go to end of para
if(IsInOutlineView() && !BypassHiddenText(tomForward, fExtend))
SetCp(cpSave, fExtend);
else
_fCaretNotAtBOL = FALSE; // Next para is never at EOL
}
else if(_pdp->WaitForRecalcIli(ili + 1)) // Go to next line
{
BOOL fSelHasEOPInOV = IsInOutlineView() && _fSelHasEOP;
if(fSelHasEOPInOV && _cch < 0)
cch = rp.FindParagraph(TRUE);
else
{
cch = rp.GetCchLeft(); // Move selection to end
rp.NextRun(); // of current line
}
Move(cch, fExtend);
while(GetPrevChar() == CELL) // Went past cell end:
{ // goto end of row
LONG cpRowEnd;
do
{
FindRow(NULL, &cpRowEnd);
SetCp(cpRowEnd, fExtend);
}
while(_rpTX.GetChar() == CELL); // Table at end of cell
CLinePtr rp0(_pdp);
rp0.SetCp(cpRowEnd, _fCaretNotAtBOL, 1);
rp = rp0;
}
if(fSelHasEOPInOV && !_fSelHasEOP) // If sel had EOP but doesn't
{ // after Move, must be IP
Assert(!_cch); // Suppress restore of
upCaretReally = -1; // _upCaretReally
}
else if(!SetUpPosition(upCaretReally, // Set *this to cp <--> x
rp, FALSE, fExtend))
{ // Failed: restore selection
Set(cpSave, cchSave);
}
}
else if(!fExtend) // No more lines to pass
// && _pdp->GetVScroll() + _pdp->GetDvpView() < _pdp->GetHeight())
{
if (!IsRich() && _pdp->IsMultiLine() && // Plain-text, multiline
!_fCaretNotAtBOL) // control with caret OK
{ // at BOL
cch = Move(rp.GetCchLeft(), fExtend);// Move selection to end
if(!_rpTX.IsAfterEOP()) // If control doesn't end
Move(-cch, fExtend); // with EOP, go back
}
UpdateCaret(TRUE); // Be sure caret in view
}
if(GetCp() == cpSave && _cch == cchSave)
{
// Continue to select to the end of the lastline
// This is what 1.0 is doing.
if(fExtend)
return End(fCtrl, TRUE);
_upCaretReally = upCaretReally;
Beep(); // Nothing changed, so beep
return FALSE;
}
Update(TRUE); // Update and then
if(!_cch && !fCtrl && upCaretReally >= 0) // restore _upCaretReally
_upCaretReally = upCaretReally; // Need to use _cch instead of
return TRUE; // cchSave in case of collapse
}
/*
* CTxtSelection::SetUpPosition(upCaret, rp, fBottomLine, fExtend)
*
* @mfunc
* Put this text ptr at cp nearest to xCaret. If xCaret is in right
* margin, we put caret either at EOL (for lines with no para mark),
* or just before para mark
*
* @rdesc
* TRUE iff could create measurer
*/
BOOL CTxtSelection::SetUpPosition(
LONG upCaret, //@parm Desired horizontal coordinate
CLinePtr& rp, //@parm Line ptr identifying line to check
BOOL fBottomLine, //@parm TRUE if use bottom line of nested display
BOOL fExtend) //@parm Extend range iff TRUE
{
TRACEBEGIN(TRCSUBSYSSEL, TRCSCOPEINTERN, "CTxtSelection::SetUpPosition");
_TEST_INVARIANT_
LONG cch = 0;
if(IsInOutlineView())
{
BOOL fSelHasEOP = _fSelHasEOP;
rp.AdjustForward();
_fCaretNotAtBOL = FALSE; // Leave at start of line
while(rp->_fCollapsed)
{
if(_fMoveBack)
{
if(!rp.PrevRun()) // No more uncollapsed text
return FALSE; // before current cp
cch -= rp->_cch;
}
else
{
cch += rp->_cch;
if(!rp.NextRun()) // No more uncollapsed text
return FALSE; // after current cp
if(fExtend && _cch > 0)
_fCaretNotAtBOL = TRUE; // Leave at end of line
}
}
if(cch)
Move(cch, fExtend);
if(fSelHasEOP)
return TRUE;
}
POINTUV pt;
UINT talign = TA_BASELINE;
if(fBottomLine)
{
if(rp->IsNestedLayout())
talign = TA_TOP | TA_CELLTOP;
else
fBottomLine = FALSE;
}
if(_pdp->PointFromTp(*this, NULL, FALSE, pt, NULL, talign, NULL) < 0)
return FALSE;
if(fBottomLine)
pt.v += rp->GetHeight() - 3;
HITTEST hit;
RECTUV rcView;
_pdp->GetViewRect(rcView, NULL);
if(!upCaret && _rpTX.IsAtTRD(STARTFIELD))
{
// At table row start at position before row: move over to get into
// first cell. This solves some of the up/down-arrow errors for
// upCaret = 0, but the caret still won't move for some nested table
// scenarios (the needed upCaret measurement is more complicated than
// that given here).
LONG dupInch = MulDiv(_pdp->GetDxpInch(), _pdp->GetZoomNumerator(), _pdp->GetZoomDenominator());
LONG dup = MulDiv(GetPF()->_dxOffset, dupInch, LX_PER_INCH);
CTxtPtr tp(_rpTX);
while(tp.IsAtTRD(STARTFIELD))
{
upCaret += dup;
tp.AdvanceCRLF(FALSE);
}
}
pt.u = upCaret + rcView.left;
LONG cp = _pdp->CpFromPoint(pt, NULL, NULL, &rp, FALSE, &hit, NULL, NULL);
if(cp < 0)
return FALSE; // If failed, restore sel
SetCp(cp, fExtend);
_fCaretNotAtBOL = rp.GetIch() != 0;
return TRUE;
}
/*
* CTxtSelection::GetUpCaretReally()
*
* @mfunc
* Get _upCaretReally - horizontal scrolling + left margin
*
* @rdesc
* x caret really
*/
LONG CTxtSelection::GetUpCaretReally()
{
TRACEBEGIN(TRCSUBSYSSEL, TRCSCOPEINTERN, "CTxtSelection::GetUpCaretReally");
_TEST_INVARIANT_
RECTUV rcView;
_pdp->GetViewRect(rcView);
return _upCaretReally - _pdp->GetUpScroll() + rcView.left;
}
/*
* CTxtSelection::Home(fCtrl, fExtend)
*
* @mfunc
* do what cursor-keypad Home key is supposed to do
*
* @rdesc
* TRUE iff movement occurred
*
* @devnote
* fExtend is TRUE iff Shift key is pressed or being simulated
*/
BOOL CTxtSelection::Home (
BOOL fCtrl, //@parm TRUE iff Ctrl key is pressed (or being simulated)
BOOL fExtend) //@parm Extend range iff TRUE
{
TRACEBEGIN(TRCSUBSYSSEL, TRCSCOPEINTERN, "CTxtSelection::Home");
_TEST_INVARIANT_
const LONG cchSave = _cch;
const LONG cpSave = GetCp();
CancelModes();
StopGroupTyping();
if(fCtrl) // Move to start of document
SetCp(0, fExtend);
else
{
CLinePtr rp(_pdp);
if(_cch && !fExtend) // Collapse at cpMin
{
Collapser(tomStart);
_fCaretNotAtBOL = FALSE; // Selections can't start at
} // EOL
rp.SetCp(GetCp(), _fCaretNotAtBOL, 2); // Define line ptr for
Move(-rp.GetIch(), fExtend); // current state. Now BOL
}
_fCaretNotAtBOL = FALSE; // Caret always goes to BOL
_fHomeOrEnd = TRUE;
if(!MatchKeyboardToPara() && GetCp() == cpSave && _cch == cchSave)
{
Beep(); // No change, so beep
_fHomeOrEnd = FALSE;
return FALSE;
}
Update(TRUE);
_fHomeOrEnd = FALSE;
_fUpdatedFromCp0 = FALSE; // UI commands don't set this
return TRUE;
}
/*
* CTxtSelection::End(fCtrl, fExtend)
*
* @mfunc
* do what cursor-keypad End key is supposed to do
*
* @rdesc
* TRUE iff movement occurred
*
* @comm
* On lines without paragraph marks (EOP), End can go all the way
* to the EOL. Since this character position (cp) is the same as
* that for the start of the next line, we need _fCaretNotAtBOL to
* distinguish between the two possible caret positions.
*
* @devnote
* fExtend is TRUE iff Shift key is pressed or being simulated
*/
BOOL CTxtSelection::End (
BOOL fCtrl, //@parm TRUE iff Ctrl key is pressed (or being simulated)
BOOL fExtend) //@parm Extend range iff TRUE
{
TRACEBEGIN(TRCSUBSYSSEL, TRCSCOPEINTERN, "CTxtSelection::End");
_TEST_INVARIANT_
LONG cch;
const LONG cchSave = _cch;
const LONG cpSave = GetCp();
CLinePtr rp(_pdp);
CancelModes();
StopGroupTyping();
if(fCtrl) // Move to end of document
{
SetCp(GetTextLength(), fExtend);
_fCaretNotAtBOL = FALSE;
goto Exit;
}
else if(!fExtend && _cch) // Collapse at cpMost
{
Collapser(tomEnd);
_fCaretNotAtBOL = TRUE; // Selections can't end at BOL
}
rp.SetCp(GetCp(), _fCaretNotAtBOL, 2); // Initialize line ptr on
// on innermost line
cch = rp.GetCchLeft(); // Default target pos in line
if(!Move(cch, fExtend)) // Move active end to EOL
goto Exit; // Failed (at end of story)
if(!fExtend && rp->_cchEOP && _rpTX.IsAfterEOP())// Not extending & have
cch += BackupCRLF(CSC_NORMAL, FALSE); // EOP so backup before EOP
_fCaretNotAtBOL = cch != 0; // Decide ambiguous caret pos
// by whether at BOL
Exit:
if(!MatchKeyboardToPara() && GetCp() == cpSave && _cch == cchSave)
{
Beep(); // No change, so Beep
return FALSE;
}
_fHomeOrEnd = TRUE;
Update(TRUE);
_fHomeOrEnd = FALSE;
return TRUE;
}
/*
* CTxtSelection::PageUp(fCtrl, fExtend)
*
* @mfunc
* do what cursor-keypad PgUp key is supposed to do
*
* @rdesc
* TRUE iff movement occurred
*
* @devnote
* fExtend is TRUE iff Shift key is pressed or being simulated
*/
BOOL CTxtSelection::PageUp (
BOOL fCtrl, //@parm TRUE iff Ctrl key is pressed (or being simulated)
BOOL fExtend) //@parm Extend range iff TRUE
{
TRACEBEGIN(TRCSUBSYSSEL, TRCSCOPEINTERN, "CTxtSelection::PageUp");
_TEST_INVARIANT_
const LONG cchSave = _cch;
const LONG cpSave = GetCp();
LONG upCaretReally = _upCaretReally;
CancelModes();
StopGroupTyping();
if(_cch && !fExtend) // Collapse selection
{
Collapser(tomStart);
_fCaretNotAtBOL = FALSE;
}
if(fCtrl) // Ctrl-PgUp: move to top
{ // of visible view for
SetCp(_pdp->IsMultiLine() // multiline but top of
? _pdp->GetFirstVisibleCp() : 0, fExtend); // text for SL
_fCaretNotAtBOL = FALSE;
}
else if(_pdp->GetFirstVisibleCp() == 0) // PgUp in top Pg: move to
{ // start of document
SetCp(0, fExtend);
_fCaretNotAtBOL = FALSE;
}
else // PgUp with scrolling to go
{ // Scroll up one windowful
ScrollWindowful(SB_PAGEUP, fExtend); // leaving caret at same
} // position in window
if(GetCp() == cpSave && _cch == cchSave) // Beep if no change
{
Beep();
return FALSE;
}
Update(TRUE);
if(GetCp()) // Maintain x offset on page
_upCaretReally = upCaretReally; // up/down
_fUpdatedFromCp0 = FALSE; // UI commands don't set this
return TRUE;
}
/*
* CTxtSelection::PageDown(fCtrl, fExtend)
*
* @mfunc
* do what cursor-keypad PgDn key is supposed to do
*
* @rdesc
* TRUE iff movement occurred
*
* @devnote
* fExtend is TRUE iff Shift key is pressed or being simulated
*/
BOOL CTxtSelection::PageDown (
BOOL fCtrl, //@parm TRUE iff Ctrl key is pressed (or being simulated)
BOOL fExtend) //@parm Extend range iff TRUE
{
TRACEBEGIN(TRCSUBSYSSEL, TRCSCOPEINTERN, "CTxtSelection::PageDown");
_TEST_INVARIANT_
const LONG cchSave = _cch;
LONG cpMostVisible;
const LONG cpSave = GetCp();
POINTUV pt;
CLinePtr rp(_pdp);
LONG upCaretReally = _upCaretReally;
CancelModes();
StopGroupTyping();
if(_cch && !fExtend) // Collapse selection
{
Collapser(tomStart);
_fCaretNotAtBOL = TRUE;
}
_pdp->GetCliVisible(&cpMostVisible, fCtrl);
if(fCtrl) // Move to end of last
{ // entirely visible line
RECTUV rcView;
SetCp(cpMostVisible, fExtend);
if(_pdp->PointFromTp(*this, NULL, TRUE, pt, &rp, TA_TOP) < 0)
return FALSE;
_fCaretNotAtBOL = TRUE;
_pdp->GetViewRect(rcView);
if(rp > 0 && pt.v + rp->GetHeight() > rcView.bottom)
{
Move(-rp->_cch, fExtend);
rp--;
}
if(!fExtend && !rp.GetCchLeft() && rp->_cchEOP)
{
BackupCRLF(CSC_NORMAL, FALSE); // After backing up over EOP,
_fCaretNotAtBOL = FALSE; // caret can't be at EOL
}
}
else if(cpMostVisible == GetTextLength())
{ // Move to end of text
SetCp(GetTextLength(), fExtend);
_fCaretNotAtBOL = !_rpTX.IsAfterEOP();
}
else if(!ScrollWindowful(SB_PAGEDOWN, fExtend))// Scroll down 1 windowful
return FALSE;
if(GetCp() == cpSave && _cch == cchSave) // Beep if no change
{
Beep();
return FALSE;
}
Update(TRUE);
_upCaretReally = upCaretReally;
return TRUE;
}
/*
* CTxtSelection::ScrollWindowful(wparam, fExtend)
*
* @mfunc
* Sroll up or down a windowful
*
* @rdesc
* TRUE iff movement occurred
*/
BOOL CTxtSelection::ScrollWindowful (
WPARAM wparam, //@parm SB_PAGEDOWN or SB_PAGEUP
BOOL fExtend) //@parm Extend range iff TRUE
{
TRACEBEGIN(TRCSUBSYSSEL, TRCSCOPEINTERN, "CTxtSelection::ScrollWindowful");
_TEST_INVARIANT_
// Scroll windowful
POINTUV pt; // leaving caret at same
CLinePtr rp(_pdp); // point on screen
LONG cpFirstVisible = _pdp->GetFirstVisibleCp();
LONG cpLastVisible;
LONG cpMin;
LONG cpMost;
GetRange(cpMin, cpMost);
// Get last character in the view
_pdp->GetCliVisible(&cpLastVisible, TRUE);
// Is active end in visible area of control?
if((cpMin < cpFirstVisible && _cch <= 0) || (cpMost > cpLastVisible && _cch >= 0))
{
// Not in view - we need to calculate a new range for selection
SetCp(cpFirstVisible, fExtend);
// Real caret postion is now at beginning of line
_upCaretReally = 0;
}
if(_pdp->PointFromTp(*this, NULL, _fCaretNotAtBOL, pt, &rp, TA_TOP) < 0)
return FALSE;
// The point is visible so use that
pt.u = _upCaretReally;
pt.v += rp->GetHeight() / 2;
_pdp->VScroll(wparam, 0);
if(fExtend)
{
// Disable auto word select -- if we have to use ExtendSelection()
// for non-mouse operations, let's try to get rid of its side-effects
BOOL fInAutoWordSel = _fInAutoWordSel;
_fInAutoWordSel = FALSE;
ExtendSelection(pt);
_fInAutoWordSel = fInAutoWordSel;
}
else
SetCaret(pt, FALSE);
return TRUE;
}
//////////////////////////// Keyboard support /////////////////////////////////
/*
* CTxtSelection::CheckChangeKeyboardLayout()
*
* @mfunc
* Change keyboard for new font, or font at new character position.
*
* @comm
* Using only the currently loaded KBs, locate one that will support
* the insertion points font. This is called anytime a character format
* change occurs, or the insert font (caret position) changes.
*
* @devnote
* The current KB is preferred. If a previous association
* was made, see if the KB is still loaded in the system and if so use
* it. Otherwise, locate a suitable KB, preferring KB's that have
* the same charset ID as their default, preferred charset. If no match
* can be made then nothing changes.
*/
void CTxtSelection::CheckChangeKeyboardLayout ()
{
TRACEBEGIN(TRCSUBSYSSEL, TRCSCOPEINTERN, "CTxtSelection::CheckChangeKeyboardLayout");
CTxtEdit * const ped = GetPed(); // Document context
if (ped && ped->_fFocus && !ped->fUseUIFont() &&// If ped, focus, not UIFont,
ped->IsAutoKeyboard() && // autokeyboard,
!ped->_fIMEInProgress && // not in IME composition,
ped->GetAdjustedTextLength() && // not empty control, and
_rpTX.GetPrevChar() != WCH_EMBEDDING) // not an object, then
{ // check kbd change
LONG iFormat = GetiFormat();
const CCharFormat *pCF = ped->GetCharFormat(iFormat);
BYTE iCharRep = pCF->_iCharRep;
if (!IsFECharRep(iCharRep) &&
(iCharRep != ANSI_INDEX || !IsFELCID((WORD)GetKeyboardLayout(0))) &&
!fc().GetInfoFlags(pCF->_iFont).fNonBiDiAscii)
{
// Don't do auto-kbd inside FE or single-codepage ASCII font.
W32->CheckChangeKeyboardLayout(iCharRep);
}
}
}
/*
* CTxtSelection::CheckChangeFont (hkl, cpg, iSelFormat, qwCharFlags)
*
* @mfunc
* Change font for new keyboard layout.
*
* @comm
* If no previous preferred font has been associated with this KB, then
* locate a font in the document suitable for this KB.
*
* @rdesc
* TRUE iff suitable font is found
*
* @devnote
* This routine is called via WM_INPUTLANGCHANGEREQUEST message
* (a keyboard layout switch). This routine can also be called
* from WM_INPUTLANGCHANGE, but we are called more, and so this
* is less efficient.
*
* Exact match is done via charset ID bitmask. If a match was previously
* made, use it. A user can force the insertion font to be associated
* to a keyboard if the control key is held through the KB changing
* process. The association is broken when another KB associates to
* the font. If no match can be made then nothing changes.
*/
bool CTxtSelection::CheckChangeFont (
const HKL hkl, //@parm Keyboard Layout to go
UINT iCharRep, //@parm Character repertoire to use
LONG iSelFormat, //@parm Format to use for selection case
QWORD qwCharFlags) //@parm 0 if called from WM_INPUTLANGCHANGE/WM_INPUTLANGCHANGEREQUEST
{
TRACEBEGIN(TRCSUBSYSSEL, TRCSCOPEINTERN, "CTxtSelection::CheckChangeFont");
CTxtEdit * const ped = GetPed();
if (!ped->IsAutoFont() || // EXIT if auto font is turned off
_cch && !qwCharFlags) // or if kbd change with nondegenerate
return true; // selection (WM_INPUTLANGCHANGEREQUEST)
// Set new format using current format and new KB info.
LONG iCurrentFormat = _cch ? iSelFormat : _iFormat;
const CCharFormat *pCF = ped->GetCharFormat(iCurrentFormat);
CCharFormat CF = *pCF;
WORD wLangID = LOWORD(hkl);
CF._lcid = wLangID;
CF._iCharRep = iCharRep;
if (pCF->_lcid == wLangID && iCharRep == pCF->_iCharRep)
{
if (ped->_fFocus && IsCaretShown())
{
CreateCaret();
ped->TxShowCaret(TRUE);
}
return true;
}
CCFRunPtr rp(*this);
int iMatchFont = MATCH_FONT_SIG;
// If current is a primary US or UK kbd. We allow matching ASCII fonts
if ((!qwCharFlags || qwCharFlags & FASCII) &&
PRIMARYLANGID(wLangID) == LANG_ENGLISH &&
IN_RANGE (SUBLANG_ENGLISH_US, SUBLANGID(wLangID), SUBLANG_ENGLISH_UK) &&
wLangID == HIWORD((DWORD_PTR)hkl))
{
iMatchFont |= MATCH_ASCII;
}
if (rp.GetPreferredFontInfo(
iCharRep,
CF._iCharRep,
CF._iFont,
CF._yHeight,
CF._bPitchAndFamily,
iCurrentFormat,
iMatchFont))
{
if(IsFECharRep(iCharRep) || iCharRep == THAI_INDEX || IsBiDiCharRep(iCharRep))
ped->OrCharFlags(FontSigFromCharRep(iCharRep));
if (!_cch)
{
SetCharFormat(&CF, SCF_NOKBUPDATE, NULL, CFM_FACE | CFM_CHARSET | CFM_LCID | CFM_SIZE, CFM2_NOCHARSETCHECK);
if(ped->IsComplexScript())
UpdateCaret(FALSE);
}
else
{
// Create a format and use it for the selection
LONG iCF;
ICharFormatCache *pf = GetCharFormatCache();
pf->Cache(&CF, &iCF);
#ifndef NOLINESERVICES
if (g_pols)
g_pols->DestroyLine(NULL);
#endif
Set_iCF(iCF);
pf->Release(iCF); // pf->Cache AddRef it
_fUseiFormat = TRUE;
}
return true;
}
return false;
}
//////////////////////////// PutChar, Delete, Replace //////////////////////////////////
/*
* CTxtSelection::PutChar(ch, dwFlags, publdr)
*
* @mfunc
* Insert or overtype a character
*
* @rdesc
* TRUE if successful
*/
BOOL CTxtSelection::PutChar (
DWORD ch, //@parm Char to put
DWORD dwFlags, //@parm Overtype mode and whether keyboard input
IUndoBuilder *publdr, //@parm If non-NULL, where to put anti-events
LCID lcid) //@parm If nonzero, lcid to use for char
{
TRACEBEGIN(TRCSUBSYSSEL, TRCSCOPEINTERN, "CTxtSelection::PutChar");
_TEST_INVARIANT_
BOOL fOver = dwFlags & 1;
CTxtEdit *ped = GetPed();
CFreezeDisplay fd(GetPed()->_pdp);
if(ch == TAB && GetPF()->InTable() && !(dwFlags & KBD_CTRL))
{
LONG cchSave = _cch;
LONG cpMin, cpMost;
LONG cpSave = GetCp();
LONG Delta;
BOOL fMoveBack = (GetKeyboardFlags() & SHIFT) != 0;
do
{
if(!fMoveBack) // TAB w/o Shift key: select
{ // contents of next cell
if(!_rpTX.IsAtTRD(ENDFIELD))
{
if(GetPrevChar() == CELL) // Handle empty cell case
Move(1, FALSE);
EndOf(tomCell, FALSE, &Delta);
}
if(_rpTX.IsAtTRD(ENDFIELD))
{
AdvanceCRLF(CSC_NORMAL, FALSE); // Bypass end-of-row delimiter
if(!_rpTX.IsAtTRD(STARTFIELD)) // Tabbed past end of table:
{
Move(-2, FALSE); // Backup before table-row end
return InsertTableRow(GetPF(), publdr, TRUE);
}
AdvanceCRLF(CSC_NORMAL, FALSE); // Bypass start-of-row delimiter
}
}
else // Shift+TAB: select contents
{ // of previous cell
if(_cch || !_rpTX.IsAtTRD(ENDFIELD))
{
FindCell(&cpMin, NULL); // StartOf() w/o Update()'s
SetCp(cpMin, FALSE);
}
if(GetPrevChar() == CELL)
Move(-1, FALSE); // Backspace over previous CELL
else
{
if(!_rpTX.IsAfterTRD(ENDFIELD))
{
Assert(_rpTX.IsAfterTRD(STARTFIELD));
BackupCRLF(CSC_NORMAL, FALSE);
if(!_rpTX.IsAfterTRD(ENDFIELD))
{
Set(cpSave, cchSave); // Restore selection
Beep(); // Tell user illegal key
return FALSE;
}
}
Move(-3, FALSE); // Backspace over row-end
} // delimiter and CELL
}
if(!InTable())
break;
FindCell(&cpMin, &cpMost);
Assert(cpMost > cpMin);
cpMost--; // Don't select the CELL mark
Set(cpMost, cpMost - cpMin);
}
while(cpMost == cpMin + 1 && _rpTX.GetPrevChar() == NOTACHAR);
Update(TRUE);
return TRUE;
}
if(_nSelExpandLevel)
{
Collapser(tomStart);
while(_rpTX.IsAtTRD(STARTFIELD))
AdvanceCRLF(CSC_NORMAL, FALSE);
LONG cpMin, cpMost;
FindCell(&cpMin, &cpMost);
Set(cpMin, cpMin - cpMost + 1);
}
// EOPs might be entered by ITextSelection::TypeText()
if(IsEOP(ch))
return _pdp->IsMultiLine() // EOP isn't allowed in
? InsertEOP(publdr, ch) : FALSE;// single line controls
if(publdr)
{
publdr->SetNameID(UID_TYPING);
publdr->StartGroupTyping();
}
// FUTURE: a Unicode lead surrogate needs to have a trail surrogate, i.e.,
// two 16-bit chars. A more thorough check would worry about this.
if ((DWORD)GetTextLength() >= ped->TxGetMaxLength() &&
((_cch == -1 || !_cch && fOver) && _rpTX.IsAtEOP() ||
_cch == 1 && _rpTX.IsAfterEOP()))
{
// Can't overtype a CR, so need to insert new char but no room
ped->GetCallMgr()->SetMaxText();
return FALSE;
}
if((!fOver || !_cch && GetCp() == GetTextLength()) &&
!CheckTextLength(1)) // Return if we can't
{ // add even 1 more char
return FALSE;
}
// The following if statement implements Word95's "Smart Quote" feature.
// To build this in, we still need an API to turn it on and off. This
// could be EM_SETSMARTQUOTES with wparam turning the feature on or off.
// murrays. NB: this needs localization for French, German, and many
// other languages (unless system can provide open/close chars given
// an LCID).
if((ch == '\'' || ch == '"') && // Smart quotes
SmartQuotesEnabled() &&
PRIMARYLANGID(GetKeyboardLayout(0)) == LANG_ENGLISH)
{
LONG cp = GetCpMin(); // Open vs close depends
CTxtPtr tp(ped, cp - 1); // on char preceding
// selection cpMin
ch = (ch == '"') ? RDBLQUOTE : RQUOTE; // Default close quote
// or apostrophe. If at
WCHAR chp = tp.GetChar();
if(!cp || IsWhiteSpace(chp) || chp == '(') // BOStory or preceded
ch--; // by whitespace, use
} // open quote/apos
WCHAR str[2]; // Might need to insert
LONG cch = 1; // Unicode surrogate pair
str[0] = (WCHAR)ch; // Default single code
if(ch > 65535) // Higher-plane char or
{ // invalid
if(ch > 0x10FFFF)
return FALSE; // Invalid (above plane 17)
ch -= 0x10000; // Higher-plane char:
str[0] = 0xD800 + (ch >> 10); // convert to surrogate pair
str[1] = 0xDC00 + (ch & 0x3FF);
cch = 2;
}
// Some languages, e.g., Thai and Vietnamese, require verifying the input
// sequence order before submitting it to the backing store.
BOOL fBaseChar = TRUE; // Assume ch is a base consonant
if(!IsInputSequenceValid(str, cch, fOver, &fBaseChar))
{
SetDualFontMode(FALSE); // Ignore bad sequence
return FALSE;
}
DWORD iCharRepDefault = ped->GetCharFormat(-1)->_iCharRep;
QWORD qw = GetCharFlags(str, cch, iCharRepDefault);
ped->OrCharFlags(qw, publdr);
// BEFORE we do "dual-font", we sync the keyboard and current font's
// (_iFormat) charset if it hasn't been done.
const CCharFormat *pCFCurrent = NULL;
CCharFormat CF = *ped->GetCharFormat(GetiFormat());
BYTE iCharRep = CF._iCharRep;
BOOL fRestoreCF = FALSE;
if(ped->IsAutoFont())
{
UINT uKbdcpg = 0;
BOOL fFEKbd = FALSE;
if(!(ped->_fIMEInProgress) && !(ped->Get10Mode() && iCharRep == MAC_INDEX))
uKbdcpg = CheckSynchCharSet(qw);
if (fUseUIFont() && ch <= 0x0FF)
{
// For UIFont, we need to format ANSI characters
// so we will not have different formats between typing and
// WM_SETTEXT.
if (!ped->_fIMEInProgress && qw == FHILATIN1)
{
// Use Ansi font if based font or current font is FE.
if(IsFECharRep(iCharRepDefault) || IsFECharRep(iCharRep))
SetupDualFont(); // Use Ansi font for HiAnsi
}
else if (qw & FASCII && (GetCharRepMask(TRUE) & FASCII) == FASCII)
{
CCharFormat CFDefault = *ped->GetCharFormat(-1);
if (IsRich() && IsBiDiCharRep(CFDefault._iCharRep) &&
!W32->IsBiDiCodePage(uKbdcpg))
{
CFDefault._iCharRep = ANSI_INDEX;
}
SetCharFormat(&CFDefault, SCF_NOKBUPDATE, publdr, CFM_CHARSET | CFM_FACE | CFM_SIZE,
CFM2_CHARFORMAT | CFM2_NOCHARSETCHECK | CFM2_HOLDITEMIZE);
_fUseiFormat = FALSE;
pCFCurrent = &CF;
fRestoreCF = ped->_fIMEInProgress;
}
}
else if(!fUseUIFont() && iCharRep != ANSI_INDEX &&
(ped->_fDualFont && iCharRep != SYMBOL_INDEX &&
(((fFEKbd = (ped->_fIMEInProgress || W32->IsFECodePage(uKbdcpg))) && ch < 127 && IsASCIIAlpha(ch)) ||
(!fFEKbd && IsFECharRep(ped->GetCharFormat(GetiFormat())->_iCharRep) && ch < 127))
|| ped->_fHbrCaps))
{
SetupDualFont();
pCFCurrent = &CF;
fRestoreCF = ped->_fIMEInProgress;
}
}
// = Indic/Thai overtyping convention =
//
// The deal is that we will overwrite the cluster if ch is a cluster-start char
// otherwise we just insert. This new convention was proposed by SA Office2000.
//
// Abc.Def.Ghi
// Typing X at D Abc.X.Ghi
// Typing y and z Abc.Xyz.Ghi
if(fOver && fBaseChar)
{ // If nothing selected and
if(!_cch && !_rpTX.IsAtEOP()) // not at EOP char, try
{ // to select char at IP
LONG iFormatSave = Get_iCF(); // Remember char's format
AdvanceCRLF(CSC_SNAPTOCLUSTER, TRUE);
ReplaceRange(0, NULL, publdr,
SELRR_REMEMBERENDIP); // Delete this character.
ReleaseFormats(_iFormat, -1);
_iFormat = iFormatSave; // Restore char's format.
}
}
else if(_SelMode == smWord && ch != TAB && _cch)// Replace word selection
{
// The code below wants the active end to be at the end of the
// word. Make sure this is so.
// FUTURE: (alexgo, andreib), _cch will only be less than zero
// in certain weird timing situations where we get a mouse move
// message in between the double click and mouse up messages.
// we should rethink how we process messages && the ordering thereof.
if(_cch < 0)
FlipRange();
// Leave word break chars
CTxtPtr tp(_rpTX); // at end of selection
Assert(_cch > 0);
tp.Move(-1);
if(tp.GetCp() && tp.FindWordBreak(WB_ISDELIMITER))// Delimiter at sel end
FindWordBreak(WB_LEFTBREAK, TRUE); // Backspace over it, etc.
}
_fIsChar = TRUE; // Tell CDisplay::UpdateView
_fDontUpdateFmt = TRUE; // we're PuttingChar()
LONG iFormat = GetiFormat(); // Save current value
LONG cchSave = _cch;
LONG cpSave = GetCp();
if(AdjustEndEOP(NEWCHARS) && publdr) // Remember what sel was
HandleSelectionAEInfo(ped, publdr, cpSave, // for undo
cchSave,GetCp(), _cch, SELAE_MERGE);
if(!_cch)
Set_iCF(iFormat);
_fDontUpdateFmt = FALSE;
if(ped->_fUpperCase)
CharUpperBuff(str, cch);
else if(ped->_fLowerCase)
CharLowerBuff(str, cch);
if(!_cch)
{
if(iCharRep == DEFAULT_INDEX)
{
CCharFormat CFTemp;
if (qw & FFE) // Find a better charset for FE char
CFTemp._iCharRep = MatchFECharRep(qw, GetFontSignatureFromFace(CF._iFont));
else
CFTemp._iCharRep = W32->CharRepFromFontSig(qw);
SetCharFormat(&CFTemp, SCF_NOKBUPDATE, NULL, CFM_CHARSET, CFM2_NOCHARSETCHECK);
}
else if(iCharRep == SYMBOL_INDEX && dwFlags & KBD_CHAR && ch > 255)
{
UINT cpg = CodePageFromCharRep(GetKeyboardCharRep(0)); // If 125x, convert char
if(IN_RANGE(1250, cpg, 1257)) // back to ANSI for storing
{ // SYMBOL_CHARSET chars
BYTE ach;
WCTMB(cpg, 0, str, cch, (char *)&ach, 1, NULL, NULL, NULL);
ch = ach;
}
}
}
if(lcid && !_fDualFontMode)
{
WORD uKbdcpg = PRIMARYLANGID(lcid);
if (!(ped->_fIMEInProgress
|| IsFELCID(uKbdcpg) && ch < 127
|| ped->_fHbrCaps))
{
const CCharFormat *pCF = GetPed()->GetCharFormat(iFormat);
if(uKbdcpg != PRIMARYLANGID(pCF->_lcid) && !IsFECharRep(pCF->_iCharRep))
{
CCharFormat CFTemp;
CFTemp._lcid = lcid;
SetCharFormat(&CFTemp, SCF_NOKBUPDATE, NULL, CFM_LCID, 0);
}
}
}
if(dwFlags & KBD_CHAR || iCharRep == SYMBOL_INDEX)
ReplaceRange(cch, str, publdr, SELRR_REMEMBERRANGE, NULL, RR_UNHIDE);
else
CleanseAndReplaceRange(cch, str, TRUE, publdr, NULL, NULL, RR_UNHIDE);
_rpPF.AdjustBackward();
if(GetPF()->IsTableRowDelimiter()) // Inserted char into TRD
InsertEOP(publdr, 0); // Insert new EOP with
_rpPF.AdjustForward(); // nonTRD paraformat
_fIsChar = FALSE;
// Restore font for Hebrew CAPS. Note that FE font is not restored
// (is handled by IME).
if(pCFCurrent && (W32->UsingHebrewKeyboard() || fRestoreCF))
SetCharFormat(pCFCurrent, SCF_NOKBUPDATE, NULL, CFM_FACE | CFM_CHARSET | CFM_SIZE, CFM2_NOCHARSETCHECK);
else if(iFormat != Get_iFormat())
CheckChangeKeyboardLayout();
SetDualFontMode(FALSE);
// Autocorrect
if (!(dwFlags & KBD_NOAUTOCORRECT) && ped->_pDocInfo &&
ped->_pDocInfo->_pfnAutoCorrect)
{
ped->AutoCorrect(this, ch, publdr);
}
if (!_pdp->IsFrozen())
CheckUpdateWindow(); // Need to update display
// for pending chars.
return TRUE;
}
/*
* CTxtSelection::CheckUpdateWindow()
*
* @mfunc
* If it's time to update the window, after pending-typed characters,
* do so now. This is needed because WM_PAINT has a lower priority
* than WM_CHAR.
*/
void CTxtSelection::CheckUpdateWindow()
{
DWORD ticks = GetTickCount();
DWORD delta = ticks - _ticksPending;
if(!_ticksPending)
_ticksPending = ticks;
else if(delta >= ticksPendingUpdate)
GetPed()->TxUpdateWindow();
}
/*
* CTxtSelection::InsertTableRow(pPF, publdr, fFixCellBorders)
*
* @mfunc
* Insert empty table row with parameters given by pPF
*
* @rdesc
* Count of CELL and NOTACHAR chars inserted if successful; else 0
*/
LONG CTxtSelection::InsertTableRow (
const CParaFormat *pPF, //@parm CParaFormat to use for delimiters
IUndoBuilder *publdr, //@parm If non-NULL, where to put anti-events
BOOL fFixCellBorders) //@parm TRUE if this row should have bottom = top cell brdrs
{
TRACEBEGIN(TRCSUBSYSSEL, TRCSCOPEINTERN, "CTxtSelection::InsertTableRow");
_cch = 0;
AssertSz(!fFixCellBorders || _rpTX.IsAtTRD(ENDFIELD),
"CTxtSelection::InsertTableRow: illegal selection cp");
LONG cpSave = GetCp();
CTxtRange rg(*this); // Use rg to get sel undo right
if(fFixCellBorders)
StopGroupTyping();
LONG cchCells = rg.InsertTableRow(pPF, publdr);
if(!cchCells)
return 0;
if(!fFixCellBorders)
{
SetCp(rg.GetCp(), FALSE);
return cchCells;
}
// Make cell bottom borders of now next-to-last row have same widths
// as the corresponding top borders
LONG cpMin;
CParaFormat PF = *GetPF();
CELLPARMS rgCellParms[MAX_TABLE_CELLS];
const CELLPARMS *prgCellParms = PF.GetCellParms();
for(LONG i = 0; i < PF._bTabCount; i++)
{
rgCellParms[i] = prgCellParms[i];
rgCellParms[i].SetBrdrWidthBottom(prgCellParms[i].GetBrdrWidthTop());
}
PF._iTabs = GetTabsCache()->Cache((LONG *)&rgCellParms[0],
(CELL_EXTRA + 1)*PF._bTabCount);
rg.Set(GetCp(), -2);
rg.SetParaFormat(&PF, publdr, PFM_TABSTOPS, PFM2_ALLOWTRDCHANGE);
rg.FindRow(&cpMin, NULL, PF._bTableLevel);
rg.Set(cpMin, -2);
rg.SetParaFormat(&PF, publdr, PFM_TABSTOPS, PFM2_ALLOWTRDCHANGE);
GetTabsCache()->Release(PF._iTabs);
Move(4, FALSE); // 1st cell of new row
if(publdr)
HandleSelectionAEInfo(GetPed(), publdr,
cpSave, 0, GetCp(), 0, SELAE_MERGE);
Update(TRUE);
return cchCells;
}
/*
* CTxtSelection::InsertEOP(publdr, ch)
*
* @mfunc
* Insert EOP character(s)
*
* @rdesc
* TRUE if successful
*/
BOOL CTxtSelection::InsertEOP (
IUndoBuilder *publdr, //@parm If non-NULL, where to put anti-events
WCHAR ch) //@parm Possible EOP char
{
TRACEBEGIN(TRCSUBSYSSEL, TRCSCOPEINTERN, "CTxtSelection::InsertEOP");
_TEST_INVARIANT_
LONG cchEOP = GetPed()->fUseCRLF() ? 2 : 1;
DWORD dwFlags = RR_NO_TRD_CHECK | RR_UNHIDE | RR_UNLINK;
BOOL fResult = FALSE;
BOOL fShift = (ch == VT);
const CParaFormat *pPF = CRchTxtPtr::GetPF(); // Get paragraph format
BOOL fInTable = pPF->InTable();
BOOL fNumbering = pPF->_wNumbering;
WCHAR szEOP[] = {CR, LF, 0};
CTxtEdit *ped = GetPed();
if(ch && (GetPed()->fUseCRLF() || IN_RANGE(VT, ch, FF)))
{
if(ch == VT)
{
CTxtPtr tp(_rpTX); // Don't allow VT after table
if(_cch > 0) // row delimiter, since TRDs
tp.Move(-_cch); // have special nonparagraph
if(tp.IsAfterTRD(0)) // properties.
ch = CR;
dwFlags = RR_NO_TRD_CHECK | RR_UNHIDE;
}
szEOP[0] = ch;
cchEOP = 1;
}
_fEOP = TRUE;
// The user hit Enter: do 1 of 4 things:
//
// 1) If at start of doc (or at start of cell at start of doc), insert
// a nontable paragraph in front of table
// 2) If following a row terminator, insert an empty row with same
// properties as the row terminator
// 3) Insert a paragraph mark
// 4) If two Enters in a row before an EOP, turn off numbering
if(_rpTX.IsAtTRD(ENDFIELD))
{
AssertSz(pPF->IsTableRowDelimiter(),
"CTxtSelection::InsertEOP: invalid paraformat");
return InsertTableRow(pPF, publdr, TRUE);
}
if(publdr)
{
publdr->StartGroupTyping();
publdr->SetNameID(UID_TYPING);
}
if(fInTable && _rpTX.IsAtStartOfCell() && !fShift)
{
Move(-2, FALSE);
if(GetCp() && !_rpTX.IsAtStartOfCell())
Move(2, FALSE);
}
if(!GetCch())
{
LONG iFormat = _iFormat;
dwFlags |= RR_NO_CHECK_TABLE_SEL;
if(CheckLinkProtection(dwFlags, iFormat))
Set_iCF(iFormat);
if(fNumbering && _rpTX.IsAfterEOP() && _rpTX.IsAtEOP())
{
// Two enters in a row turn off numbering
CParaFormat PF;
PF._wNumbering = 0;
PF._dxOffset = 0;
SetParaFormat(&PF, publdr, PFM_NUMBERING | PFM_OFFSET, PFM2_PARAFORMAT);
}
}
if(CheckTextLength(cchEOP)) // If cchEOP chars can fit...
{
CFreezeDisplay fd(GetPed()->_pdp);
LONG iFormatSave = Get_iCF(); // Save CharFormat before EOP
// Get_iCF() does AddRefFormat()
if(fNumbering) // Bullet paragraph: EOP has
{ // desired bullet CharFormat
CFormatRunPtr rpCF(_rpCF); // Get run pointers for locating
CTxtPtr rpTX(_rpTX); // EOP CharFormat
rpCF.Move(rpTX.FindEOP(tomForward));
rpCF.AdjustBackward();
Set_iCF(rpCF.GetFormat()); // Set _iFormat to EOP CharFormat
}
// Put in appropriate EOP mark
fResult = ReplaceRange(cchEOP, szEOP, publdr,
SELRR_REMEMBERRANGE, NULL, dwFlags);
if (ped->_pDocInfo && ped->_pDocInfo->_pfnAutoCorrect)
ped->AutoCorrect(this, ch == 0 ? CR : ch, publdr);
_rpPF.AdjustBackward();
if(GetPF()->IsTableRowDelimiter()) // EOP just inserted before table
{ // row
Move(-cchEOP, FALSE); // Backup before EOP
CTxtRange rg(*this); // Use clone so don't change undo
rg.Set(GetCp(), -cchEOP); // Select EOP just inserted
CParaFormat PF = *GetPed()->GetParaFormat(-1);
PF._wEffects &= ~PFE_TABLE; // Default not in table
PF._bTableLevel = GetPF()->_bTableLevel - 1;
if(PF._bTableLevel)
PF._wEffects |= PFE_TABLE; // It's in a table
Assert(PF._bTableLevel >= 0);
rg.SetParaFormat(&PF, publdr, PFM_ALL2, PFM2_ALLOWTRDCHANGE);
}
else
_rpPF.AdjustForward();
Set_iCF(iFormatSave); // Restore _iFormat if changed
ReleaseFormats(iFormatSave, -1); // Release iFormatSave
}
return fResult;
}
/*
* CTxtSelection::DeleteWithTRDCheck(publdr. selaemode, pcchMove, dwFlags)
*
* @mfunc
* Delete text in this range, inserting an EOP in place of the text
* if the range ends at a table-row start delimiter
*
* @rdesc
* Count of new characters added
*
* @devnote
* moves this text pointer to end of replaced text and
* may move text block and formatting arrays
*/
LONG CTxtSelection::DeleteWithTRDCheck (
IUndoBuilder * publdr, //@parm UndoBuilder to receive antievents
SELRR selaemode, //@parm Controls how selection antievents are to be generated.
LONG * pcchMove, //@parm number of chars moved after replace
DWORD dwFlags) //@parm ReplaceRange flags
{
TRACEBEGIN(TRCSUBSYSRANG, TRCSCOPEINTERN, "CTxtRange::ReplaceRange");
if(IsUpdatedFromCp0())
{
SetCp(0, FALSE);
_fUpdatedFromCp0 = FALSE;
}
return CTxtRange::DeleteWithTRDCheck(publdr, selaemode, pcchMove, dwFlags);
}
/*
* CTxtSelection::Delete(fCtrl, publdr)
*
* @mfunc
* Delete the selection. If fCtrl is true, this method deletes from
* min of selection to end of word
*
* @rdesc
* TRUE if successful
*/
BOOL CTxtSelection::Delete (
DWORD fCtrl, //@parm If TRUE, Ctrl key depressed
IUndoBuilder *publdr) //@parm if non-NULL, where to put anti-events
{
TRACEBEGIN(TRCSUBSYSSEL, TRCSCOPEINTERN, "CTxtSelection::Delete");
_TEST_INVARIANT_
SELRR mode = SELRR_REMEMBERRANGE;
AssertSz(!GetPed()->TxGetReadOnly(), "CTxtSelection::Delete(): read only");
if(!_cch)
BypassHiddenText(tomForward, FALSE);
if(publdr)
{
publdr->StopGroupTyping();
publdr->SetNameID(UID_DELETE);
}
if(fCtrl)
{ // Delete to word end from cpMin
Collapser(tomStart); // (won't necessarily repaint,
FindWordBreak(WB_MOVEWORDRIGHT, TRUE);// since won't delete it)
}
if(!_cch) // No selection
{ // Try to select char at IP
mode = SELRR_REMEMBERCPMIN;
if(_rpTX.GetChar() == CELL || // Don't try to delete CELL mark
!AdvanceCRLF(CSC_SNAPTOCLUSTER, TRUE))
{ // End of text, nothing to delete
Beep(); // Only executed in plain text,
return FALSE; // since else there's always
} // a final EOP to select
_fMoveBack = TRUE; // Convince Update_iFormat() to
_fUseiFormat = TRUE; // use forward format
}
if(AdjustEndEOP(NONEWCHARS) && !_cch)
Update(FALSE);
else
ReplaceRange(0, NULL, publdr, mode); // Delete selection
return TRUE;
}
/*
* CTxtSelection::BackSpace(fCtrl, publdr)
*
* @mfunc
* do what keyboard BackSpace key is supposed to do
*
* @rdesc
* TRUE iff movement occurred
*
* @comm
* This routine should probably use the Move methods, i.e., it's
* logical, not directional
*
* @devnote
* _fExtend is TRUE iff Shift key is pressed or being simulated
*/
BOOL CTxtSelection::Backspace (
BOOL fCtrl, //@parm TRUE iff Ctrl key is pressed (or being simulated)
IUndoBuilder *publdr) //@parm If not-NULL, where to put the antievents
{
TRACEBEGIN(TRCSUBSYSSEL, TRCSCOPEINTERN, "CTxtSelection::Backspace");
_TEST_INVARIANT_
SELRR mode = _cch ? SELRR_REMEMBERRANGE : SELRR_REMEMBERENDIP;
AssertSz(!GetPed()->TxGetReadOnly(),
"CTxtSelection::Backspace(): read only");
_fCaretNotAtBOL = FALSE;
if(publdr)
{
publdr->SetNameID(UID_TYPING);
if(_cch || fCtrl)
publdr->StopGroupTyping();
}
if(fCtrl) // Delete word left
{
if(!GetCpMin()) // Beginning of story:
{ // no word to delete
Beep();
return FALSE;
}
Collapser(tomStart); // First collapse to cpMin
}
if(!_cch) // Empty selection
{ // Try to select previous char
unsigned ch = _rpTX.GetPrevChar();
if (ch == CELL || ch == CR && // Don't delete CELL mark
_rpTX.IsAfterTRD(0) || // or table-row delimiter
!BypassHiddenText(tomBackward, FALSE) ||
(fCtrl ? !FindWordBreak(WB_MOVEWORDLEFT, TRUE) :
!BackupCRLF(CSC_NOMULTICHARBACKUP, TRUE)))
{ // Nothing to delete
Beep();
return FALSE;
}
if(publdr && !fCtrl)
publdr->StartGroupTyping();
}
ReplaceRange(0, NULL, publdr, mode); // Delete selection
return TRUE;
}
/*
* CTxtSelection::ReplaceRange(cchNew, pch, publdr, SELRRMode, pcchMove, dwFlags)
*
* @mfunc
* Replace selected text by new given text and update screen according
* to _fShowCaret and _fShowSelection
*
* @rdesc
* length of text inserted
*/
LONG CTxtSelection::ReplaceRange (
LONG cchNew, //@parm Length of replacing text or -1 to request
// <p pch> sz length
const WCHAR *pch, //@parm Replacing text
IUndoBuilder *publdr, //@parm If non-NULL, where to put anti-events
SELRR SELRRMode, //@parm what to do about selection anti-events.
LONG* pcchMove, //@parm number of chars moved after replacing
DWORD dwFlags) //@parm Special flags
{
TRACEBEGIN(TRCSUBSYSSEL, TRCSCOPEINTERN, "CTxtSelection::ReplaceRange");
_TEST_INVARIANT_
LONG cchNewSave;
LONG cchText = GetTextLength();
LONG cpMin, cpMost;
LONG cpSave;
BOOL fDeleteAll = FALSE;
BOOL fHeading = FALSE;
const BOOL fUpdateView = _fShowSelection;
CancelModes();
if(cchNew < 0)
cchNew = wcslen(pch);
if(!_cch && !cchNew) // Nothing to do
return 0;
if(!GetPed()->IsStreaming()) // If not pasting,
{
if(_cch != cchText && cchNew &&
(IsInOutlineView() && IsCollapsed() ||
IsHidden() && !(dwFlags & RR_UNHIDE)))
{ // Don't insert into collapsed
Beep(); // or hidden region (should
return 0; // only happen if whole story
} // collapsed or hidden)
if(!(dwFlags & RR_NO_CHECK_TABLE_SEL))
CheckTableSelection(FALSE, TRUE, NULL, 0);
}
GetPed()->GetCallMgr()->SetSelectionChanged();
dwFlags |= RR_NO_LP_CHECK; // Check is done by
// CheckTableSelection()
GetRange(cpMin, cpMost);
if(cpMin > min(_cpSel, _cpSel + _cchSel) ||// If new sel doesn't
cpMost < max(_cpSel, _cpSel + _cchSel)) // contain all of old
{ // sel, remove old sel
ShowSelection(FALSE);
_fShowCaret = TRUE;
}
_fCaretNotAtBOL = FALSE;
_fShowSelection = FALSE; // Suppress the flashies
// If we are streaming in text or RTF data, don't bother with incremental
// recalcs. The data transfer engine will take care of a final recalc
if(!GetPed()->IsStreaming())
{
// Do this before calling ReplaceRange() so that UpdateView() works
// AROO !!! Do this before replacing the text or the format ranges!!!
if(!_pdp->WaitForRecalc(cpMin, -1))
{
Tracef(TRCSEVERR, "WaitForRecalc(%ld) failed", cpMin);
cchNew = 0; // Nothing inserted
goto err;
}
}
if(publdr)
{
Assert(SELRRMode != SELRR_IGNORE);
// Use selection AntiEvent mode to determine what to do for undo
LONG cp = cpMin;
LONG cch = 0;
if(SELRRMode == SELRR_REMEMBERRANGE)
{
cp = GetCp();
cch = _cch;
}
else if(SELRRMode == SELRR_REMEMBERENDIP)
cp = cpMost;
else
Assert(SELRRMode == SELRR_REMEMBERCPMIN);
HandleSelectionAEInfo(GetPed(), publdr, cp, cch, cpMin + cchNew,
0, SELAE_MERGE);
}
if(_cch == cchText && !cchNew && !(dwFlags & RR_NEW_CHARS)) // For delete all, set
{ // up to choose Normal
fDeleteAll = TRUE; // or Heading 1
FlipRange();
fHeading = IsInOutlineView() && IsHeadingStyle(GetPF()->_sStyle);
}
cpSave = cpMin;
cchNewSave = cchNew;
cchNew = CTxtRange::ReplaceRange(cchNew, pch, publdr, SELRR_IGNORE, pcchMove, dwFlags);
_cchSel = 0; // No displayed selection
_cpSel = GetCp();
cchText = GetTextLength(); // Update total text length
_fShowSelection = fUpdateView;
if(cchNew != cchNewSave)
{
Tracef(TRCSEVERR, "CRchTxtPtr::ReplaceRange(%ld, %ld, %ld) failed", GetCp(), cpMost - cpMin, cchNew);
goto err;
}
if(fDeleteAll) // When all text is deleted
{ // use Normal style unless
CParaFormat PF; // in Outline View and first
PF._sStyle = fHeading ? STYLE_HEADING_1 : STYLE_NORMAL;
SetParaStyle(&PF, NULL, PFM_STYLE); // para was a heading
if(GetPed()->IsBiDi())
{
if(GetPed()->_fFocus && !GetPed()->_fIMEInProgress)
{
MatchKeyboardToPara();
CheckSynchCharSet(0);
}
}
else
Update_iFormat(-1);
}
// Only update caret if inplace active
if(GetPed()->fInplaceActive())
UpdateCaret(fUpdateView); // May need to scroll
else // Update caret when we get
GetPed()->_fScrollCaretOnFocus = TRUE; // focus again
return cchNew;
err:
TRACEERRSZSC("CTxtSelection::ReplaceRange()", E_FAIL);
Tracef(TRCSEVERR, "CTxtSelection::ReplaceRange(%ld, %ld)", cpMost - cpMin, cchNew);
Tracef(TRCSEVERR, "cchText %ld", cchText);
return cchNew;
}
/*
* CTxtSelection::GetPF()
*
* @mfunc
* Return ptr to CParaFormat at active end of this selection. If no PF
* runs are allocated, then return ptr to default format. If active
* end is at cpMost of a nondegenerate selection, use the PF of the
* previous char (last char in selection).
*
* @rdesc
* Ptr to CParaFormat at active end of this selection
*/
const CParaFormat* CTxtSelection::GetPF()
{
TRACEBEGIN(TRCSUBSYSBACK, TRCSCOPEINTERN, "CTxtSelection::GetPF");
if(_cch > 0)
_rpPF.AdjustBackward();
const CParaFormat* pPF = GetPed()->GetParaFormat(_rpPF.GetFormat());
if(_cch > 0)
_rpPF.AdjustForward();
return pPF;
}
/*
* CTxtSelection::SetCharFormat(pCF, flags, publdr, dwMask, dwMask2)
*
* @mfunc
* apply CCharFormat *pCF to this selection. If range is an IP
* and fApplyToWord is TRUE, then apply CCharFormat to word surrounding
* this insertion point
*
* @rdesc
* HRESULT = NOERROR if no error
*/
HRESULT CTxtSelection::SetCharFormat (
const CCharFormat *pCF, //@parm Ptr to CCharFormat to fill with results
DWORD flags, //@parm If SCF_WORD and selection is an IP,
// use enclosing word
IUndoBuilder *publdr, //@parm Undo context
DWORD dwMask, //@parm CHARFORMAT2 mask
DWORD dwMask2) //@parm Second mask
{
TRACEBEGIN(TRCSUBSYSSEL, TRCSCOPEINTERN, "CTxtSelection::SetCharFormat");
HRESULT hr = 0;
LONG iFormat = _iFormat;
if(publdr)
publdr->StopGroupTyping();
/*
* The code below applies character formatting to a double-clicked
* selection the way Word does it, that is, not applying the formatting to
* the last character in the selection if that character is a blank.
*
* See also the corresponding code in CTxtRange::GetCharFormat().
*/
CCharFormat CF;
LONG cpMin, cpMost;
LONG cch = GetRange(cpMin, cpMost);;
BOOL fCheckKeyboard = (flags & SCF_NOKBUPDATE) == 0;
if(_SelMode == smWord && (flags & SCF_USEUIRULES) && cch)
{
// In word select mode, don't include final blank in SetCharFormat
CTxtPtr tpLast(GetPed(), cpMost - 1);
if(tpLast.GetChar() == ' ') // Selection ends with a blank:
{
cpMost--; // Setup end point to end at last
cch--; // char in selection
fCheckKeyboard = FALSE;
flags &= ~SCF_WORD;
}
}
BYTE iCharRep = pCF->_iCharRep;
// Smart SB/DB Font Apply Feature
if (cch && IsRich() && // > 0 chars in rich text
!GetPed()->_fSingleCodePage && // Not in single cp mode
(dwMask & CFM_FACE)) // font change
{
if (!(dwMask & CFM_CHARSET) || iCharRep == DEFAULT_INDEX)
{
CF = *pCF;
CF._iCharRep = GetFirstAvailCharRep(GetFontSignatureFromFace(CF._iFont));
pCF = &CF;
}
dwMask2 |= CFM2_MATCHFONT; // Signal to match font charsets
}
// Selection is being set to a charformat
if(_cch && IsRich())
GetPed()->SetfSelChangeCharFormat();
if(_cch && cch < abs(_cch))
{
CTxtRange rg(*this);
rg.Set(cpMin, -cch); // Use smaller cch
hr = rg.SetCharFormat(pCF, flags, publdr, dwMask, dwMask2);
}
else
hr = CTxtRange::SetCharFormat(pCF, flags, publdr, dwMask, dwMask2);
if(fCheckKeyboard && (dwMask & CFM_CHARSET) && _iFormat != iFormat)
CheckChangeKeyboardLayout();
_fIsChar = TRUE;
UpdateCaret(!GetPed()->fHideSelection());
_fIsChar = FALSE;
return hr;
}
/*
* CTxtSelection::SetParaFormat(pPF, publdr, dwMask, dwMask2)
*
* @mfunc
* apply CParaFormat *pPF to this selection.
*
* @rdesc
* HRESULT = NOERROR if no error
*/
HRESULT CTxtSelection::SetParaFormat (
const CParaFormat* pPF, //@parm ptr to CParaFormat to apply
IUndoBuilder *publdr, //@parm Undo context for this operation
DWORD dwMask, //@parm Mask to use
DWORD dwMask2) //@parm Mask for internal flags
{
TRACEBEGIN(TRCSUBSYSSEL, TRCSCOPEINTERN, "CTxtSelection::SetParaFormat");
CFreezeDisplay fd(GetPed()->_pdp);
if(publdr)
publdr->StopGroupTyping();
// Apply the format
HRESULT hr = CTxtRange::SetParaFormat(pPF, publdr, dwMask, dwMask2);
UpdateCaret(!GetPed()->Get10Mode() || IsCaretInView());
return hr;
}
/*
* CTxtSelection::SetSelectionInfo (pselchg)
*
* @mfunc Fills out data members in a SELCHANGE structure
*/
void CTxtSelection::SetSelectionInfo(
SELCHANGE *pselchg) //@parm SELCHANGE structure to use
{
LONG cpMin, cpMost;
LONG cch = GetRange(cpMin, cpMost);;
pselchg->chrg.cpMin = cpMin;
pselchg->chrg.cpMost = cpMost;
pselchg->seltyp = SEL_EMPTY;
// OR in the following selection type flags if active:
//
// SEL_EMPTY: insertion point
// SEL_TEXT: at least one character selected
// SEL_MULTICHAR: more than one character selected
// SEL_OBJECT: at least one object selected
// SEL_MULTIOJBECT: more than one object selected
//
// Note that the flags are OR'ed together.
if(cch)
{
LONG cObjects = GetObjectCount(); // Total object count
if(cObjects) // There are objects:
{ // get count in range
CObjectMgr *pobjmgr = GetPed()->GetObjectMgr();
Assert(pobjmgr);
cObjects = pobjmgr->CountObjectsInRange(cpMin, cpMost);
if(cObjects > 0)
{
pselchg->seltyp |= SEL_OBJECT;
if(cObjects > 1)
pselchg->seltyp |= SEL_MULTIOBJECT;
}
}
cch -= cObjects;
AssertSz(cch >= 0, "objects are overruning the selection");
if(cch > 0)
{
pselchg->seltyp |= SEL_TEXT;
if(cch > 1)
pselchg->seltyp |= SEL_MULTICHAR;
}
}
}
/*
* CTxtSelection::UpdateForAutoWord ()
*
* @mfunc Update state to prepare for auto word selection
*
* @rdesc void
*/
void CTxtSelection::UpdateForAutoWord()
{
AssertSz(!_cch,
"CTxtSelection::UpdateForAutoWord: Selection isn't degenerate");
// If enabled, prepare Auto Word Sel
if(GetPed()->TxGetAutoWordSel())
{
CTxtPtr tp(_rpTX);
// Move anchor to new location
_cpAnchor = GetCp();
// Remember that FindWordBreak moves tp's cp
// (aren't side effects wonderful?
tp.FindWordBreak(WB_MOVEWORDRIGHT);
_cpAnchorMost =_cpWordMost = tp.GetCp();
tp.FindWordBreak(WB_MOVEWORDLEFT);
_cpAnchorMin = _cpWordMin = tp.GetCp();
_fAutoSelectAborted = FALSE;
}
}
/*
* CTxtSelection::AutoSelGoBackWord(pcpToUpdate, iDirToPrevWord, iDirToNextWord)
*
* @mfunc Backup a word in auto word selection
*/
void CTxtSelection::AutoSelGoBackWord(
LONG * pcpToUpdate, //@parm end of word selection to update
int iDirToPrevWord, //@parm direction to next word
int iDirToNextWord) //@parm direction to previous word
{
if (GetCp() >= _cpAnchorMin &&
GetCp() <= _cpAnchorMost)
{
// We are back in the first word. Here we want to pop
// back to a selection anchored by the original selection
Set(GetCp(), GetCp() - _cpAnchor);
_fAutoSelectAborted = FALSE;
_cpWordMin = _cpAnchorMin;
_cpWordMost = _cpAnchorMost;
}
else
{
// pop back a word
*pcpToUpdate = _cpWordPrev;
CTxtPtr tp(_rpTX);
_cpWordPrev = GetCp() + tp.FindWordBreak(iDirToPrevWord);
FindWordBreak(iDirToNextWord, TRUE);
}
}
/*
* CTxtSelection::InitClickForAutWordSel (pt)
*
* @mfunc Init auto selection for click with shift key down
*
* @rdesc void
*/
void CTxtSelection::InitClickForAutWordSel(
const POINTUV pt) //@parm Point of click
{
// If enabled, prepare Auto Word Sel
if(GetPed()->TxGetAutoWordSel())
{
// If auto word selection is occuring we want to pretend
// that the click is really part of extending the selection.
// Therefore, we want the auto word select data to look as
// if the user had been extending the selection via the
// mouse all along. So we set the word borders to the
// word that would have been previously selected.
// Need this for finding word breaks
CRchTxtPtr rtp(GetPed());
LONG cpClick = _pdp->CpFromPoint(pt, NULL, &rtp, NULL, TRUE);
int iDir = -1;
if(cpClick < 0)
{
// If this fails what can we do? Prentend it didn't happen!
// We can do this because it will only make the UI act a
// little funny and chances are the user won't even notice.
return;
}
// Assume click is within anchor word
_cpWordMost = _cpAnchorMost;
_cpWordMin = _cpAnchorMin;
if(cpClick > _cpAnchorMost)
{
// Click is after anchor word, so set cpMost appropriately
iDir = WB_MOVEWORDLEFT;
rtp.FindWordBreak(WB_MOVEWORDLEFT);
_cpWordMost = rtp.GetCp();
}
// Click is before the anchor word
else if(cpClick < _cpAnchorMost)
{
// Click is before anchor word, so set cpMin appropriately.
iDir = WB_MOVEWORDRIGHT;
rtp.FindWordBreak(WB_MOVEWORDRIGHT);
_cpWordMin = rtp.GetCp();
}
if(iDir != -1)
{
rtp.FindWordBreak(iDir);
_cpWordPrev = rtp.GetCp();
}
}
}
/*
* CTxtSelection::CreateCaret ()
*
* @mfunc Create a caret
*
* @devnote
* The caret is characterized by a height (_dvpCaret), a keyboard
* direction (if BiDi), a width (1 to 8, since OS can't handle carets
* larger than 8 pixels), and an italic state. One could cache this
* info thereby avoiding computing the caret on every keystroke.
*/
void CTxtSelection::CreateCaret()
{
CTxtEdit * ped = GetPed();
const CCharFormat *pCF = ped->GetCharFormat(_iFormat);
DWORD dwCaretType = 0;
BOOL fItalic;
LONG y = min(_dvpCaret, 512);
y = max(0, y);
fItalic = pCF->_dwEffects & CFE_ITALIC && _dvpCaret > 15; //9 pt/15 pixels looks bad
// Caret shape reflects current charset
if(ped->IsComplexScript() && IsComplexKbdInstalled())
{
// Custom carets aren't italicized
LCID lcid = GetKeyboardLCID();
#ifdef FANCY_CARET
fItalic = 0;
dwCaretType = CARET_CUSTOM;
#endif
if (W32->IsBiDiLcid(lcid))
{
dwCaretType = CARET_CUSTOM | CARET_BIDI;
fItalic = 0;
}
#ifdef FANCY_CARET
else if (PRIMARYLANGID(lcid) == LANG_THAI)
dwCaretType = CARET_CUSTOM | CARET_THAI;
else if (W32->IsIndicLcid(lcid))
dwCaretType = CARET_CUSTOM | CARET_INDIC;
#endif
}
//REVIEW (keithcu) Vertical text can't do complex scripts or italic carets (yet?)
if (ped->_pdp->GetTflow() != tflowES)
{
fItalic = 0;
dwCaretType = 0;
}
INT dx = duCaret;
DWORD dwCaretInfo = (_dvpCaret << 16) | (dx << 8) | (dwCaretType << 4) |
(fItalic << 1) | !_cch;
#ifndef NOFEPROCESSING
if (ped->_fKoreanBlockCaret)
{
// Support Korean block caret during Kor IME composition
// Basically, we want to create a caret using the width and height of the
// character at current cp.
CDisplay * pdp = ped->_pdp;
LONG cpMin, cpMost;
POINTUV ptStart, ptEnd;
GetRange(cpMin, cpMost);
CRchTxtPtr rtp(ped, cpMin);
// REVIEW: generalize PointFromTp to return both values (so one call)
if (pdp->PointFromTp(rtp, NULL, FALSE, ptStart, NULL, TA_TOP+TA_LEFT) != -1 &&
pdp->PointFromTp(rtp, NULL, FALSE, ptEnd, NULL, TA_BOTTOM+TA_RIGHT) != -1)
{
// Destroy whatever caret bitmap we had previously
DeleteCaretBitmap(TRUE);
LONG iCharWidth = abs(ptEnd.u - ptStart.u);
LONG iCharHeight = abs(ptEnd.v - ptStart.v);
// REVIEW: honwch do we need to SetCaretPos for all Tflows
if (IsCaretHorizontal())
ped->TxCreateCaret(0, iCharWidth, iCharHeight);
else
ped->TxCreateCaret(0, iCharHeight, iCharWidth);
switch (_pdp->GetTflow())
{
case tflowES:
ped->TxSetCaretPos(ptStart.u, ptStart.v);
break;
case tflowSW:
ped->TxSetCaretPos(ptStart.u, ptEnd.v);
break;
case tflowWN:
ped->TxSetCaretPos(ptEnd.u, ptEnd.v);
break;
case tflowNE:
ped->TxSetCaretPos(ptEnd.u, ptStart.v);
break;
}
_fCaretCreated = TRUE;
}
return;
}
#endif
// We always create the caret bitmap on the fly since it
// may be of arbitrary size
if (dwCaretInfo != _dwCaretInfo)
{
_dwCaretInfo = dwCaretInfo; // Update caret info
// Destroy whatever caret bitmap we had previously
DeleteCaretBitmap(FALSE);
if (y && y == _dvpCaret && (_cch || fItalic || dwCaretType))
{
LONG dy = 4; // Assign value to suppress
LONG i; // compiler warning
WORD rgCaretBitMap[512];
WORD wBits = 0x0020;
if(_cch) // Create blank bitmap if
{ // selection is nondegenerate
y = 1; // (allows others to query
wBits = 0; // OS where caret is)
fItalic = FALSE;
}
if(fItalic)
{
i = (5*y)/16 - 1; // System caret can't be wider
i = min(i, 7); // than 8 bits
wBits = 1 << i; // Make larger italic carets
dy = y/7; // more vertical. Ideal is
dy = max(dy, 4); // usually up 4 over 1, but
} // if bigger go up 5 over 1...
for(i = y; i--; )
{
rgCaretBitMap[i] = wBits;
if(fItalic && !(i % dy))
wBits /= 2;
}
if(!fItalic && !_cch && dwCaretType)
{
#ifdef FANCY_CARET
dwCaretType &= ~CARET_CUSTOM;
// Create an appropriate shape
switch (dwCaretType)
{
case CARET_BIDI:
// BiDi is a caret with a little triangle on top (flag shape pointing left)
rgCaretBitMap[0] = 0x00E0;
rgCaretBitMap[1] = 0x0060;
break;
case CARET_THAI:
// Thai is an L-like shape (same as system edit control)
rgCaretBitMap[y-2] = 0x0030;
rgCaretBitMap[y-1] = 0x0038;
break;
case CARET_INDIC:
// Indic is a T-like shape
rgCaretBitMap[0] = 0x00F8;
rgCaretBitMap[1] = 0x0070;
break;
default:
if (ped->IsBiDi())
{
// Non-BiDi caret in BiDi document (flag shape pointing right)
rgCaretBitMap[0] = 0x0038;
rgCaretBitMap[1] = 0x0030;
}
}
#else
// No fancy caret, we only setup CARET_BIDI case
rgCaretBitMap[0] = 0x00E0;
rgCaretBitMap[1] = 0x0060;
#endif
}
_hbmpCaret = (HBITMAP)CreateBitmap(8, y, 1, 1, rgCaretBitMap);
}
}
if (IsCaretHorizontal())
ped->TxCreateCaret(_hbmpCaret, dx, _dvpCaret);
else
ped->TxCreateCaret(_hbmpCaret, _dvpCaret, dx);
_fCaretCreated = TRUE;
LONG xShift = _hbmpCaret ? 2 : 0;
if(fItalic)
{
// TODO: figure out better shift algorithm. Use CCcs::_xOverhang?
if(pCF->_iFont == IFONT_TMSNEWRMN)
xShift = 4;
xShift += y/16;
}
xShift = _upCaret - xShift;
if (_pdp->GetTflow() == tflowSW || _pdp->GetTflow() == tflowWN)
ped->TxSetCaretPos(xShift, _vpCaret + _dvpCaret);
else
ped->TxSetCaretPos(xShift, _vpCaret);
}
/*
* CTxtSelection::DeleteCaretBitmap (fReset)
*
* @mfunc DeleteCaretBitmap
*/
void CTxtSelection::DeleteCaretBitmap(
BOOL fReset)
{
if(_hbmpCaret)
{
DestroyCaret();
DeleteObject((void *)_hbmpCaret);
_hbmpCaret = NULL;
}
if(fReset)
_dwCaretInfo = 0;
}
/*
* CTxtSelection::SetDelayedSelectionRange (cp, cch)
*
* @mfunc sets the selection range such that it won't take effect until
* the control is "stable"
*/
void CTxtSelection::SetDelayedSelectionRange(
LONG cp, //@parm Active end
LONG cch) //@parm Signed extension
{
CSelPhaseAdjuster *pspa;
pspa = (CSelPhaseAdjuster *)GetPed()->GetCallMgr()->GetComponent(
COMP_SELPHASEADJUSTER);
Assert(pspa);
pspa->CacheRange(cp, cch);
}
/*
* CTxtSelection::CheckPlainTextFinalEOP ()
*
* @mfunc
* returns TRUE if this is a plain-text, multiline control with caret
* allowed at BOL and the selection at the end of the story following
* and EOP
*
* @rdesc
* TRUE if all of the conditions above are met
*/
BOOL CTxtSelection::CheckPlainTextFinalEOP()
{
return !IsRich() && _pdp->IsMultiLine() && // Plain-text, multiline
!_fCaretNotAtBOL && // with caret OK at BOL,
GetCp() == GetTextLength() && // & cp at end of story
_rpTX.IsAfterEOP();
}
/*
* CTxtSelection::StopGroupTyping()
*
* @mfunc
* Tell undo manager to stop group typing
*/
void CTxtSelection::StopGroupTyping()
{
IUndoMgr * pundo = GetPed()->GetUndoMgr();
CheckTableIP(FALSE);
if(pundo)
pundo->StopGroupTyping();
}
/*
* CTxtSelection::SetupDualFont()
*
* @mfunc checks to see if dual font support is necessary; in this case,
* switching to an English font if English text is entered into
* an FE run
* @rdesc
* A pointer to the current CharFormat if the font has to be changed.
*/
void CTxtSelection::SetupDualFont()
{
CTxtEdit * ped = GetPed();
CCharFormat CF;
CF._iCharRep = ANSI_INDEX;
CCFRunPtr rp(*this);
if (rp.GetPreferredFontInfo(
ANSI_INDEX,
CF._iCharRep,
CF._iFont,
CF._yHeight,
CF._bPitchAndFamily,
_iFormat,
IGNORE_CURRENT_FONT))
{
if (!_cch)
SetCharFormat(&CF, SCF_NOKBUPDATE, NULL, CFM_FACE | CFM_CHARSET | CFM_SIZE, 0);
else
{
// For selection, we need to set the character format at cpMin+1
// and use the format for the selection.
CTxtRange rg(ped, GetCpMin() + 1, 0);
rg.SetCharFormat(&CF, SCF_NOKBUPDATE, NULL, CFM_FACE | CFM_CHARSET | CFM_SIZE, 0);
Set_iCF(rg.Get_iCF());
GetCharFormatCache()->Release(_iFormat); // rg.Get_iCF() AddRefs it
_fUseiFormat = TRUE;
}
SetDualFontMode(TRUE);
}
}
//
// CSelPhaseAdjuster methods
//
/*
* CSelPhaseAdjuster::CSelPhaseAdjuster (ped)
*
* @mfunc constructor
*/
CSelPhaseAdjuster::CSelPhaseAdjuster(
CTxtEdit *ped) //@parm the edit context
{
_cp = _cch = -1;
_ped = ped;
_ped->GetCallMgr()->RegisterComponent((IReEntrantComponent *)this,
COMP_SELPHASEADJUSTER);
}
/*
* CSelPhaseAdjuster::~CSelPhaseAdjuster()
*
* @mfunc destructor
*/
CSelPhaseAdjuster::~CSelPhaseAdjuster()
{
// Save some indirections
CTxtEdit *ped = _ped;
if(_cp != -1)
{
ped->GetSel()->SetSelection(_cp - _cch, _cp);
// If the selection is updated, then we invalidate the
// entire display because the old selection can still
// appear otherwise because the part of the screen that
// it was on is not updated.
if(ped->fInplaceActive())
{
// Tell entire client rectangle to update.
// FUTURE: The smaller we make this the better.
ped->TxInvalidate();
}
}
ped->GetCallMgr()->RevokeComponent((IReEntrantComponent *)this);
}
/*
* CSelPhaseAdjuster::CacheRange(cp, cch)
*
* @mfunc tells this class the selection range to remember
*/
void CSelPhaseAdjuster::CacheRange(
LONG cp, //@parm Active end to remember
LONG cch) //@parm Signed extension to remember
{
_cp = cp;
_cch = cch;
}
Reference in a new issue Copy permalink