windows-xp/Source/XPSP1/NT/windows/richedit/re30/select.cpp

/*
 *  @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;
}