4296 lines
143 KiB
C++
4296 lines
143 KiB
C++
/*
|
|
* @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-1998, 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"
|
|
|
|
#ifdef LINESERVICES
|
|
#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;
|
|
BOOL fMoveBack = _fMoveBack;
|
|
CTxtEdit *ped = GetPed();
|
|
|
|
if(!_cch) // Update _cpAnchor, etc.
|
|
UpdateForAutoWord();
|
|
|
|
if(!ped->fInplaceActive() || ped->IsStreaming())
|
|
{
|
|
// Nothing to do while inactive or streaming in text or RTF data
|
|
return TRUE;
|
|
}
|
|
|
|
if(_cch && (_fSelHasEOP || _fSelHasCell))
|
|
{
|
|
BOOL fInTable = GetPF()->InTable();
|
|
if(!fInTable)
|
|
{
|
|
CFormatRunPtr rp(_rpPF);
|
|
rp.AdvanceCp(-_cch);
|
|
fInTable = (ped->GetParaFormat(rp.GetFormat()))->InTable();
|
|
}
|
|
if(fInTable)
|
|
Expander(_fSelHasEOP ? tomParagraph : tomCell,
|
|
TRUE, NULL, &cpMin, &cpMost);
|
|
}
|
|
|
|
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.AdvanceCp(cpMin - cp); // Start at cpMin
|
|
if(rp.IsCollapsed())
|
|
cpMin += rp.FindExpandedBackward();
|
|
rp.AdjustForward();
|
|
|
|
BOOL fCpMinCollapsed = rp.IsCollapsed();
|
|
rp.AdvanceCp(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.AdvanceCp(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();
|
|
|
|
_fExtend = FALSE;
|
|
Advance(cch);
|
|
rp.AdjustForward();
|
|
if(cch <= 0 && rp.IsCollapsed() && _rpTX.IsAfterEOP())
|
|
BackupCRLF();
|
|
_fCaretNotAtBOL = FALSE;
|
|
}
|
|
}
|
|
|
|
// Don't let active end be in hidden text
|
|
CCFRunPtr rp(*this);
|
|
|
|
cp = GetCp();
|
|
GetRange(cpMin, cpMost);
|
|
if(_cch && (cpMin || cpMost < cchText))
|
|
{
|
|
rp.AdvanceCp(cpMin - cp); // Start at cpMin
|
|
BOOL fHidden = rp.IsInHidden();
|
|
rp.AdvanceCp(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();
|
|
|
|
_fExtend = FALSE;
|
|
Advance(cch);
|
|
_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;
|
|
}
|
|
|
|
_TEST_INVARIANT_
|
|
|
|
// 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);
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
/*
|
|
* CTxtSelection::CheckSynchCharSet(dwCharFlag)
|
|
*
|
|
* @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(
|
|
DWORD dwCharFlag)
|
|
{
|
|
CTxtEdit *ped = GetPed();
|
|
LONG iFormat = GetiFormat();
|
|
const CCharFormat *pCF = ped->GetCharFormat(iFormat);
|
|
BYTE bCharSet = pCF->_bCharSet;
|
|
HKL hkl = GetKeyboardLayout(0xFFFFFFFF); // Force refresh
|
|
WORD wlidKbd = LOWORD(hkl);
|
|
UINT uKbdCodePage = ConvertLanguageIDtoCodePage(wlidKbd);
|
|
|
|
// 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 &&
|
|
(UINT)GetCodePage(bCharSet) != uKbdCodePage &&
|
|
(!ped->_fSingleCodePage ||
|
|
uKbdCodePage == 1252 ||
|
|
uKbdCodePage == (ped->_pDocInfo ?
|
|
ped->_pDocInfo->wCpg :
|
|
GetSystemDefaultCodePage())) &&
|
|
bCharSet != SYMBOL_CHARSET &&
|
|
bCharSet != OEM_CHARSET &&
|
|
!(W32->IsFECodePage(uKbdCodePage) && bCharSet == ANSI_CHARSET))
|
|
{
|
|
CheckChangeFont(hkl, uKbdCodePage, iFormat, dwCharFlag);
|
|
}
|
|
|
|
return uKbdCodePage;
|
|
}
|
|
|
|
/*
|
|
* 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;
|
|
|
|
BOOL fRTLPara = IsParaRTL(); // Get paragraph direction
|
|
|
|
if(W32->IsBiDiLcid(LOWORD(GetKeyboardLayout(0))) == fRTLPara)
|
|
return FALSE;
|
|
|
|
// Current keyboard direction didn't match paragraph direction...
|
|
|
|
BYTE bCharSet;
|
|
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());
|
|
bCharSet = pCF->_bCharSet;
|
|
if(IsRTLCharSet(bCharSet) == fRTLPara)
|
|
hkl = W32->CheckChangeKeyboardLayout(bCharSet);
|
|
} 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());
|
|
bCharSet = pCF->_bCharSet;
|
|
if(IsRTLCharSet(bCharSet) == fRTLPara)
|
|
hkl = W32->CheckChangeKeyboardLayout(bCharSet);
|
|
}
|
|
if(!hkl)
|
|
{
|
|
// Still didn't find an appropriate charformat so see if
|
|
// default charformat matches paragraph direction.
|
|
pCF = ped->GetCharFormat(rpCF.GetFormat());
|
|
bCharSet = pCF->_bCharSet;
|
|
if(IsRTLCharSet(bCharSet) == fRTLPara)
|
|
hkl = W32->CheckChangeKeyboardLayout(bCharSet);
|
|
|
|
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)
|
|
*
|
|
* @mfunc
|
|
* This routine determines where the caret should be positioned
|
|
* on screen.
|
|
* This routine is trivial, 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(
|
|
RECT & rcClient,
|
|
POINT & 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.Advance(-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;
|
|
}
|
|
|
|
DWORD dwScrollBars = ped->TxGetScrollBars();
|
|
BOOL fAutoVScroll = FALSE;
|
|
BOOL fAutoHScroll = FALSE;
|
|
BOOL fBeforeCp = _rpTX.IsAfterEOP();
|
|
POINT pt;
|
|
CLinePtr rp(_pdp);
|
|
RECT rcClient;
|
|
RECT rcView;
|
|
|
|
LONG xWidthView, yHeightView;
|
|
LONG xScroll = _pdp->GetXScroll();
|
|
LONG yScroll = _pdp->GetYScroll();
|
|
|
|
INT yAbove = 0; // Ascent of line above & beyond IP
|
|
INT yAscent; // Ascent of IP
|
|
INT yAscentLine;
|
|
LONG yBase; // Base of IP & line
|
|
INT yBelow = 0; // Descent of line below & beyond IP
|
|
INT yDescent; // Descent of IP
|
|
INT yDescentLine;
|
|
INT ySum;
|
|
LONG yViewTop, yViewBottom;
|
|
|
|
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 = IsRTLCharSet(GetCF()->_bCharSet);
|
|
_rpCF.AdjustForward();
|
|
|
|
if (fRTLPrevRun != IsRTLCharSet(GetCF()->_bCharSet) &&
|
|
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.
|
|
yViewTop = max(rcView.top, rcClient.top);
|
|
yViewBottom = min(rcView.bottom, rcClient.bottom);
|
|
|
|
xWidthView = rcView.right - rcView.left;
|
|
yHeightView = yViewBottom - yViewTop;
|
|
|
|
if(fScrollIntoView)
|
|
{
|
|
fAutoVScroll = (dwScrollBars & ES_AUTOVSCROLL) != 0;
|
|
fAutoHScroll = (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 || fAutoHScroll))
|
|
{ // Would scroll but don't have
|
|
ped->_fScrollCaretOnFocus = TRUE; // focus. Signal to scroll
|
|
if (!ped->Get10Mode() || !GetAutoVScroll())
|
|
fAutoVScroll = fAutoHScroll = 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;
|
|
|
|
pt.x = rcView.left; // Default left
|
|
if(Align == PFA_CENTER)
|
|
pt.x = (rcView.left + rcView.right)/2;
|
|
|
|
else if(Align == PFA_RIGHT)
|
|
pt.x = rcView.right;
|
|
|
|
pt.x -= xScroll; // 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.)
|
|
pt.y += rp->_yHeight;
|
|
}
|
|
|
|
_xCaret = (LONG) pt.x;
|
|
yBase = (LONG) pt.y;
|
|
|
|
// Compute caret height, ascent, and descent
|
|
yAscent = GetCaretHeight(&yDescent);
|
|
yAscent -= yDescent;
|
|
|
|
// Default to line empty case. Use what came back from the default
|
|
// calculation above.
|
|
yDescentLine = yDescent;
|
|
yAscentLine = yAscent;
|
|
|
|
if(rp.IsValid())
|
|
{
|
|
if(rp->_yDescent != -1)
|
|
{
|
|
// Line has been measured so we can use the line's values
|
|
yDescentLine = rp->_yDescent;
|
|
yAscentLine = rp->_yHeight - yDescentLine;
|
|
}
|
|
}
|
|
|
|
if(yAscent + yDescent == 0)
|
|
{
|
|
yAscent = yAscentLine;
|
|
yDescent = yDescentLine;
|
|
}
|
|
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.
|
|
yAscent = min(yAscent, yAscentLine);
|
|
yDescent = min(yDescent, yDescentLine);
|
|
}
|
|
|
|
if(fAutoVScroll)
|
|
{
|
|
Assert(yDescentLine >= yDescent);
|
|
Assert(yAscentLine >= yAscent);
|
|
|
|
yBelow = yDescentLine - yDescent;
|
|
yAbove = yAscentLine - yAscent;
|
|
|
|
ySum = yAscent;
|
|
|
|
// Scroll as much as possible into view, giving priorities
|
|
// primarily to IP and secondarily ascents
|
|
if(ySum > yHeightView)
|
|
{
|
|
yAscent = yHeightView;
|
|
yDescent = 0;
|
|
yAbove = 0;
|
|
yBelow = 0;
|
|
}
|
|
else if((ySum += yDescent) > yHeightView)
|
|
{
|
|
yDescent = yHeightView - yAscent;
|
|
yAbove = 0;
|
|
yBelow = 0;
|
|
}
|
|
else if((ySum += yAbove) > yHeightView)
|
|
{
|
|
yAbove = yHeightView - (ySum - yAbove);
|
|
yBelow = 0;
|
|
}
|
|
else if((ySum += yBelow) > yHeightView)
|
|
yBelow = yHeightView - (ySum - yBelow);
|
|
}
|
|
else
|
|
{
|
|
AssertSz(yAbove == 0, "yAbove non-zero");
|
|
AssertSz(yBelow == 0, "yBelow non-zero");
|
|
}
|
|
|
|
// Update real caret x pos (constant during vertical moves)
|
|
_xCaretReally = _xCaret - rcView.left + xScroll;
|
|
if (!(dwScrollBars & ES_AUTOHSCROLL) && // Not auto hscrolling
|
|
!_pdp->IsHScrollEnabled()) // and no scrollbar
|
|
{
|
|
if (_xCaret < rcView.left) // Caret off left edge
|
|
_xCaret = rcView.left;
|
|
else if(_xCaret + GetCaretDelta() > rcView.right)// Caret off right edge
|
|
_xCaret = rcView.right - dxCaret; // 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(yBase + yDescent + yBelow > yViewTop &&
|
|
yBase - yAscent - yAbove < yViewBottom)
|
|
{
|
|
if(yBase - yAscent - yAbove < yViewTop) // Caret is partially
|
|
{ // visible
|
|
if(fAutoVScroll) // Top isn't visible
|
|
goto scrollit;
|
|
Assert(yAbove == 0);
|
|
|
|
yAscent = yBase - yViewTop; // Change ascent to amount
|
|
if(yBase < yViewTop) // visible
|
|
{ // Move base to top
|
|
yDescent += yAscent;
|
|
yAscent = 0;
|
|
yBase = yViewTop;
|
|
}
|
|
}
|
|
if(yBase + yDescent + yBelow > yViewBottom)
|
|
{
|
|
if(fAutoVScroll) // Bottom isn't visible
|
|
goto scrollit;
|
|
Assert(yBelow == 0);
|
|
|
|
yDescent = yViewBottom - yBase; // Change descent to amount
|
|
if(yBase > yViewBottom) // visible
|
|
{ // Move base to bottom
|
|
yAscent += yDescent;
|
|
yDescent = 0;
|
|
yBase = yViewBottom;
|
|
}
|
|
}
|
|
|
|
// Anything still visible?
|
|
if(yAscent <= 0 && yDescent <= 0)
|
|
goto not_visible;
|
|
|
|
// If left or right isn't visible, scroll or set non_visible
|
|
if (_xCaret < rcView.left || // Left isn't visible
|
|
_xCaret + GetCaretDelta() > rcView.right)// Right isn't visible
|
|
{
|
|
if(fAutoHScroll)
|
|
goto scrollit;
|
|
goto not_visible;
|
|
}
|
|
|
|
_yCaret = yBase - yAscent;
|
|
_yHeightCaret = (INT) yAscent + yDescent;
|
|
}
|
|
else if(fAutoHScroll || fAutoVScroll) // Caret isn't visible
|
|
goto scrollit; // scroll it into view
|
|
else
|
|
{
|
|
not_visible:
|
|
// Caret isn't visible, don't show it
|
|
_xCaret = -32000;
|
|
_yCaret = -32000;
|
|
_yHeightCaret = 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())
|
|
yScroll = 0;
|
|
|
|
else if(yBase - yAscent - yAbove < yViewTop) // Top invisible
|
|
yScroll -= yViewTop - (yBase - yAscent - yAbove); // Make it so
|
|
|
|
else if(yBase + yDescent + yBelow > yViewBottom) // Bottom invisible
|
|
{
|
|
yScroll += yBase + yDescent + yBelow - yViewBottom; // Make it so
|
|
|
|
// Don't do following special adjust if the current line is bigger
|
|
// than the client area
|
|
if(rp->_yHeight < yViewBottom - yViewTop)
|
|
{
|
|
yScroll = _pdp->AdjustToDisplayLastLine(yBase + rp->_yHeight,
|
|
yScroll);
|
|
}
|
|
}
|
|
}
|
|
if(fAutoHScroll)
|
|
{
|
|
if(_xCaret < rcView.left) // Left invisible
|
|
{
|
|
xScroll -= rcView.left - _xCaret; // Make it visible
|
|
if(xScroll > 0) // Scroll left in
|
|
{ // chunks to make
|
|
xScroll -= xWidthView / 3; // typing faster
|
|
xScroll = max(0, xScroll);
|
|
}
|
|
}
|
|
else if(_xCaret + GetCaretDelta() > rcView.right) // right invisible
|
|
{ // Make it visible
|
|
xScroll += _xCaret + dxCaret - rcView.left // We don't scroll
|
|
- xWidthView; // in chunks because
|
|
} // this more edit
|
|
} // control like.
|
|
if(yScroll != _pdp->GetYScroll() || xScroll != _pdp->GetXScroll())
|
|
{
|
|
if (_pdp->ScrollView(xScroll, yScroll, FALSE, FALSE) == FALSE)
|
|
{
|
|
if(ped->_fFocus && _fShowCaret)
|
|
{
|
|
CreateCaret();
|
|
ped->TxShowCaret(TRUE);
|
|
}
|
|
return FALSE;
|
|
}
|
|
return TRUE;
|
|
}
|
|
return FALSE;
|
|
}
|
|
|
|
/*
|
|
* CTxtSelection::GetCaretHeight(pyDescent)
|
|
*
|
|
* @mfunc
|
|
* Add a given amount to _xCaret (to make special case of inserting
|
|
* a character nice and fast)
|
|
*
|
|
* @rdesc
|
|
* Caret height, <lt> 0 if failed
|
|
*/
|
|
INT CTxtSelection::GetCaretHeight (
|
|
INT *pyDescent) 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 = fc().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(pyDescent)
|
|
*pyDescent = 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_
|
|
|
|
RECT rc;
|
|
_pdp->GetViewRect(rc);
|
|
|
|
return (_xCaret + dxCaret > rc.left) &&
|
|
(_xCaret < rc.right) &&
|
|
(_yCaret + _yHeightCaret > rc.top) &&
|
|
(_yCaret < rc.bottom);
|
|
}
|
|
|
|
/*
|
|
* 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::LineLength(pcch)
|
|
*
|
|
* @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.RpSetCp(GetCp(), _fCaretNotAtBOL);
|
|
cch = rp.GetAdjustedLineLength();
|
|
*pcp = GetCp() - rp.RpGetIch();
|
|
}
|
|
else
|
|
{
|
|
LONG cpMin, cpMost, cchLast;
|
|
GetRange(cpMin, cpMost);
|
|
rp.RpSetCp(cpMin, FALSE); // Selections can't start at EOL
|
|
cch = rp.RpGetIch();
|
|
*pcp = cpMin - cch;
|
|
rp.RpSetCp(cpMost, TRUE); // Selections can't end at BOL
|
|
|
|
// Remove trailing EOP, if it exists and isn't already selected
|
|
cchLast = rp.GetAdjustedLineLength() - rp.RpGetIch();
|
|
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->TxInvalidateRect(NULL, FALSE);
|
|
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 POINT pt, //@parm Point in containing window client coords
|
|
const RECT *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 POINT 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;
|
|
RECT rcView;
|
|
CLinePtr rp(_pdp);
|
|
CRchTxtPtr rtp(GetPed());
|
|
LONG y;
|
|
|
|
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.y 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);
|
|
y = pt.y + _pdp->GetYScroll() - rcView.top;
|
|
|
|
if(y > rp.Count()*rp->_yHeight) // Below last line of
|
|
{ // text
|
|
rtp.Advance(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.AdvanceCp(-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.RpGetIch() != 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 POINT 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)
|
|
{
|
|
// Extend both active and dead ends on word boundaries
|
|
_cch = 0; // Start with IP at pt
|
|
SetExtend(FALSE);
|
|
FindWordBreak(WB_MOVEWORDRIGHT); // Go to end of word
|
|
SetExtend(TRUE);
|
|
FindWordBreak(WB_MOVEWORDLEFT); // 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 POINT 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.RpGetIch(); // 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;
|
|
}
|
|
SetExtend(FALSE);
|
|
Advance(cchBackward);
|
|
|
|
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;
|
|
}
|
|
}
|
|
}
|
|
SetExtend(TRUE);
|
|
Advance(cchForward);
|
|
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 POINT 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;
|
|
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) < 0)
|
|
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);
|
|
}
|
|
|
|
SetExtend(TRUE);
|
|
cch = rp.RpGetIch();
|
|
if(_SelMode > smWord && cch == rp->_cch) // If in line or para select
|
|
{ // modes and pt at EOL,
|
|
rtp.Advance(-cch); // make sure we stay on that
|
|
rp.RpAdvanceCp(-cch); // line
|
|
cch = 0;
|
|
}
|
|
|
|
SetCp(rtp.GetCp()); // Move active end to pt
|
|
// Caret OK at BOL _unless_
|
|
_fCaretNotAtBOL = _cch > 0; // 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
|
|
Advance(-cch);
|
|
}
|
|
else if(_SelMode == smPara)
|
|
Advance(rp.FindParagraph(_cch >= 0)); // 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();
|
|
Advance(_cpAnchor - GetCp()); // Extend from anchor
|
|
|
|
FindWordBreak(_cch < 0 ? WB_MOVEWORDLEFT : WB_MOVEWORDRIGHT);
|
|
|
|
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);
|
|
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)
|
|
Advance(_cch > 0 ? 1 : -1);
|
|
|
|
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);
|
|
}
|
|
|
|
/*
|
|
* 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)
|
|
*
|
|
* @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)
|
|
{
|
|
TRACEBEGIN(TRCSUBSYSSEL, TRCSCOPEINTERN, "CTxtSelection::Left");
|
|
|
|
_TEST_INVARIANT_
|
|
|
|
LONG cp;
|
|
|
|
CancelModes();
|
|
StopGroupTyping();
|
|
|
|
if(!_fExtend && _cch) // Collapse selection to
|
|
{ // nearest whole Unit before
|
|
if(fCtrl) // cpMin
|
|
Expander(tomWord, FALSE, NULL, &cp, NULL);
|
|
Collapser(tomStart); // Collapse to cpMin
|
|
}
|
|
else // Not collapsing selection
|
|
{
|
|
if (!GetCp() || // Already at beginning of
|
|
!BypassHiddenText(tomBackward)) // 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); // treat as up arrow
|
|
}
|
|
if(fCtrl) // WordLeft
|
|
FindWordBreak(WB_MOVEWORDLEFT);
|
|
else // CharLeft
|
|
{
|
|
BackupCRLF();
|
|
SnapToCluster(-1);
|
|
}
|
|
}
|
|
|
|
_fCaretNotAtBOL = FALSE; // Caret always OK at BOL
|
|
Update(TRUE);
|
|
return TRUE;
|
|
}
|
|
|
|
/*
|
|
* CTxtSelection::Right(fCtrl)
|
|
*
|
|
* @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)
|
|
{
|
|
TRACEBEGIN(TRCSUBSYSSEL, TRCSCOPEINTERN, "CTxtSelection::Right");
|
|
|
|
_TEST_INVARIANT_
|
|
|
|
LONG cchText;
|
|
LONG cp;
|
|
|
|
CancelModes();
|
|
StopGroupTyping();
|
|
|
|
if(!_fExtend && _cch) // Collapse selection to
|
|
{ // nearest whole Unit after
|
|
if(fCtrl) // cpMost
|
|
Expander(tomWord, FALSE, NULL, NULL, &cp);
|
|
Collapser(tomEnd);
|
|
}
|
|
else // Not collapsing selection
|
|
{
|
|
cchText = _fExtend ? GetTextLength() : GetAdjustedTextLength();
|
|
if (GetCp() >= cchText || // Already at end of story
|
|
!BypassHiddenText(tomForward))
|
|
{
|
|
Beep(); // Tell the user
|
|
return FALSE;
|
|
}
|
|
if(IsInOutlineView() && _fSelHasEOP) // If outline view with EOP
|
|
return Down(FALSE); // Treat as down arrow
|
|
if(fCtrl) // WordRight
|
|
FindWordBreak(WB_MOVEWORDRIGHT);
|
|
else // CharRight
|
|
{
|
|
AdvanceCRLF();
|
|
SnapToCluster();
|
|
}
|
|
}
|
|
|
|
_fCaretNotAtBOL = _fExtend; // If extending to EOL, need
|
|
Update(TRUE); // TRUE to get _xCaretReally
|
|
return TRUE; // at EOL
|
|
}
|
|
|
|
/*
|
|
* CTxtSelection::Up(fCtrl)
|
|
*
|
|
* @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 _xCaretPosition (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)
|
|
{
|
|
TRACEBEGIN(TRCSUBSYSSEL, TRCSCOPEINTERN, "CTxtSelection::Up");
|
|
|
|
_TEST_INVARIANT_
|
|
|
|
LONG cchSave = _cch; // Save starting position for
|
|
LONG cpSave = GetCp(); // change check
|
|
BOOL fCollapse = _cch && !_fExtend; // Collapse nondegenerate sel
|
|
BOOL fPTNotAtEnd;
|
|
CLinePtr rp(_pdp);
|
|
LONG xCaretReally = _xCaretReally; // Save desired caret x pos
|
|
|
|
CancelModes();
|
|
StopGroupTyping();
|
|
|
|
if(fCollapse) // Collapse selection at cpMin
|
|
{
|
|
Collapser(tomTrue);
|
|
_fCaretNotAtBOL = FALSE; // Selections can't begin at
|
|
} // EOL
|
|
rp.RpSetCp(GetCp(), _fCaretNotAtBOL); // Initialize line ptr
|
|
|
|
if(fCtrl) // Move to beginning of para
|
|
{
|
|
if(!fCollapse && // If no selection collapsed
|
|
rp > 0 && !rp.RpGetIch()) // and are at BOL,
|
|
{ // backup to prev BOL to make
|
|
rp--; // sure we move to prev. para
|
|
Advance(-rp->_cch);
|
|
}
|
|
Advance(rp.FindParagraph(FALSE)); // Go to beginning of para
|
|
_fCaretNotAtBOL = FALSE; // Caret always OK at BOL
|
|
}
|
|
else // Move up a line
|
|
{ // If on first line, can't go
|
|
fPTNotAtEnd = !CheckPlainTextFinalEOP();// up
|
|
if(rp <= 0 && fPTNotAtEnd)
|
|
{
|
|
//if(!_fExtend)// &&_pdp->GetYScroll())
|
|
UpdateCaret(TRUE); // Be sure caret in view
|
|
}
|
|
else
|
|
{
|
|
LONG cch;
|
|
BOOL fSelHasEOPInOV = IsInOutlineView() && _fSelHasEOP;
|
|
if(fSelHasEOPInOV && _cch > 0)
|
|
{
|
|
rp.AdjustBackward();
|
|
cch = rp->_cch;
|
|
rp.AdvanceCp(-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.RpGetIch();
|
|
rp--;
|
|
}
|
|
cch += rp->_cch;
|
|
}
|
|
Advance(-cch); // Move to previous BOL
|
|
if(fSelHasEOPInOV && !_fSelHasEOP) // If sel had EOP but doesn't
|
|
{ // after Advance, must be IP
|
|
Assert(!_cch); // Suppress restore of
|
|
xCaretReally = -1; // _xCaretReally
|
|
}
|
|
else if(!SetXPosition(xCaretReally, rp))// Set this cp corresponding
|
|
Set(cpSave, cchSave); // to xCaretReally here, but
|
|
} // agree on Down()
|
|
}
|
|
|
|
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);
|
|
|
|
Beep(); // Nothing changed, so beep
|
|
return FALSE;
|
|
}
|
|
|
|
Update(TRUE); // Update and then restore
|
|
if(!_cch && !fCtrl && xCaretReally >= 0) // _xCaretReally conditionally
|
|
_xCaretReally = xCaretReally; // Need to use _cch instead of
|
|
// cchSave in case of collapse
|
|
return TRUE;
|
|
}
|
|
|
|
/*
|
|
* CTxtSelection::Down(fCtrl)
|
|
*
|
|
* @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 _xCaretPosition (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)
|
|
{
|
|
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
|
|
CLinePtr rp(_pdp);
|
|
LONG xCaretReally = _xCaretReally; // Save _xCaretReally
|
|
|
|
CancelModes();
|
|
StopGroupTyping();
|
|
|
|
if(fCollapse) // Collapse at cpMost
|
|
{
|
|
Collapser(tomEnd);
|
|
_fCaretNotAtBOL = TRUE; // Selections can't end at BOL
|
|
}
|
|
|
|
rp.RpSetCp(GetCp(), _fCaretNotAtBOL);
|
|
if(fCtrl) // Move to next para
|
|
{
|
|
Advance(rp.FindParagraph(TRUE)); // Go to end of para
|
|
if(IsInOutlineView() && !BypassHiddenText(tomForward))
|
|
SetCp(cpSave);
|
|
else
|
|
_fCaretNotAtBOL = FALSE; // Next para is never at EOL
|
|
}
|
|
else if(_pdp->WaitForRecalcIli(rp + 1)) // Go to next line
|
|
{
|
|
LONG cch;
|
|
BOOL fSelHasEOPInOV = IsInOutlineView() && _fSelHasEOP;
|
|
if(fSelHasEOPInOV && _cch < 0)
|
|
cch = rp.FindParagraph(TRUE);
|
|
else
|
|
{
|
|
cch = rp.GetCchLeft(); // Advance selection to end
|
|
rp++; // of current line
|
|
}
|
|
Advance(cch);
|
|
if(fSelHasEOPInOV && !_fSelHasEOP) // If sel had EOP but doesn't
|
|
{ // after Advance, must be IP
|
|
Assert(!_cch); // Suppress restore of
|
|
xCaretReally = -1; // _xCaretReally
|
|
}
|
|
else if(!SetXPosition(xCaretReally, rp))// Set *this to cp <--> x
|
|
Set(cpSave, cchSave); // If failed, restore sel
|
|
}
|
|
else if(!_fExtend) // No more lines to pass
|
|
// && _pdp->GetYScroll() + _pdp->GetViewHeight() < _pdp->GetHeight())
|
|
{
|
|
if (!IsRich() && _pdp->IsMultiLine() && // Plain-text, multiline
|
|
!_fCaretNotAtBOL) // control with caret OK
|
|
{ // at BOL
|
|
cch = Advance(rp.GetCchLeft()); // Advance selection to end
|
|
if(!_rpTX.IsAfterEOP()) // If control doesn't end
|
|
Advance(-cch); // 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);
|
|
|
|
Beep(); // Nothing changed, so beep
|
|
return FALSE;
|
|
}
|
|
|
|
Update(TRUE); // Update and then
|
|
if(!_cch && !fCtrl && xCaretReally >= 0) // restore _xCaretReally
|
|
_xCaretReally = xCaretReally; // Need to use _cch instead of
|
|
return TRUE; // cchSave in case of collapse
|
|
}
|
|
|
|
/*
|
|
* CTxtSelection::SetXPosition(xCaret, rp)
|
|
*
|
|
* @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::SetXPosition (
|
|
LONG xCaret, //@parm Desired horizontal coordinate
|
|
CLinePtr& rp) //@parm Line ptr identifying line to check
|
|
{
|
|
TRACEBEGIN(TRCSUBSYSSEL, TRCSCOPEINTERN, "CTxtSelection::SetXPosition");
|
|
|
|
_TEST_INVARIANT_
|
|
|
|
LONG cch = 0;
|
|
CMeasurer me(_pdp, *this);
|
|
|
|
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)
|
|
Advance(cch);
|
|
if(fSelHasEOP)
|
|
return TRUE;
|
|
if(cch)
|
|
me.Advance(cch);
|
|
}
|
|
|
|
POINT pt = {xCaret, 0};
|
|
CDispDim dispdim;
|
|
HITTEST hit;
|
|
cch = rp->CchFromXpos(me, pt, &dispdim, &hit);// Move out from start of line
|
|
if(!_fExtend && cch == rp->_cch && // Not extending, at EOL,
|
|
rp->_cchEOP) // and have EOP:
|
|
{ // backup before EOP
|
|
cch += me._rpTX.BackupCpCRLF(); // Note: me._rpCF/_rpPF
|
|
} // are now inconsistent
|
|
SetCp(me.GetCp()); // but doesn't matter since
|
|
_fCaretNotAtBOL = cch != 0; // me.GetCp() doesn't care
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
/*
|
|
* CTxtSelection::GetXCaretReally()
|
|
*
|
|
* @mfunc
|
|
* Get _xCaretReally - horizontal scrolling + left margin
|
|
*
|
|
* @rdesc
|
|
* x caret really
|
|
*/
|
|
LONG CTxtSelection::GetXCaretReally()
|
|
{
|
|
TRACEBEGIN(TRCSUBSYSSEL, TRCSCOPEINTERN, "CTxtSelection::GetXCaretReally");
|
|
|
|
_TEST_INVARIANT_
|
|
|
|
RECT rcView;
|
|
|
|
_pdp->GetViewRect(rcView);
|
|
|
|
return _xCaretReally - _pdp->GetXScroll() + rcView.left;
|
|
}
|
|
|
|
/*
|
|
* CTxtSelection::Home(fCtrl)
|
|
*
|
|
* @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)
|
|
{
|
|
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);
|
|
else
|
|
{
|
|
CLinePtr rp(_pdp);
|
|
|
|
if(_cch && !_fExtend) // Collapse at cpMin
|
|
{
|
|
Collapser(tomStart);
|
|
_fCaretNotAtBOL = FALSE; // Selections can't start at
|
|
} // EOL
|
|
|
|
rp.RpSetCp(GetCp(), _fCaretNotAtBOL); // Define line ptr for
|
|
|
|
Advance(-rp.RpGetIch()); // 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;
|
|
return TRUE;
|
|
}
|
|
|
|
/*
|
|
* CTxtSelection::End(fCtrl)
|
|
*
|
|
* @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)
|
|
{
|
|
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());
|
|
_fCaretNotAtBOL = FALSE;
|
|
goto Exit;
|
|
}
|
|
else if(!_fExtend && _cch) // Collapse at cpMost
|
|
{
|
|
Collapser(tomEnd);
|
|
_fCaretNotAtBOL = TRUE; // Selections can't end at BOL
|
|
}
|
|
|
|
rp.RpSetCp(GetCp(), _fCaretNotAtBOL); // Initialize line ptr
|
|
|
|
cch = rp->_cch; // Default target pos in line
|
|
Advance(cch - rp.RpGetIch()); // Move active end to EOL
|
|
|
|
if(!_fExtend && rp->_cchEOP && _rpTX.IsAfterEOP())// Not extending and have EOP:
|
|
cch += BackupCRLF(); // 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)
|
|
*
|
|
* @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)
|
|
{
|
|
TRACEBEGIN(TRCSUBSYSSEL, TRCSCOPEINTERN, "CTxtSelection::PageUp");
|
|
|
|
_TEST_INVARIANT_
|
|
|
|
const LONG cchSave = _cch;
|
|
const LONG cpSave = GetCp();
|
|
LONG xCaretReally = _xCaretReally;
|
|
|
|
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); // text for SL
|
|
_fCaretNotAtBOL = FALSE;
|
|
}
|
|
else if(_pdp->GetFirstVisibleCp() == 0) // PgUp in top Pg: move to
|
|
{ // start of document
|
|
SetCp(0);
|
|
_fCaretNotAtBOL = FALSE;
|
|
}
|
|
else // PgUp with scrolling to go
|
|
{ // Scroll up one windowful
|
|
ScrollWindowful(SB_PAGEUP); // 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
|
|
_xCaretReally = xCaretReally; // up/down
|
|
return TRUE;
|
|
}
|
|
|
|
/*
|
|
* CTxtSelection::PageDown(fCtrl)
|
|
*
|
|
* @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)
|
|
{
|
|
TRACEBEGIN(TRCSUBSYSSEL, TRCSCOPEINTERN, "CTxtSelection::PageDown");
|
|
|
|
_TEST_INVARIANT_
|
|
|
|
const LONG cchSave = _cch;
|
|
LONG cpMostVisible;
|
|
const LONG cpSave = GetCp();
|
|
POINT pt;
|
|
CLinePtr rp(_pdp);
|
|
LONG xCaretReally = _xCaretReally;
|
|
|
|
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
|
|
RECT rcView;
|
|
|
|
SetCp(cpMostVisible);
|
|
|
|
if(_pdp->PointFromTp(*this, NULL, TRUE, pt, &rp, TA_TOP) < 0)
|
|
return FALSE;
|
|
|
|
_fCaretNotAtBOL = TRUE;
|
|
|
|
_pdp->GetViewRect(rcView);
|
|
|
|
if(rp > 0 && pt.y + rp->_yHeight > rcView.bottom)
|
|
{
|
|
Advance(-rp->_cch);
|
|
rp--;
|
|
}
|
|
|
|
if(!_fExtend && !rp.GetCchLeft() && rp->_cchEOP)
|
|
{
|
|
BackupCRLF(); // After backing up over EOP,
|
|
_fCaretNotAtBOL = FALSE; // caret can't be at EOL
|
|
}
|
|
}
|
|
else if(cpMostVisible == GetTextLength())
|
|
{ // Move to end of text
|
|
SetCp(GetTextLength());
|
|
_fCaretNotAtBOL = !_rpTX.IsAfterEOP();
|
|
}
|
|
else
|
|
{
|
|
if(!ScrollWindowful(SB_PAGEDOWN)) // Scroll down 1 windowful
|
|
return FALSE;
|
|
}
|
|
|
|
if(GetCp() == cpSave && _cch == cchSave) // Beep if no change
|
|
{
|
|
Beep();
|
|
return FALSE;
|
|
}
|
|
|
|
Update(TRUE);
|
|
_xCaretReally = xCaretReally;
|
|
return TRUE;
|
|
}
|
|
|
|
/*
|
|
* CTxtSelection::ScrollWindowful(wparam)
|
|
*
|
|
* @mfunc
|
|
* Sroll up or down a windowful
|
|
*
|
|
* @rdesc
|
|
* TRUE iff movement occurred
|
|
*/
|
|
BOOL CTxtSelection::ScrollWindowful (
|
|
WPARAM wparam) //@parm SB_PAGEDOWN or SB_PAGEUP
|
|
{
|
|
TRACEBEGIN(TRCSUBSYSSEL, TRCSCOPEINTERN, "CTxtSelection::ScrollWindowful");
|
|
// Scroll windowful
|
|
_TEST_INVARIANT_
|
|
|
|
POINT 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);
|
|
|
|
// Real caret postion is now at beginning of line
|
|
_xCaretReally = 0;
|
|
}
|
|
|
|
if(_pdp->PointFromTp(*this, NULL, _fCaretNotAtBOL, pt, &rp, TA_TOP) < 0)
|
|
return FALSE;
|
|
|
|
// The point is visible so use that
|
|
pt.x = _xCaretReally;
|
|
pt.y += rp->_yHeight / 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 (BOOL fChangedFont)
|
|
*
|
|
* @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, & auto
|
|
ped->IsAutoKeyboard() && // kbd, check kbd change
|
|
!ped->_fIMEInProgress && // not in IME composition and
|
|
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 bCharSet = pCF->_bCharSet;
|
|
|
|
if (!IsFECharSet(bCharSet) &&
|
|
(bCharSet != ANSI_CHARSET || !IsFELCID((WORD)GetKeyboardLayout(0))) &&
|
|
!fc().GetInfoFlags(pCF->_iFont).fNonBiDiAscii)
|
|
{
|
|
// Don't do auto-kbd inside FE or single-codepage ASCII font.
|
|
W32->CheckChangeKeyboardLayout(bCharSet);
|
|
}
|
|
}
|
|
}
|
|
|
|
/*
|
|
* CTxtSelection::CheckChangeFont (hkl, cpg, iSelFormat, dwCharFlag)
|
|
*
|
|
* @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 cpg, //@parm code page to use (could be ANSI for FE with IME off)
|
|
LONG iSelFormat, //@parm Format to use for selection case
|
|
DWORD dwCharFlag) //@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 && !dwCharFlag) // 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._bCharSet = GetCharSet(cpg);
|
|
|
|
if (pCF->_lcid == wLangID && CF._bCharSet == pCF->_bCharSet)
|
|
{
|
|
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 ((!dwCharFlag || dwCharFlag & 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(
|
|
cpg,
|
|
CF._bCharSet,
|
|
CF._iFont,
|
|
CF._yHeight,
|
|
CF._bPitchAndFamily,
|
|
iCurrentFormat,
|
|
iMatchFont))
|
|
{
|
|
if (W32->IsFECodePage(cpg) || cpg == CP_THAI)
|
|
ped->OrCharFlags(GetFontSig((WORD)cpg) << 8);
|
|
|
|
// FUTURE: turn current fBIDI into fRTL and make
|
|
// fBIDI = (fRTL | fARABIC | fHEBREW). Then can combine following if
|
|
// with preceding if
|
|
else if (W32->IsBiDiCodePage(cpg))
|
|
ped->OrCharFlags(fBIDI | (GetFontSig((WORD)cpg) << 8));
|
|
|
|
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);
|
|
|
|
#ifdef LINESERVICES
|
|
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 (
|
|
TCHAR 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
|
|
{
|
|
TRACEBEGIN(TRCSUBSYSSEL, TRCSCOPEINTERN, "CTxtSelection::PutChar");
|
|
|
|
_TEST_INVARIANT_
|
|
|
|
BOOL fOver = dwFlags & 1;
|
|
CTxtEdit *ped = GetPed();
|
|
|
|
SetExtend(FALSE);
|
|
|
|
if(ch == TAB && GetPF()->InTable())
|
|
{
|
|
LONG cpMin, cpMost;
|
|
LONG cch = GetRange(cpMin, cpMost);
|
|
LONG cch0 = 0;
|
|
LONG iDir = GetKeyboardFlags() & SHIFT ? -1 : 1;
|
|
if(_fSelHasEOP) // If selection has an EOP
|
|
{ // collapse to cpMin and
|
|
Collapser(tomStart); // go forward
|
|
iDir = 1;
|
|
if(!GetPF()->InTable())
|
|
{
|
|
Update(TRUE);
|
|
return TRUE;
|
|
}
|
|
}
|
|
if((_cch ^ iDir) < 0) // If at cpMost going back or
|
|
FlipRange(); // at cpMin going forward,
|
|
// switch active end
|
|
CRchTxtPtr rtp(*this);
|
|
|
|
CancelModes();
|
|
StopGroupTyping();
|
|
|
|
if(iDir < 0 || _cch)
|
|
rtp.Advance(-1);
|
|
|
|
// Scan for start/end of next/prev cell
|
|
do
|
|
{
|
|
ch = rtp.GetChar();
|
|
} while(rtp.Advance(iDir) && ch != CELL && rtp.GetPF()->InTable());
|
|
|
|
if(ch != CELL)
|
|
{
|
|
if(iDir < 0)
|
|
return FALSE;
|
|
insertRow: rtp.BackupCRLF(); // Tabbed past end of table:
|
|
Set(rtp.GetCp(), 0); // insert new row
|
|
return InsertEOP(publdr);
|
|
}
|
|
if(iDir > 0) // Check for IP between CELL
|
|
{ // and CR at row end
|
|
if(rtp.GetChar() == CR)
|
|
rtp.AdvanceCRLF(); // Bypass row end
|
|
}
|
|
for(cch = 0; // Determine cchSel
|
|
(ch = rtp.GetChar()) != CELL && rtp.GetPF()->InTable();
|
|
cch += iDir)
|
|
{
|
|
cch0 = rtp.Advance(iDir);
|
|
if(!cch0)
|
|
break;
|
|
}
|
|
if(iDir > 0) // Tabbing forward
|
|
{
|
|
if(ch != CELL) // Went past end of table
|
|
goto insertRow; // so go insert new row
|
|
}
|
|
else if(cch) // Tabbing backward with
|
|
{ // nondegenerate selection
|
|
if(cch0) // Didn't run into start of story
|
|
{
|
|
rtp.Advance(1); // Advance over CELL. Then if at
|
|
if(rtp.GetChar() == CR) // end of row, advance over EOP
|
|
cch += rtp.AdvanceCRLF();
|
|
}
|
|
else // Ran into start of story
|
|
cch -= 1; // Include another char since
|
|
} // broke out of for loop
|
|
else if(cpMin > 1) // Handles tabbing back over
|
|
rtp.Advance(1); // adjacent null cells
|
|
|
|
Set(rtp.GetCp(), cch);
|
|
_fCaretNotAtBOL = FALSE;
|
|
Update(TRUE);
|
|
return TRUE;
|
|
}
|
|
|
|
// 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
|
|
|
|
|
|
// Some languages, e.g., Thai, 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(&ch, 1, fOver, &fBaseChar))
|
|
{
|
|
SetDualFontMode(FALSE); // Ignore bad sequence
|
|
return FALSE;
|
|
}
|
|
|
|
|
|
DWORD bCharSetDefault = ped->GetCharFormat(-1)->_bCharSet;
|
|
DWORD dw = GetCharFlags(ch, bCharSetDefault);
|
|
ped->OrCharFlags(dw, 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 bCharSet = CF._bCharSet;
|
|
BOOL fRestoreCF = FALSE;
|
|
|
|
if(ped->IsAutoFont())
|
|
{
|
|
UINT uKbdcpg = 0;
|
|
BOOL fFEKbd = FALSE;
|
|
|
|
if(!(ped->_fIMEInProgress))
|
|
uKbdcpg = CheckSynchCharSet(dw);
|
|
|
|
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 && dw == fHILATIN1)
|
|
{
|
|
// Use Ansi font if based font or current font is FE.
|
|
if(IsFECharSet(bCharSetDefault) || IsFECharSet(bCharSet))
|
|
SetupDualFont(); // Use Ansi font for HiAnsi
|
|
}
|
|
else if (dw & fASCII && (GetCharSetMask(TRUE) & fASCII) == fASCII)
|
|
{
|
|
CCharFormat CFDefault = *ped->GetCharFormat(-1);
|
|
if (IsRich() && IsBiDiCharSet(CFDefault._bCharSet)
|
|
&& !W32->IsBiDiCodePage(uKbdcpg))
|
|
CFDefault._bCharSet = ANSI_CHARSET;
|
|
|
|
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() && bCharSet != ANSI_CHARSET &&
|
|
(ped->_fDualFont && bCharSet != SYMBOL_CHARSET &&
|
|
(((fFEKbd = (ped->_fIMEInProgress || W32->IsFECodePage(uKbdcpg))) && ch < 127 && IsAlpha(ch)) ||
|
|
(!fFEKbd && IsFECharSet(ped->GetCharFormat(GetiFormat())->_bCharSet) && 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
|
|
|
|
SetExtend(TRUE); // Tell Advance() to
|
|
if(fOver && fBaseChar) // select chars
|
|
{ // 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();
|
|
SnapToCluster();
|
|
|
|
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.AdvanceCp(-1);
|
|
if(tp.GetCp() && tp.FindWordBreak(WB_ISDELIMITER))// Delimeter at sel end
|
|
FindWordBreak(WB_LEFTBREAK); // Backspace over it, etc.
|
|
}
|
|
|
|
_fIsChar = TRUE; // Tell CDisplay::UpdateView
|
|
_fDontUpdateFmt = TRUE; // we're PuttingChar()
|
|
LONG iFormat = GetiFormat(); // Save current value
|
|
AdjustEndEOP(NEWCHARS);
|
|
if(!_cch)
|
|
Set_iCF(iFormat);
|
|
_fDontUpdateFmt = FALSE;
|
|
|
|
if(ped->_fUpperCase)
|
|
CharUpperBuff(&ch, 1);
|
|
else if(ped->_fLowerCase)
|
|
CharLowerBuff(&ch, 1);
|
|
|
|
{
|
|
CFreezeDisplay fd(GetPed()->_pdp);
|
|
|
|
if(!_cch)
|
|
{
|
|
if(bCharSet == DEFAULT_CHARSET)
|
|
{
|
|
CCharFormat CFTemp;
|
|
|
|
if (dw & fFE) // Find a better charset for FE char
|
|
CFTemp._bCharSet = MatchFECharSet(dw, GetFontSignatureFromFace(CF._iFont));
|
|
else
|
|
CFTemp._bCharSet = GetCharSet(W32->ScriptIndexFromFontSig(dw >> 8), NULL);
|
|
|
|
SetCharFormat(&CFTemp, SCF_NOKBUPDATE, NULL, CFM_CHARSET, CFM2_NOCHARSETCHECK);
|
|
}
|
|
else if(bCharSet == SYMBOL_CHARSET && dwFlags & KBD_CHAR && ch > 255)
|
|
{
|
|
UINT cpg = GetKeyboardCodePage(0); // If 125x, convert char
|
|
if(IN_RANGE(1250, cpg, 1257)) // back to ANSI for storing
|
|
{ // SYMBOL_CHARSET chars
|
|
BYTE ach;
|
|
WCTMB(cpg, 0, &ch, 1, (char *)&ach, 1, NULL, NULL, NULL);
|
|
ch = ach;
|
|
}
|
|
}
|
|
}
|
|
if(dwFlags & KBD_CHAR || ped->_fIMEInProgress || bCharSet == SYMBOL_CHARSET)
|
|
ReplaceRange(1, &ch, publdr, SELRR_REMEMBERRANGE);
|
|
else
|
|
CleanseAndReplaceRange(1, &ch, TRUE, publdr, NULL);
|
|
}
|
|
|
|
_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);
|
|
|
|
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::BypassHiddenText(iDir)
|
|
*
|
|
* @mfunc
|
|
* Bypass hidden text forward/backward for iDir positive/negative
|
|
*
|
|
* @rdesc
|
|
* TRUE if succeeded or no hidden text. FALSE if at document limit
|
|
* (end/start for Direction positive/negative) or if hidden text between
|
|
* cp and that limit.
|
|
*/
|
|
BOOL CTxtSelection::BypassHiddenText(
|
|
LONG iDir)
|
|
{
|
|
if(iDir > 0)
|
|
_rpCF.AdjustForward();
|
|
else
|
|
_rpCF.AdjustBackward();
|
|
|
|
if(!(GetPed()->GetCharFormat(_rpCF.GetFormat())->_dwEffects & CFE_HIDDEN))
|
|
return TRUE;
|
|
|
|
BOOL fExtendSave = _fExtend;
|
|
SetExtend(FALSE);
|
|
|
|
CCFRunPtr rp(*this);
|
|
LONG cch = (iDir > 0)
|
|
? rp.FindUnhiddenForward() : rp.FindUnhiddenBackward();
|
|
|
|
BOOL bRet = !rp.IsHidden(); // Note whether still hidden
|
|
if(bRet) // It isn't:
|
|
Advance(cch); // bypass hidden text
|
|
SetExtend(fExtendSave);
|
|
return bRet;
|
|
}
|
|
|
|
/*
|
|
* CTxtSelection::InsertEOP(publdr)
|
|
*
|
|
* @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;
|
|
BOOL fResult = FALSE;
|
|
LONG i, iFormatSave;
|
|
WCHAR szBlankRow[MAX_TAB_STOPS + 1] = {CR, LF, 0};
|
|
WCHAR * pch = szBlankRow;
|
|
BOOL fPFInTable;
|
|
WORD wPFNumbering;
|
|
BYTE bPFTabCount;
|
|
BOOL fPrevPFInTable = TRUE;
|
|
|
|
{
|
|
const CParaFormat *pPF = GetPF(); // Get paragraph format
|
|
|
|
// pPF may become invalid after SetParaFormat. So, we need
|
|
// to save up necessary data from pPF.
|
|
fPFInTable = pPF->InTable();
|
|
wPFNumbering = pPF->_wNumbering;
|
|
bPFTabCount = pPF->_bTabCount;
|
|
}
|
|
|
|
if(ch && (GetPed()->fUseCRLF() || IN_RANGE(VT, ch, FF)))
|
|
{
|
|
szBlankRow[0] = ch;
|
|
cchEOP = 1;
|
|
}
|
|
|
|
_fEOP = TRUE;
|
|
|
|
if(publdr)
|
|
{
|
|
publdr->StartGroupTyping();
|
|
publdr->SetNameID(UID_TYPING);
|
|
}
|
|
|
|
if(fPFInTable)
|
|
{
|
|
SetExtend(FALSE); // Don't want extended selection
|
|
if(!_cch && !_rpPF.GetIch())
|
|
{
|
|
const CParaFormat *pPFPrev; // Get previous paragraph format
|
|
|
|
_rpPF.AdjustBackward();
|
|
pPFPrev = GetPed()->GetParaFormat(_rpPF.GetFormat());
|
|
fPrevPFInTable = (pPFPrev->_wEffects & PFE_TABLE) ? TRUE : FALSE;
|
|
|
|
_rpPF.AdjustForward();
|
|
}
|
|
|
|
if(fPrevPFInTable)
|
|
{
|
|
if(GetCp() && !_rpTX.IsAfterEOP())
|
|
{
|
|
while(!_rpTX.IsAtEOP() && Advance(1))
|
|
;
|
|
*pch++ = CR;
|
|
}
|
|
for(i = bPFTabCount; i--; *pch++ = CELL)
|
|
;
|
|
*pch++ = CR;
|
|
pch = szBlankRow;
|
|
cchEOP = bPFTabCount + 1;
|
|
}
|
|
}
|
|
if(!GetCch() && wPFNumbering && _rpTX.IsAfterEOP())
|
|
{
|
|
// Two enters in a row turn off numbering
|
|
CParaFormat PF;
|
|
PF._wNumbering = 0;
|
|
PF._dxOffset = 0;
|
|
SetParaFormat(&PF, publdr, PFM_NUMBERING | PFM_OFFSET);
|
|
}
|
|
|
|
if(CheckTextLength(cchEOP)) // If cchEOP chars can fit...
|
|
{
|
|
CFreezeDisplay fd(GetPed()->_pdp);
|
|
iFormatSave = Get_iCF(); // Save CharFormat before EOP
|
|
// Get_iCF() does AddRefFormat()
|
|
if(wPFNumbering) // Bullet paragraph: EOP has
|
|
{ // desired bullet CharFormat
|
|
CFormatRunPtr rpCF(_rpCF); // Get run pointers for locating
|
|
CTxtPtr rpTX(_rpTX); // EOP CharFormat
|
|
|
|
rpCF.AdvanceCp(rpTX.FindEOP(tomForward));
|
|
rpCF.AdjustBackward();
|
|
Set_iCF(rpCF.GetFormat()); // Set _iFormat to EOP CharFormat
|
|
}
|
|
|
|
// Put in appropriate EOP mark
|
|
fResult = ReplaceRange(cchEOP, pch, // If Shift-Enter, insert VT
|
|
publdr, SELRR_REMEMBERRANGE, NULL, RR_NO_EOR_CHECK);
|
|
|
|
Set_iCF(iFormatSave); // Restore _iFormat if changed
|
|
ReleaseFormats(iFormatSave, -1); // Release iFormatSave
|
|
if(fPFInTable)
|
|
{
|
|
if(!fPrevPFInTable) // Turn off PFE_TABLE bit of
|
|
{ // EOP just inserted
|
|
CParaFormat PF;
|
|
_cch = cchEOP; // Select EOP just inserted
|
|
PF._wEffects = 0;
|
|
SetParaFormat(&PF, publdr, PFM_TABLE);
|
|
_cch = 0; // Back to insertion point
|
|
}
|
|
else if(cchEOP > 1)
|
|
{
|
|
if(*pch == CR)
|
|
cchEOP--;
|
|
Advance(-cchEOP);
|
|
_fCaretNotAtBOL = FALSE;
|
|
Update(FALSE);
|
|
}
|
|
}
|
|
}
|
|
return fResult;
|
|
}
|
|
|
|
/*
|
|
* 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);
|
|
|
|
if(publdr)
|
|
{
|
|
publdr->StopGroupTyping();
|
|
publdr->SetNameID(UID_DELETE);
|
|
}
|
|
|
|
SetExtend(TRUE); // Setup to change selection
|
|
if(fCtrl)
|
|
{ // Delete to word end from cpMin
|
|
Collapser(tomStart); // (won't necessarily repaint,
|
|
FindWordBreak(WB_MOVEWORDRIGHT); // since won't delete it)
|
|
}
|
|
|
|
if(!_cch) // No selection
|
|
{
|
|
mode = SELRR_REMEMBERCPMIN;
|
|
if(!AdvanceCRLF()) // Try to select char at IP
|
|
{ // End of text, nothing to delete
|
|
Beep(); // Only executed in plain text,
|
|
return FALSE; // since else there's always
|
|
} // a final EOP to select
|
|
SnapToCluster();
|
|
_fMoveBack = TRUE; // Convince Update_iFormat() to
|
|
_fUseiFormat = TRUE; // use forward format
|
|
}
|
|
AdjustEndEOP(NONEWCHARS);
|
|
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 = SELRR_REMEMBERRANGE;
|
|
|
|
AssertSz(!GetPed()->TxGetReadOnly(),
|
|
"CTxtSelection::Backspace(): read only");
|
|
|
|
_fCaretNotAtBOL = FALSE;
|
|
|
|
if(publdr)
|
|
{
|
|
publdr->SetNameID(UID_TYPING);
|
|
|
|
if(_cch || fCtrl)
|
|
publdr->StopGroupTyping();
|
|
}
|
|
|
|
SetExtend(TRUE); // Set up to extend range
|
|
if(fCtrl) // Delete word left
|
|
{
|
|
if(!GetCpMin()) // Beginning of story: no word
|
|
{ // to delete
|
|
Beep();
|
|
return FALSE;
|
|
}
|
|
Collapser(tomStart); // First collapse to cpMin
|
|
if(!BypassHiddenText(tomBackward))
|
|
goto beep;
|
|
FindWordBreak(WB_MOVEWORDLEFT); // Extend word left
|
|
}
|
|
else if(!_cch) // Empty selection
|
|
{ // Try to select previous char
|
|
if (!BypassHiddenText(tomBackward) ||
|
|
!BackupCRLF(FALSE))
|
|
{ // Nothing to delete
|
|
beep: Beep();
|
|
return FALSE;
|
|
}
|
|
mode = SELRR_REMEMBERENDIP;
|
|
|
|
if(publdr)
|
|
publdr->StartGroupTyping();
|
|
}
|
|
ReplaceRange(0, NULL, publdr, mode); // Delete selection
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
/*
|
|
* CTxtSelection::ReplaceRange(cchNew, pch, publdr, SELRRMode)
|
|
*
|
|
* @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 TCHAR *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 cchOld;
|
|
LONG cchText = GetTextLength();
|
|
LONG cpFirstRecalc;
|
|
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,
|
|
(!_cch && *pch != CR && // Don't insert bet CELL & CR
|
|
CRchTxtPtr::GetChar() == CR && GetPrevChar() == CELL && GetPF()->InTable() ||
|
|
_cch != cchText && (IsInOutlineView() && IsCollapsed() ||
|
|
IsHidden())))
|
|
{ // Don't insert into collapsed
|
|
Beep(); // or hidden region (should
|
|
return 0; // only happen if whole story
|
|
} // collapsed or hidden)
|
|
|
|
GetPed()->GetCallMgr()->SetSelectionChanged();
|
|
|
|
CheckTableSelection();
|
|
cchOld = 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) // For delete all, set
|
|
{ // up to choose Normal
|
|
fDeleteAll = TRUE; // or Heading 1
|
|
FlipRange();
|
|
fHeading = IsInOutlineView() && IsHeadingStyle(GetPF()->_sStyle);
|
|
}
|
|
|
|
cpSave = cpMin;
|
|
cpFirstRecalc = cpSave;
|
|
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
|
|
|
|
if(cchNew != cchNewSave)
|
|
{
|
|
Tracef(TRCSEVERR, "CRchTxtPtr::ReplaceRange(%ld, %ld, %ld) failed", GetCp(), cchOld, cchNew);
|
|
_fShowSelection = fUpdateView;
|
|
goto err;
|
|
}
|
|
|
|
// The cp should be at *end* (cpMost) of replaced range (it starts
|
|
// at cpMin of the prior range).
|
|
AssertSz(_cpSel == cpSave + cchNew && _cpSel <= cchText,
|
|
"CTxtSelection::ReplaceRange() - Wrong cp after replacement");
|
|
|
|
_fShowSelection = fUpdateView;
|
|
|
|
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)", cchOld, 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::CheckTableSelection()
|
|
*
|
|
* @mfunc
|
|
* Select whole cells if one or more CELLs are selected
|
|
*/
|
|
void CTxtSelection::CheckTableSelection ()
|
|
{
|
|
if(!_fSelHasEOP && GetPF()->InTable()) // For now, don't let
|
|
{ // table CELLs be
|
|
LONG cpMin, cpMost; // deleted, unless in
|
|
CTxtPtr tp(_rpTX); // complete rows
|
|
|
|
GetRange(cpMin, cpMost);
|
|
if(_cch > 0)
|
|
tp.AdvanceCp(-_cch); // Start at cpMin
|
|
|
|
while(tp.GetCp() < cpMost)
|
|
{
|
|
if(tp.GetChar() == CELL) // Stop selection at CELL
|
|
{
|
|
Set(cpMin, cpMin - tp.GetCp());
|
|
UpdateSelection();
|
|
return;
|
|
}
|
|
tp.AdvanceCp(1);
|
|
}
|
|
}
|
|
}
|
|
|
|
/*
|
|
* CTxtSelection::SetCharFormat(pCF, fApplyToWord, 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().
|
|
*/
|
|
|
|
LONG cpMin, cpMost;
|
|
LONG cch = GetRange(cpMin, cpMost);;
|
|
BOOL fCheckKeyboard = (flags & SCF_NOKBUPDATE) == 0;
|
|
CTxtRange rg(GetPed());
|
|
CCharFormat CF;
|
|
|
|
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 bCharSet = pCF->_bCharSet;
|
|
|
|
// 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) || bCharSet == DEFAULT_CHARSET)
|
|
{
|
|
// Setup charset for DEFAULT_CHARSET or when the client only specifies
|
|
// facename
|
|
CF = *pCF;
|
|
CF._bCharSet = GetFirstAvailCharSet(GetFontSignatureFromFace(CF._iFont));
|
|
pCF = &CF;
|
|
}
|
|
|
|
dwMask2 |= CFM2_MATCHFONT; // Signal to match font charsets
|
|
#if 0
|
|
// Single byte 125x CharSet
|
|
CFreezeDisplay fd(_pdp); // Speed this up
|
|
|
|
CTxtPtr tp(GetPed(), cpMin);
|
|
CCharFormat CF = *pCF;
|
|
|
|
while(cpMin < cpMost)
|
|
{
|
|
BOOL fInCharSet = In125x(tp.GetChar(), pCF->_bCharSet);
|
|
|
|
while(fInCharSet == In125x(tp.GetChar(), pCF->_bCharSet) &&
|
|
tp.GetCp() < cpMost)
|
|
{
|
|
tp.AdvanceCp(1);
|
|
}
|
|
dwMask &= ~(CFM_FACE | CFM_CHARSET);
|
|
if(fInCharSet)
|
|
dwMask |= (CFM_FACE | CFM_CHARSET);
|
|
|
|
rg.SetRange(cpMin, tp.GetCp());
|
|
HRESULT hr1 = dwMask
|
|
? rg.SetCharFormat(&CF, flags | SCF_IGNORESELAE, publdr, dwMask, dwMask2)
|
|
: NOERROR;
|
|
hr = FAILED(hr) ? hr : hr1;
|
|
cpMin = tp.GetCp();
|
|
}
|
|
#endif
|
|
}
|
|
if(_cch)
|
|
{
|
|
// Selection is being set to a charformat
|
|
if (IsRich())
|
|
{
|
|
GetPed()->SetfSelChangeCharFormat();
|
|
}
|
|
|
|
// REVIEW (murrays): can _iFormat change if _cch != 0?
|
|
// It is OK to not update _iFormat for a non degenerate selection
|
|
// even if UI rules and word select have reduced it.
|
|
rg.SetRange(cpMin, cpMost);
|
|
hr = rg.SetCharFormat(pCF, flags, publdr, dwMask, dwMask2);
|
|
}
|
|
else
|
|
{
|
|
// But for a degenerate selection, _iFormat must be updated
|
|
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)
|
|
*
|
|
* @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
|
|
{
|
|
TRACEBEGIN(TRCSUBSYSSEL, TRCSCOPEINTERN, "CTxtSelection::SetParaFormat");
|
|
|
|
CFreezeDisplay fd(GetPed()->_pdp);
|
|
HRESULT hr;
|
|
|
|
if(publdr)
|
|
publdr->StopGroupTyping();
|
|
|
|
// Apply the format
|
|
hr = CTxtRange::SetParaFormat(pPF, publdr, dwMask);
|
|
|
|
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);
|
|
}
|
|
}
|
|
|
|
/*
|
|
* CTxtSelection::InitClickForAutWordSel (pt)
|
|
*
|
|
* @mfunc Init auto selection for click with shift key down
|
|
*
|
|
* @rdesc void
|
|
*/
|
|
void CTxtSelection::InitClickForAutWordSel(
|
|
const POINT 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 (_yHeightCaret), 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(_yHeightCaret, 512);
|
|
|
|
y = max(0, y);
|
|
|
|
// Caret shape reflects current charset
|
|
if(IsComplexKbdInstalled())
|
|
{
|
|
// Custom carets aren't italicized
|
|
fItalic = 0;
|
|
LCID lcid = GetKeyboardLCID();
|
|
|
|
dwCaretType = CARET_CUSTOM;
|
|
|
|
if (W32->IsBiDiLcid(lcid))
|
|
dwCaretType = CARET_CUSTOM | CARET_BIDI;
|
|
|
|
else if (PRIMARYLANGID(lcid) == LANG_THAI)
|
|
dwCaretType = CARET_CUSTOM | CARET_THAI;
|
|
|
|
else if (W32->IsIndicLcid(lcid))
|
|
dwCaretType = CARET_CUSTOM | CARET_INDIC;
|
|
}
|
|
else
|
|
fItalic = pCF->_dwEffects & CFE_ITALIC && _yHeightCaret > 15; //9 pt/15 pixels looks bad
|
|
|
|
INT dx = dxCaret;
|
|
DWORD dwCaretInfo = (_yHeightCaret << 16) | (dx << 8) | (dwCaretType << 4) |
|
|
(fItalic << 1) | !_cch;
|
|
|
|
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;
|
|
POINT ptStart, ptEnd;
|
|
|
|
GetRange(cpMin, cpMost);
|
|
|
|
CRchTxtPtr tp(ped, cpMin);
|
|
|
|
if (pdp->PointFromTp(tp, NULL, FALSE, ptStart, NULL, TA_TOP+TA_LEFT) != -1 &&
|
|
pdp->PointFromTp(tp, NULL, FALSE, ptEnd, NULL, TA_BOTTOM+TA_RIGHT) != -1)
|
|
{
|
|
// Destroy whatever caret bitmap we had previously
|
|
DeleteCaretBitmap(TRUE);
|
|
|
|
LONG iCharWidth = ptEnd.x - ptStart.x;
|
|
if (!ped->fUseLineServices())
|
|
{
|
|
const CCharFormat *pCF = tp.GetCF();
|
|
CLock lock;
|
|
HDC hdc = W32->GetScreenDC();
|
|
if(hdc)
|
|
{
|
|
LONG dypInch = MulDiv(GetDeviceCaps(hdc, LOGPIXELSY), _pdp->GetZoomNumerator(), _pdp->GetZoomDenominator());
|
|
CCcs *pccs = fc().GetCcs(pCF, dypInch);
|
|
if(pccs)
|
|
{
|
|
LONG iKorCharWidth;
|
|
if (pccs->Include(0xAC00, iKorCharWidth))
|
|
iCharWidth = iKorCharWidth;
|
|
pccs->Release();
|
|
}
|
|
}
|
|
}
|
|
|
|
ped->TxCreateCaret(0, iCharWidth, ptEnd.y - ptStart.y);
|
|
_fCaretCreated = TRUE;
|
|
ped->TxSetCaretPos(ptStart.x, ptStart.y);
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
// 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 == _yHeightCaret && (_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)
|
|
{
|
|
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;
|
|
}
|
|
}
|
|
}
|
|
_hbmpCaret = (HBITMAP)CreateBitmap(8, y, 1, 1, rgCaretBitMap);
|
|
}
|
|
}
|
|
|
|
ped->TxCreateCaret(_hbmpCaret, dx, (INT)_yHeightCaret);
|
|
_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 = _xCaret - xShift;
|
|
#ifdef Boustrophedon
|
|
//if(_pPF->_wEffects & PFE_BOUSTROPHEDON)
|
|
{
|
|
RECT rcView;
|
|
_pdp->GetViewRect(rcView, NULL);
|
|
xShift = rcView.right - xShift;
|
|
}
|
|
#endif
|
|
ped->TxSetCaretPos(xShift, (INT)_yCaret);
|
|
}
|
|
|
|
/*
|
|
* 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();
|
|
|
|
if(pundo)
|
|
pundo->StopGroupTyping();
|
|
}
|
|
|
|
/*
|
|
* CTxtSelection::SetupDualFont(ch)
|
|
*
|
|
* @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._bCharSet = ANSI_CHARSET;
|
|
CCFRunPtr rp(*this);
|
|
|
|
if (rp.GetPreferredFontInfo(
|
|
1252,
|
|
CF._bCharSet,
|
|
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
|
|
*
|
|
* @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 othewise 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->TxInvalidateRect(NULL, FALSE);
|
|
}
|
|
}
|
|
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;
|
|
}
|