archive
/
windows-xp
mirror of https://github.com/tongzx/nt5src
2
0
Fork 0
Code Issues Projects Releases Wiki Activity
Source code of Windows XP (NT5)
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
6 Commits
1 Branch
0 Tags
2.0 GiB
 
 
 
 
 
 
Tree: daad8a087a
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from 'daad8a087a'
${ noResults }
windows-xp/Source/XPSP1/NT/windows/richedit/re30/range.cpp

4349 lines
145 KiB
Raw Blame History

/*
* @doc INTERNAL
*
* @module RANGE.C - Implement the CTxtRange Class |
*
* This module implements the internal CTxtRange methods. See range2.c
* for the ITextRange methods
*
* Authors: <nl>
* Original RichEdit code: David R. Fulmer <nl>
* Christian Fortini <nl>
* Murray Sargent <nl>
*
* Revisions: <nl>
* AlexGo: update to runptr text ptr; floating ranges, multilevel undo
*
* Copyright (c) 1995-1998, Microsoft Corporation. All rights reserved.
*/
#include "_common.h"
#include "_range.h"
#include "_edit.h"
#include "_text.h"
#include "_rtext.h"
#include "_m_undo.h"
#include "_antievt.h"
#include "_disp.h"
#include "_uspi.h"
#include "_rtfconv.h"
#include "_txtbrk.h"
#include "_font.h"
#ifdef LINESERVICES
#include "_ols.h"
#endif
ASSERTDATA
TCHAR szEmbedding[] = {WCH_EMBEDDING, 0};
// =========================== Invariant stuff ======================================================
#define DEBUG_CLASSNAME CTxtRange
#include "_invar.h"
#ifdef DEBUG
BOOL
CTxtRange::Invariant( void ) const
{
LONG cpMin, cpMost;
GetRange(cpMin, cpMost);
Assert ( cpMin >= 0 );
Assert ( cpMin <= cpMost );
Assert ( cpMost <= GetTextLength() );
Assert ( cpMin != cpMost || cpMost <= GetAdjustedTextLength());
static LONG numTests = 0;
numTests++; // how many times we've been called.
// make sure the selections are in range.
return CRchTxtPtr::Invariant();
}
#endif
void CTxtRange::RangeValidateCp(LONG cp, LONG cch)
{
LONG cchText = GetAdjustedTextLength();
LONG cpOther = cp - cch; // Calculate cpOther with entry cp
_wFlags = FALSE; // This range isn't a selection
_iFormat = -1; // Set up the default format, which
// doesn't get AddRefFormat'd
ValidateCp(cpOther); // Validate requested other end
cp = GetCp(); // Validated cp
if(cp == cpOther && cp > cchText) // IP cannot follow undeletable
cp = cpOther = SetCp(cchText); // EOP at end of story
_cch = cp - cpOther; // Store valid length
}
CTxtRange::CTxtRange(CTxtEdit *ped, LONG cp, LONG cch) :
CRchTxtPtr(ped, cp)
{
TRACEBEGIN(TRCSUBSYSRANG, TRCSCOPEINTERN, "CTxtRange::CTxtRange");
RangeValidateCp(cp, cch);
Update_iFormat(-1); // Choose _iFormat
CNotifyMgr *pnm = ped->GetNotifyMgr();
if(pnm)
pnm->Add( (ITxNotify *)this );
}
CTxtRange::CTxtRange(CRchTxtPtr& rtp, LONG cch) :
CRchTxtPtr(rtp)
{
TRACEBEGIN(TRCSUBSYSRANG, TRCSCOPEINTERN, "CTxtRange::CTxtRange");
RangeValidateCp(GetCp(), cch);
Update_iFormat(-1); // Choose _iFormat
CNotifyMgr *pnm = GetPed()->GetNotifyMgr();
if(pnm)
pnm->Add( (ITxNotify *)this );
}
CTxtRange::CTxtRange(const CTxtRange &rg) :
CRchTxtPtr((CRchTxtPtr)rg)
{
TRACEBEGIN(TRCSUBSYSRANG, TRCSCOPEINTERN, "CTxtRange::CTxtRange");
_cch = rg._cch;
_wFlags = FALSE; // This range isn't a selection
_iFormat = -1; // Set up the default format, which
// doesn't get AddRefFormat'd
Set_iCF(rg._iFormat);
CNotifyMgr *pnm = GetPed()->GetNotifyMgr();
if(pnm)
pnm->Add((ITxNotify *)this);
}
CTxtRange::~CTxtRange()
{
TRACEBEGIN(TRCSUBSYSRANG, TRCSCOPEINTERN, "CTxtRange::~CTxtRange");
if(!IsZombie())
{
CNotifyMgr *pnm = GetPed()->GetNotifyMgr();
if(pnm )
pnm->Remove((ITxNotify *)this);
}
ReleaseFormats(_iFormat, -1);
}
CRchTxtPtr& CTxtRange::operator =(const CRchTxtPtr &rtp)
{
TRACEBEGIN(TRCSUBSYSRANG, TRCSCOPEINTERN, "CTxtRange::operator =");
_TEST_INVARIANT_ON(rtp)
LONG cpSave = GetCp(); // Save entry _cp for CheckChange()
CRchTxtPtr::operator =(rtp);
CheckChange(cpSave);
return *this;
}
CTxtRange& CTxtRange::operator =(const CTxtRange &rg)
{
TRACEBEGIN(TRCSUBSYSRANG, TRCSCOPEINTERN, "CTxtRange::operator =");
_TEST_INVARIANT_ON( rg );
LONG cchSave = _cch; // Save entry _cp, _cch for change check
LONG cpSave = GetCp();
CRchTxtPtr::operator =(rg);
_cch = rg._cch; // Can't use CheckChange(), since don't
// use _fExtend
Update_iFormat(-1);
_TEST_INVARIANT_
if( _fSel && (cpSave != GetCp() || cchSave != _cch) )
GetPed()->GetCallMgr()->SetSelectionChanged();
return *this;
}
/*
* CTxtRange::OnPreReplaceRange (cp, cchDel, cchNew, cpFormatMin,
* cpFormatMax)
*
* @mfunc
* called when the backing store changes
*
* @devnote
* 1) if this range is before the changes, do nothing
*
* 2) if the changes are before this range, simply
* add the delta change to GetCp()
*
* 3) if the changes overlap one end of the range, collapse
* that end to the edge of the modifications
*
* 4) if the changes are completely internal to the range,
* adjust _cch and/or GetCp() to reflect the new size. Note
* that two overlapping insertion points will be viewed as
* a 'completely internal' change.
*
* 5) if the changes overlap *both* ends of the range, collapse
* the range to cp
*
* Note that there is an ambiguous cp case; namely the changes
* occur *exactly* at a boundary. In this case, the type of
* range matters. If a range is normal, then the changes
* are assumed to fall within the range. If the range is
* is protected (either in reality or via DragDrop), then
* the changes are assumed to be *outside* of the range.
*/
void CTxtRange::OnPreReplaceRange (
LONG cp, //@parm cp at start of change
LONG cchDel, //@parm Count of chars deleted
LONG cchNew, //@parm Count of chars inserted
LONG cpFormatMin, //@parm the min cp of a format change
LONG cpFormatMax) //@parm the max cp of a format change
{
TRACEBEGIN(TRCSUBSYSRANG, TRCSCOPEINTERN, "CTxtRange::OnPreReplaceRange");
if(CONVERT_TO_PLAIN == cp)
{
// We need to dump our formatting because it is gone
_rpCF.SetToNull();
_rpPF.SetToNull();
if(_fSel)
GetPed()->_fUpdateSelection = TRUE;
Update_iFormat(-1);
return;
}
}
/*
* CTxtRange::OnPostReplaceRange (cp, cchDel, cchNew, cpFormatMin,
* cpFormatMax)
*
* @mfunc
* called when the backing store changes
*
* @devnote
* 1) if this range is before the changes, do nothing
*
* 2) if the changes are before this range, simply
* add the delta change to GetCp()
*
* 3) if the changes overlap one end of the range, collapse
* that end to the edge of the modifications
*
* 4) if the changes are completely internal to the range,
* adjust _cch and/or GetCp() to reflect the new size. Note
* that two overlapping insertion points will be viewed as
* a 'completely internal' change.
*
* 5) if the changes overlap *both* ends of the range, collapse
* the range to cp
*
* Note that there is an ambiguous cp case; namely the changes
* occur *exactly* at a boundary. In this case, the type of
* range matters. If a range is normal, then the changes
* are assumed to fall within the range. If the range is
* is protected (either in reality or via DragDrop), then
* the changes are assumed to be *outside* of the range.
*/
void CTxtRange::OnPostReplaceRange (
LONG cp, //@parm cp at start of change
LONG cchDel, //@parm Count of chars deleted
LONG cchNew, //@parm Count of chars inserted
LONG cpFormatMin, //@parm Min cp of format change
LONG cpFormatMax) //@parm Max cp of format change
{
TRACEBEGIN(TRCSUBSYSRANG, TRCSCOPEINTERN, "CTxtRange::OnPostReplaceRange");
// NB!! We can't do invariant testing here, because we could
// be severely out of date!
LONG cchtemp;
LONG cpMin, cpMost;
LONG cchAdjTextLen;
LONG delta = cchNew - cchDel;
Assert (CONVERT_TO_PLAIN != cp);
GetRange(cpMin, cpMost);
// This range is before the changes. Note: an insertion pt at cp
// shouldn't be changed
if( cp >= cpMost )
{
// Double check to see if we need to fix up our format
// run pointers. If so, all we need to do is rebind
// our inherited rich text pointer
if(cpFormatMin <= cpMost || cpFormatMin == CP_INFINITE)
InitRunPtrs();
else
{
// It's possible that the format runs changed anyway,
// e.g., they became allocated, deallocated, or otherwise
// changed. Normally, BindToCp takes care of this
// situation, but we don't want to pay that cost all
// the time.
//
// Note that starting up the rich text subsystem will
// generate a notification with cpFormatMin == CP_INFINITE
//
// So here, call CheckFormatRuns. This makes sure that
// the runs are in sync with what CTxtStory has
// (doing an InitRunPtrs() _only_ if absolutely necessary).
CheckFormatRuns();
}
return;
}
// Anywhere in the following that we want to increment the current cp by a
// delta, we are counting on the following invariant.
Assert(GetCp() >= 0);
// Changes are entirely before this range. Specifically,
// that's determined by looking at the incoming cp *plus* the number
// of characters deleted
if(cp + cchDel < cpMin || _fDragProtection && cp + cchDel <= cpMin)
{
cchtemp = _cch;
BindToCp(GetCp() + delta);
_cch = cchtemp;
}
// The changes are internal to the range or start within the
// range and go beyond.
else if( cp >= cpMin && cp <= cpMost )
{
// Nobody should be modifying a drag-protected range. Unfortunately,
// Ren re-enters us with a SetText call during drag drop, so we need
// to handle this case 'gracefully'.
if( _fDragProtection )
{
TRACEWARNSZ("REENTERED during a DRAG DROP!! Trying to recover!");
}
if( cp + cchDel <= cpMost )
{
// Changes are purely internal, so
// be sure to preserve the active end. Basically, if
// GetCp() *is* cpMin, then we only need to update _cch.
// Otherwise, GetCp() needs to be moved as well
if( _cch >= 0 )
{
Assert(GetCp() == cpMost);
cchtemp = _cch;
BindToCp(GetCp() + delta);
_cch = cchtemp + delta;
}
else
{
BindToCp(GetCp());
_cch -= delta;
}
// Special case: the range is left with only the final EOP
// selected. This means all the characters in the range were
// deleted so we want to move the range back to an insertion
// point at the end of the text.
cchAdjTextLen = GetAdjustedTextLength();
if(GetCpMin() >= cchAdjTextLen && !GetPed()->IsStreaming())
{
// Reduce the range to an insertion point
_cch = 0;
_fExtend = FALSE;
// Set the cp to the end of the document.
SetCp(cchAdjTextLen);
}
}
else
{
// Changes extended beyond cpMost. In this case,
// we want to truncate cpMost to the *beginning* of
// the changes (i.e. cp)
if( _cch > 0 )
{
BindToCp(cp);
_cch = cp - cpMin;
}
else
{
BindToCp(cpMin);
_cch = cpMin - cp;
}
}
}
else if( cp + cchDel >= cpMost )
{
// Nobody should be modifying a drag-protected range. Unfortunately,
// Ren re-enters us with a SetText call during drag drop, so we need
// to handle this case 'gracefully'.
if( _fDragProtection )
{
TRACEWARNSZ("REENTERED during a DRAG DROP!! Trying to recover!");
}
// Entire range was deleted, so collapse to an insertion point at cp
BindToCp(cp);
_cch = 0;
}
else
{
// Nobody should be modifying a drag-protected range. Unfortunately,
// Ren re-enters us with a SetText call during drag drop, so we need
// to handle this case 'gracefully'.
if( _fDragProtection )
{
TRACEWARNSZ("REENTERED during a DRAG DROP!! Trying to recover!");
}
// The change crossed over just cpMin. In this case move cpMin
// forward to the unchanged part
LONG cchdiff = (cp + cchDel) - cpMin;
Assert( cp + cchDel < cpMost );
Assert( cp + cchDel >= cpMin );
Assert( cp < cpMin );
cchtemp = _cch;
if( _cch > 0 )
{
BindToCp(GetCp() + delta);
_cch = cchtemp - cchdiff;
}
else
{
BindToCp(cp + cchNew);
_cch = cchtemp + cchdiff;
}
}
if( _fSel )
{
GetPed()->_fUpdateSelection = TRUE;
GetPed()->GetCallMgr()->SetSelectionChanged();
}
Update_iFormat(-1); // Make sure _iFormat is up to date
_TEST_INVARIANT_
}
/*
* CTxtRange::Zombie ()
*
* @mfunc
* Turn this range into a zombie (_cp = _cch = 0, NULL ped, ptrs to
* backing store arrays. CTxtRange methods like GetRange(),
* GetCpMost(), GetCpMin(), and GetTextLength() all work in zombie mode,
* returning zero values.
*/
void CTxtRange::Zombie()
{
CRchTxtPtr::Zombie();
_cch = 0;
}
/*
* CTxtRange::CheckChange(cpSave, cchSave)
*
* @mfunc
* Set _cch according to _fExtend and set selection-changed flag if
* this range is a CTxtSelection and the new _cp or _cch differ from
* cp and cch, respectively.
*
* @devnote
* We can count on GetCp() and cpSave both being <= GetTextLength(),
* but we can't leave GetCp() equal to GetTextLength() unless _cch ends
* up > 0.
*/
LONG CTxtRange::CheckChange(
LONG cpSave) //@parm Original _cp for this range
{
LONG cchAdj = GetAdjustedTextLength();
LONG cchSave = _cch;
if(_fExtend) // Wants to be nondegenerate
{ // and maybe it is
LONG cp = GetCp();
_cch = cp - (cpSave - cchSave);
CheckIfSelHasEOP(cpSave, cchSave);
}
else
{
_cch = 0; // Insertion point
_fSelHasEOP = FALSE; // Selection doesn't contain
_fSelHasCell = FALSE; // any char, let alone a CR
} // or table cell
if(!_cch && GetCp() > cchAdj) // If still IP and active end
CRchTxtPtr::SetCp(cchAdj); // follows nondeletable EOP,
// backspace over that EOP
LONG cch = GetCp() - cpSave;
_fMoveBack = cch < 0;
if(cch || cchSave != _cch)
{
Update_iFormat(-1);
if(_fSel)
GetPed()->GetCallMgr()->SetSelectionChanged();
_TEST_INVARIANT_
}
return cch;
}
/*
* CTxtRange::CheckIfSelHasEOP(cpSave, cchSave)
*
* @mfunc
* Maintains _fSelHasEOP = TRUE iff selection contains one or more EOPs.
* When cpSave = -1, calculates _fSelHasEOP unconditionally and cchSave
* is ignored (it's only used for conditional execution). Else _fSelHasEOP
* is only calculated for cases that may change it, i.e., it's assumed
* be up to date before the change.
*
* @rdesc
* TRUE iff _fSel and _cch
*
* @devnote
* Call after updating range _cch
*/
BOOL CTxtRange::CheckIfSelHasEOP(
LONG cpSave, //@parm Previous active end cp or -1
LONG cchSave) //@parm Previous signed length if cpSave != -1
{
// _fSelHasEOP only maintained for the selection
if(!_fSel)
return FALSE;
if(!_cch)
{
_fSelHasEOP = FALSE; // Selection doesn't contain
_fSelHasCell = FALSE; // any char, let alone CR
return FALSE;
}
LONG cpMin, cpMost;
GetRange(cpMin, cpMost);
if(cpSave != -1) // Selection may have changed
{ // Set up to bypass text scan if
LONG cpMinPrev, cpMostPrev; // selection grew and _fSelHasEOP
// is already TRUE or got smaller
cpMinPrev = cpMostPrev = cpSave;// and _fSelHasEOP is FALSE.
if(cchSave > 0) // Calculate previous cpMin
cpMinPrev -= cchSave; // and cpMost
else
cpMostPrev -= cchSave;
// Note: _fSelHasCell shouldn't change while in a table, since
// Update() should always expand to a cell once _fSelHasCell has
// been deteted.
if (!_fSelHasEOP && cpMin >= cpMinPrev && cpMost <= cpMostPrev ||
_fSelHasEOP && cpMin <= cpMinPrev && cpMost >= cpMostPrev)
{
return TRUE; // _fSelHasEOP can't change
}
}
LONG FEOP_Results;
CTxtPtr tp(_rpTX); // Scan range for an EOP
tp.SetCp(cpMin);
tp.FindEOP(cpMost - cpMin, &FEOP_Results);
_fSelHasCell = (FEOP_Results & FEOP_CELL) != 0;
_fSelHasEOP = (FEOP_Results & FEOP_EOP) != 0;
return TRUE;
}
/*
* CTxtRange::GetRange(&cpMin, &cpMost)
*
* @mfunc
* set cpMin = this range cpMin
* set cpMost = this range cpMost
* return cpMost - cpMin, i.e. abs(_cch)
*
* @rdesc
* abs(_cch)
*/
LONG CTxtRange::GetRange (
LONG& cpMin, //@parm Pass-by-ref cpMin
LONG& cpMost) const //@parm Pass-by-ref cpMost
{
TRACEBEGIN(TRCSUBSYSRANG, TRCSCOPEINTERN, "CTxtRange::GetRange");
LONG cch = _cch;
if(cch >= 0)
{
cpMost = GetCp();
cpMin = cpMost - cch;
}
else
{
cch = -cch;
cpMin = GetCp();
cpMost = cpMin + cch;
}
return cch;
}
/*
* CTxtRange::GetCpMin()
*
* @mfunc
* return this range's cpMin
*
* @rdesc
* cpMin
*
* @devnote
* If you need cpMost and/or cpMost - cpMin, GetRange() is faster
*/
LONG CTxtRange::GetCpMin() const
{
TRACEBEGIN(TRCSUBSYSRANG, TRCSCOPEINTERN, "CTxtRange::GetCpMin");
LONG cp = GetCp();
return _cch <= 0 ? cp : cp - _cch;
}
/*
* CTxtRange::GetCpMost()
*
* @mfunc
* return this range's cpMost
*
* @rdesc
* cpMost
*
* @devnote
* If you need cpMin and/or cpMost - cpMin, GetRange() is faster
*/
LONG CTxtRange::GetCpMost() const
{
TRACEBEGIN(TRCSUBSYSRANG, TRCSCOPEINTERN, "CTxtRange::GetCpMost");
LONG cp = GetCp();
return _cch >= 0 ? cp : cp - _cch;
}
/*
* CTxtRange::Update(fScrollIntoView)
*
* @mfunc
* Virtual stub routine overruled by CTxtSelection::Update() when this
* text range is a text selection. The purpose is to update the screen
* display of the caret or selection to correspond to changed cp's.
*
* @rdesc
* TRUE
*/
BOOL CTxtRange::Update (
BOOL fScrollIntoView) //@parm TRUE if should scroll caret into view
{
TRACEBEGIN(TRCSUBSYSRANG, TRCSCOPEINTERN, "CTxtRange::Update");
return TRUE; // Simple range has no selection colors or
} // caret, so just return TRUE
/*
* CTxtRange::SetCp(cp)
*
* @mfunc
* Set active end of this range to cp. Leave other end where it is or
* collapse range depending on _fExtend (see CheckChange()).
*
* @rdesc
* cp at new active end (may differ from cp, since cp may be invalid).
*/
LONG CTxtRange::SetCp(
LONG cp) //@parm new cp for active end of this range
{
TRACEBEGIN(TRCSUBSYSBACK, TRCSCOPEINTERN, "CTxtRange::SetCp");
LONG cpSave = GetCp();
CRchTxtPtr::SetCp(cp);
CheckChange(cpSave); // NB: this changes _cp if after
return GetCp(); // final CR and _cch = 0
}
/*
* CTxtRange::Set (cp, cch)
*
* @mfunc
* Set this range's active-end cp and signed cch
*/
BOOL CTxtRange::Set (
LONG cp, //@parm Desired active end cp
LONG cch) //@parm Desired signed count of chars
{
TRACEBEGIN(TRCSUBSYSRANG, TRCSCOPEINTERN, "CTxtRange::Set");
BOOL bRet = FALSE;
LONG cchSave = _cch; // Save entry _cp, _cch for change check
LONG cchText = GetAdjustedTextLength();
LONG cpSave = GetCp();
LONG cpOther = cp - cch; // Desired "other" end
ValidateCp(cp); // Be absolutely sure to validate
ValidateCp(cpOther); // both ends
if(cp == cpOther && cp > cchText) // IP cannot follow undeletable
cp = cpOther = cchText; // EOP at end of story
CRchTxtPtr::Advance(cp - GetCp());
AssertSz(cp == GetCp(),
"CTxtRange::Set: inconsistent cp");
if(GetPed()->fUseCRLF())
{
cch = _rpTX.AdjustCpCRLF();
if(cch)
{
_rpCF.AdvanceCp(cch); // Keep all 3 runptrs in sync
_rpPF.AdvanceCp(cch);
cp = GetCp();
}
if(cpOther != cp)
{
CTxtPtr tp(_rpTX);
tp.AdvanceCp(cpOther - cp);
cpOther += tp.AdjustCpCRLF();
}
}
_cch = cp - cpOther; // Validated _cch value
CheckIfSelHasEOP(cpSave, cchSave); // Maintain _fSelHasEOP in
// outline mode
_fMoveBack = GetCp() < cpSave;
if(cpSave != GetCp() || cchSave != _cch)
{
if(_fSel)
GetPed()->GetCallMgr()->SetSelectionChanged();
Update_iFormat(-1);
bRet = TRUE;
}
_TEST_INVARIANT_
return bRet;
}
/*
* CTxtRange::Advance(cch)
*
* @mfunc
* Advance active end of range by cch.
* Other end stays put iff _fExtend
*
* @rdesc
* cch actually moved
*/
LONG CTxtRange::Advance (
LONG cch) //@parm Signed char count to move active end
{
TRACEBEGIN(TRCSUBSYSRANG, TRCSCOPEINTERN, "CTxtRange::Advance");
LONG cpSave = GetCp(); // Save entry _cp for CheckChange()
CRchTxtPtr::Advance(cch);
return CheckChange(cpSave);
}
/*
* CTxtRange::AdvanceCRLF()
*
* @mfunc
* Advance active end of range one char, treating CRLF as a single char.
* Other end stays put iff _fExtend is nonzero.
*
* @rdesc
* cch actually moved
*/
LONG CTxtRange::AdvanceCRLF()
{
TRACEBEGIN(TRCSUBSYSRANG, TRCSCOPEINTERN, "CTxtRange::AdvanceCRLF");
LONG cpSave = GetCp(); // Save entry _cp for CheckChange()
CRchTxtPtr::AdvanceCRLF();
return CheckChange(cpSave);
}
/*
* CTxtRange::SnapToCluster(INT iDirection)
*
* @rdesc
* cch actually moved
*/
LONG CTxtRange::SnapToCluster(INT iDirection)
{
TRACEBEGIN(TRCSUBSYSRANG, TRCSCOPEINTERN, "CTxtRange::SnapToCluster");
LONG cpSave = GetCp(); // Save entry _cp for CheckChange()
CRchTxtPtr::SnapToCluster(iDirection);
return CheckChange(cpSave);
}
/*
* CTxtRange::BackupCRLF()
*
* @mfunc
* Backup active end of range one char, treating CRLF as a single char.
* Other end stays put iff _fExtend
*
* @rdesc
* cch actually moved
*/
LONG CTxtRange::BackupCRLF(
BOOL fDiacriticCheck)
{
TRACEBEGIN(TRCSUBSYSRANG, TRCSCOPEINTERN, "CTxtRange::BackupCRLF");
LONG cpSave = GetCp(); // Save entry _cp for CheckChange()
CRchTxtPtr::BackupCRLF(fDiacriticCheck);
return CheckChange(cpSave);
}
/*
* CTxtRange::FindWordBreak(action)
*
* @mfunc
* Move active end as determined by plain-text FindWordBreak().
* Other end stays put iff _fExtend
*
* @rdesc
* cch actually moved
*/
LONG CTxtRange::FindWordBreak (
INT action) //@parm action defined by CTxtPtr::FindWordBreak()
{
TRACEBEGIN(TRCSUBSYSRANG, TRCSCOPEINTERN, "CTxtPtr::FindWordBreak");
LONG cpSave = GetCp(); // Save entry _cp for CheckChange()
CRchTxtPtr::FindWordBreak(action);
return CheckChange(cpSave);
}
/*
* CTxtRange::FlipRange()
*
* @mfunc
* Flip active and non active ends
*/
void CTxtRange::FlipRange()
{
TRACEBEGIN(TRCSUBSYSRANG, TRCSCOPEINTERN, "CTxtRange::FlipRange");
_TEST_INVARIANT_
CRchTxtPtr::Advance(-_cch);
_cch = -_cch;
}
/*
* CTxtRange::HexToUnicode(publdr)
*
* @mfunc
* Convert hex number ending at cpMost to a Unicode character and
* replace the hex number by that character. Take into account
* Unicode surrogates for hex values from 0x10000 up to 0x10FFFF.
*
* @rdesc
* HRESULT S_OK if conversion successful and hex number replaced by
* corresponding Unicode character
*/
HRESULT CTxtRange::HexToUnicode (
IUndoBuilder *publdr) //@parm UndoBuilder to receive antievents
{
LONG ch;
LONG cpMin, cpMost;
LONG cch = GetRange(cpMin, cpMost);
LONG i;
LONG lch = 0;
if(cch)
{
if(cpMost > GetAdjustedTextLength() || cch > 6)
return S_FALSE;
Collapser(tomEnd);
}
else
cch = 6;
SetExtend(TRUE);
for(i = 0; cch--; i += 4)
{
ch = GetPrevChar();
if(ch == '+') // Check for U+xxxx notation
{ // If it's there, set up to
Advance(-1); // delete the U+ (or u+)
Advance((GetPrevChar() | 0x20) == 'u' ? -1 : 1);
break; // Else leave the +
}
if(ch > 'f' || !IsXDigit(ch))
break;
Advance(-1);
ch |= 0x20;
ch -= (ch >= 'a') ? 'a' - 10 : '0';
lch += (ch << i);
}
if(!lch || lch > 0x10FFFF)
return S_FALSE;
WCHAR str[2] = {(WCHAR)lch};
cch = 1;
if(lch > 0xFFFF)
{
lch -= 0x10000;
str[0] = 0xD800 + (lch >> 10);
str[1] = 0xDC00 + (lch & 0x3FF);
cch = 2;
}
if(publdr)
publdr->StopGroupTyping();
_rpCF.AdjustBackward(); // Use format of run preceding
Set_iCF(_rpCF.GetFormat()); // hex number
_fUseiFormat = TRUE;
_rpCF.AdjustForward();
CleanseAndReplaceRange(cch, str, FALSE, publdr, NULL);
return S_OK;
}
/*
* CTxtRange::UnicodeToHex(publdr)
*
* @mfunc
* Convert Unicode character(s) preceeding cpMin to a hex number and
* select it. Translate Unicode surrogates into corresponding for hex
* values from 0x10000 up to 0x10FFFF.
*
* @rdesc
* HRESULT S_OK if conversion successful and Unicode character(s) is
* replaced by corresponding hex number.
*/
HRESULT CTxtRange::UnicodeToHex (
IUndoBuilder *publdr) //@parm UndoBuilder to receive antievents
{
if(_cch) // If there's a selection,
{ // convert 1st char in sel
Collapser(tomStart);
Advance(IN_RANGE(0xD800, CRchTxtPtr::GetChar(), 0xDBFF) ? 2 : 1);
}
LONG cp = GetCp();
if(!cp) // No character to convert
return S_FALSE;
_cch = 1; // Select previous char
LONG n = GetPrevChar(); // Get it
_fExtend = TRUE;
if(publdr)
publdr->StopGroupTyping();
if(IN_RANGE(0xDC00, n, 0xDFFF)) // Unicode surrogate trail word
{
if(cp <= 1) // No lead word
return S_FALSE;
Advance(-2);
LONG ch = CRchTxtPtr::GetChar();
Assert(IN_RANGE(0xD800, ch, 0xDBFF));
n = (n & 0x3FF) + ((ch & 0x3FF) << 10) + 0x10000;
_cch = -2;
}
// Convert ch to str
LONG cch = 0;
LONG quot, rem; // ldiv results
WCHAR str[6];
WCHAR * pch = &str[0];
for(LONG d = 1; d < n; d <<= 4) // d = smallest power of 16 > n
;
if(n && d > n)
d >>= 4;
while(d)
{
quot = n / d; // Avoid an ldiv
rem = n % d;
n = quot + '0';
if(n > '9')
n += 'A' - '9' - 1;
*pch++ = (WCHAR)n; // Store digit
cch++;
n = rem; // Setup remainder
d >>= 4;
}
CleanseAndReplaceRange(cch, str, FALSE, publdr, NULL);
_cch = cch; // Select number
if(_fSel)
Update(FALSE);
return S_OK;
}
/*
* CTxtRange::IsInputSequenceValid(pch, cchIns, fOver, pfBaseChar)
*
* @mfunc
* Verify the sequence of incoming text. Return FALSE if invalid
* combination is found. The criteria is to allow any combinations
* that are displayable on screen (the simplest approach used by system
* edit control).
*
* @rdesc
* Return FALSE if invalid combination is found; else TRUE.
*
* FUTURE: We may consider to support bad sequence filter or text streaming. The code
* below is easy enough to be extended to do so.
*/
BOOL CTxtRange::IsInputSequenceValid(
WCHAR* pwch, // Inserting string
LONG cchIns, // Character count
BOOL fOverType, // Insert or Overwrite mode
BOOL* pfBaseChar) // Is pwch[0] a cluster start (base char)?
{
CTxtEdit* ped = GetPed();
CTxtPtr tp(_rpTX);
HKL hkl = GetKeyboardLayout(0);
BOOL fr = TRUE;
if (ped->fUsePassword() || ped->_fNoInputSequenceChk)
return TRUE; // no check when editing password
if (PRIMARYLANGID(hkl) == LANG_VIETNAMESE)
{
// No concern about overtyping or cluster since we look backward only
// 1 char and dont care characters following the insertion point.
if(_cch > 0)
tp.AdvanceCp(-_cch);
fr = IsVietCdmSequenceValid(tp.GetPrevChar(), *pwch);
}
else if (PRIMARYLANGID(hkl) == LANG_THAI ||
W32->IsIndicLcid(LOWORD(hkl)))
{
// Do complex things for Thai and Indic
WCHAR rgwchText[32];
WCHAR* pwchText = rgwchText;
CUniscribe* pusp = ped->Getusp();
CTxtBreaker* pbrk = ped->_pbrk;
LONG found = 0;
LONG cp, cpSave, cpLimMin, cpLimMax;
LONG cchDel = 0, cchText, ich;
LONG cpEnd = ped->GetAdjustedTextLength();
if (_cch > 0)
tp.AdvanceCp(-_cch);
cp = cpSave = cpLimMin = cpLimMax = tp.GetCp();
if (_cch)
{
cchDel = abs(_cch);
}
else if (fOverType && !tp.IsAtEOP() && cp != cpEnd)
{
// Delete up to the next cluster in overtype mode
cchDel++;
if (pbrk)
while (cp + cchDel < cpEnd && !pbrk->CanBreakCp(BRK_CLUSTER, cp + cchDel))
cchDel++;
}
cpLimMax += cchDel;
// Figure the min/max boundaries
if (pbrk)
{
// Min boundary
cpLimMin += tp.FindEOP(tomBackward, &found);
if (!(found & FEOP_EOP))
cpLimMin = 0;
while (--cp > cpLimMin && !pbrk->CanBreakCp(BRK_CLUSTER, cp));
cpLimMin = max(cp, cpLimMin); // more precise boundary
// Max boundary
cp = cpLimMax;
tp.SetCp(cpLimMax);
cpLimMax += tp.FindEOP(tomForward, &found);
if (!(found & FEOP_EOP))
cpLimMax = ped->GetTextLength();
while (cp < cpLimMax && !pbrk->CanBreakCp(BRK_CLUSTER, cp++));
cpLimMax = min(cp, cpLimMax); // more precise boundary
}
else
{
// No cluster info we statically bound to -1/+1 from selection range
cpLimMin--;
cpLimMin = max(0, cpLimMin);
cpLimMax += cchDel + 1;
cpLimMax = min(cpLimMax, ped->GetTextLength());
}
cp = cpSave + cchDel;
cchText = cpSave - cpLimMin + cchIns + cpLimMax - cp;
tp.SetCp(cpLimMin);
if (cchText > 32)
pwchText = new WCHAR[cchText];
if (pwchText)
{
// prepare text
cchText = tp.GetText (cpSave - cpLimMin, pwchText);
tp.AdvanceCp (cchText + cchDel);
ich = cchText;
wcsncpy (&pwchText[cchText], pwch, cchIns);
cchText += cchIns;
cchText += tp.GetText (cpLimMax - cpSave - cchDel, &pwchText[cchText]);
Assert (cchText == cpLimMax - cpLimMin - cchDel + cchIns);
if (pusp)
{
SCRIPT_STRING_ANALYSIS ssa;
HRESULT hr;
BOOL fDecided = FALSE;
hr = ScriptStringAnalyse(NULL, pwchText, cchText, GLYPH_COUNT(cchText), -1,
SSA_BREAK, -1, NULL, NULL, NULL, NULL, NULL, &ssa);
if (S_OK == hr)
{
if (fOverType)
{
const SCRIPT_LOGATTR* psla = ScriptString_pLogAttr(ssa);
BOOL fBaseChar = !psla || psla[ich].fCharStop;
if (!fBaseChar)
{
// In overtype mode, if the inserted char is not a cluster start.
// We act like insert mode. Recursive call with fOvertype = FALSE.
fr = IsInputSequenceValid(pwch, cchIns, 0, NULL);
fDecided = TRUE;
}
if (pfBaseChar)
*pfBaseChar = fBaseChar;
}
if (!fDecided && S_FALSE == ScriptStringValidate(ssa))
fr = FALSE;
ScriptStringFree(&ssa);
}
}
if (pwchText != rgwchText)
delete[] pwchText;
}
}
return fr;
}
/*
* CTxtRange::CleanseAndReplaceRange(cch, *pch, fTestLimit, publdr,
* pchD, pcchMove, dwFlags)
* @mfunc
* Cleanse the string pch (replace CRLFs by CRs, etc.) and substitute
* the resulting string for the text in this range using the CCharFormat
* _iFormat and updating other text runs as needed. For single-line
* controls, truncate on the first EOP and substitute the truncated
* string. Also truncate if string would overflow the max text length.
*
* @rdesc
* Count of new characters added
*/
LONG CTxtRange::CleanseAndReplaceRange (
LONG cchS, //@parm Length of replacement (Source) text
const WCHAR * pchS, //@parm Replacement (Source) text
BOOL fTestLimit, //@parm Whether to do limit test
IUndoBuilder * publdr, //@parm UndoBuilder to receive antievents
WCHAR * pchD, //@parm Destination string (multiline only)
LONG* pcchMove, //@parm Count of chars moved in 1st replace
DWORD dwFlags) //@parm ReplaceRange's flags
{
TRACEBEGIN(TRCSUBSYSRANG, TRCSCOPEINTERN, "CTxtRange::CleanseAndReplaceRange");
CTxtEdit * ped = GetPed();
BYTE bDefaultCharset = ped->GetCharFormat(-1)->_bCharSet;
LONG cchM = 0;
LONG cchMove = 0;
LONG cchNew = 0; // Collects total cch inserted
LONG cch; // Collects cch for cur charset
DWORD ch, ch1;
LONG cpFirst = GetCpMin();
DWORD dw;
DWORD dwCharFlags = 0;
DWORD dwCharMask = GetCharSetMask();
DWORD dwCurrentFontUsed = 0;
BOOL f10Mode = ped->Get10Mode();
BOOL fCallerDestination = pchD != 0; // Save if pchD enters as 0
BOOL fDefFontHasASCII = FALSE;
CFreezeDisplay fd(ped->_pdp);
BOOL fMultiLine = ped->_pdp->IsMultiLine();
BOOL fFEBaseFont = IsFECharSet(bDefaultCharset);
BOOL fInTable = FALSE;
bool fUIFont = fUseUIFont();
BOOL fUseCRLF = ped->fUseCRLF();
BOOL fDefFontSymbol = dwCharMask == fSYMBOL;
const WCHAR * pch = pchS;
CTempWcharBuf twcb; // Buffer needed for multiline if
// pchD = 0
CCharFormat CFCurrent; // Current CF used during IME in progress
const DWORD fALPHA = 0x01;
BOOL fDeleteChar = !ped->IsRich() && _cch;
if (ped->_fIMEInProgress)
{
// Initialize data to handle alpha/ASCII dual font mode
// during IME composition
dwCurrentFontUsed = fFE;
CFCurrent = *ped->GetCharFormat(GetiFormat());
}
// Check if default font supports full ASCII and Symbol
if (fUIFont)
{
DWORD dwMaskDefFont = GetCharSetMask(TRUE);
fDefFontHasASCII = (dwMaskDefFont & fASCII) == fASCII;
fDefFontSymbol = dwMaskDefFont == fSYMBOL;
}
if(!pchS)
cchS = 0;
else if(fMultiLine)
{
if(cchS < 0) // Calculate length for
cchS = wcslen(pchS); // target buffer
if(cchS && !pchD)
{
pchD = twcb.GetBuf(cchS);
if(!pchD) // Couldn't allocate buffer:
return 0; // give up with no update
}
pch = pchD;
if(_cch <= 0)
fInTable = GetPF()->InTable();
else
{
CFormatRunPtr rpPF(_rpPF);
rpPF.AdvanceCp(-_cch);
fInTable = (ped->GetParaFormat(rpPF.GetFormat())->InTable());
}
}
else if(cchS < 0) // Calculate string length
cchS = tomForward; // while looking for EOP
for(cch = 0; cchS; cchS--, pchS++, cch++)
{
ch = *pchS;
if(!ch && (!fMultiLine || !fCallerDestination))
break;
if(IN_RANGE(CELL, ch, CR)) // Handle CR and LF combos
{
if(!fMultiLine && ch >= LF) // Truncate at 1st EOP to be
break; // compatible with user.exe SLE
// and for consistent behavior
if(ch == CR && !f10Mode)
{
if(cchS > 1)
{
ch1 = *(pchS + 1);
if(cchS > 2 && ch1 == CR && *(pchS+2) == LF)
{
if(fUseCRLF)
{
*pchD++ = ch;
*pchD++ = ch1;
ch = LF;
cch += 2;
}
else
{
// Translate CRCRLF to CR or to ' '
ch = ped->fXltCRCRLFtoCR() ? CR : ' ';
}
pchS += 2; // Bypass two chars
cchS -= 2;
}
else if(ch1 == LF)
{
if(fUseCRLF && !fInTable)// Copy over whole CRLF
{
*pchD++ = ch; // Here we copy CR
ch = ch1; // Setup to copy LF
cch++;
}
pchS++;
cchS--;
}
}
if(fInTable && ch == CR) // Our simple tables can't contain
ch = ' '; // CRs or CELLs
}
else if(!fUseCRLF && ch == LF) // Treat lone LFs as EOPs, i.e.,
ch = CR; // be nice to Unix text files
else if(ch == CELL && fInTable)
ch = ' ';
}
else if((ch | 1) == PS) // Translate Unicode para/line
{ // separators into CR/VT
if(!fMultiLine)
break;
ch = (ch == PS) ? CR : VT;
}
dw = fSYMBOL;
if(!fDefFontSymbol)
dw = GetCharFlags(ch, bDefaultCharset); // Check for complex scripts,
dwCharFlags |= dw; // FE, and charset changes
dw &= ~0xFF; // Exclude non-fontbind flags
if(ped->IsAutoFont() && !fDefFontSymbol)
{
BOOL fReplacedText = FALSE;
if (fDeleteChar)
{
fDeleteChar = FALSE;
ReplaceRange(0, NULL, publdr, SELRR_REMEMBERRANGE, NULL, RR_ITMZ_NONE);
Set_iCF(-1);
dwCharMask = GetCharSetMask(TRUE);
}
if (!ped->_fIMEInProgress)
{
// Simp. Chinese uses some of the Latin2 symbols
if (dw == fLATIN2 || IN_RANGE(0x0250, ch, 0x02FF)
|| IN_RANGE(0xFE50, ch, 0xFE6F))
{
WCHAR wch = ch;
if (VerifyFEString(CP_CHINESE_SIM, &wch, 1, TRUE) == CP_CHINESE_SIM ||
VerifyFEString(CP_CHINESE_TRAD, &wch, 1, TRUE) == CP_CHINESE_TRAD)
dw = fCHINESE;
}
if (fUIFont && dw == fHILATIN1 && fFEBaseFont)
{
// Use Ansi font for HiAnsi
if (dwCurrentFontUsed != fHILATIN1)
{
fReplacedText = TRUE;
cchNew += CheckLimitReplaceRange(cch, pch, fTestLimit, publdr,
dw, &cchM, cpFirst, IGNORE_CURRENT_FONT, RR_ITMZ_NONE); // Replace text up to previous char
}
dwCurrentFontUsed = fHILATIN1;
}
else if (fUIFont && fDefFontHasASCII &&
(dw & fASCII || IN_RANGE(0x2018, ch, 0x201D)))
{
if (dwCurrentFontUsed != fASCII)
{
cchNew += CheckLimitReplaceRange(cch, pch, fTestLimit, publdr,
0, &cchM, cpFirst, IGNORE_CURRENT_FONT, RR_ITMZ_NONE); // Replace text up to previous char
// Use the -1 font charset/face/size so the current font effect
// will still be used.
CCharFormat CFDefault = *ped->GetCharFormat(-1);
SetCharFormat(&CFDefault, 0, publdr, CFM_CHARSET | CFM_FACE | CFM_SIZE,
CFM2_CHARFORMAT | CFM2_NOCHARSETCHECK);
fReplacedText = TRUE;
}
dwCurrentFontUsed = fASCII;
}
else if (dw && !(dw & dwCharMask) // No match: need charset change
|| dwCurrentFontUsed) // or change in classification
{
fReplacedText = TRUE;
dwCurrentFontUsed = 0;
if(dw & (fCHINESE | fBIG5) & ~255) // If Han char, check next few
{ // chars for a Hangul or Kana
Assert(cchS);
const WCHAR *pchT = pchS+1;
LONG i = min(10, cchS - 1);
while(i-- && *pchT)
dw |= GetCharFlags(*pchT++, bDefaultCharset);
i = CalcTextLenNotInRange();
if(cchS < 6 && i) // Get flags around range
{
CTxtPtr tp(_rpTX);
i = min(i, 6);
if(!_cch) // For insertion point, backup
tp.AdvanceCp(-i/2); // half way
else if(_cch < 0) // Active end at cpMin, backup
tp.AdvanceCp(-i); // whole way
for(; i--; tp.AdvanceCp(1))
dw |= GetCharFlags(tp.GetChar(), bDefaultCharset);
}
dw &= (fKANA | fHANGUL | fCHINESE | fBIG5);
}
else if(dw & (fHILATIN1 | fLATIN2) && dwCharMask & fLATIN)
{
LONG i = dwCharMask & fLATIN;
dw = W32->GetCharFlags125x(ch) & fLATIN;
if(!(dw & i))
for(i = 0x100; i < 0x20000 && !(dw & i); i <<= 1)
;
dw &= i;
}
cchNew += CheckLimitReplaceRange(cch, pch, fTestLimit, publdr,
dw, &cchM, cpFirst, MATCH_FONT_SIG, RR_ITMZ_NONE); // Replace text up to previous char
}
}
else
{
// IME in progress, only need to check ASCII cases
BOOL fHandled = FALSE;
if (ch <= 0x7F)
{
if (fUIFont)
{
// Use default font
if (dwCurrentFontUsed != fASCII)
{
cchNew += CheckLimitReplaceRange(cch, pch, fTestLimit, publdr,
0, &cchM, cpFirst, IGNORE_CURRENT_FONT, RR_ITMZ_NONE); // Replace text up to previous char
// Use the -1 font charset/face/size so the current font effect
// will still be used.
CCharFormat CFDefault = *ped->GetCharFormat(-1);
SetCharFormat(&CFDefault, 0, publdr, CFM_CHARSET | CFM_FACE | CFM_SIZE,
CFM2_CHARFORMAT | CFM2_NOCHARSETCHECK);
fReplacedText = TRUE;
}
dwCurrentFontUsed = fASCII;
fHandled = TRUE;
}
else if (ped->_fDualFont && IsAlpha(ch))
{
// Use English Font
if (dwCurrentFontUsed != fALPHA)
{
cchNew += CheckLimitReplaceRange(cch, pch, fTestLimit, publdr,
dw, &cchM, cpFirst, IGNORE_CURRENT_FONT, RR_ITMZ_NONE); // Replace text up to previous char
fReplacedText = TRUE;
}
dwCurrentFontUsed = fALPHA;
fHandled = TRUE;
}
}
// Use current FE font
if (!fHandled)
{
if (dwCurrentFontUsed != fFE)
{
cchNew += CheckLimitReplaceRange(cch, pch, fTestLimit, publdr,
0, &cchM, cpFirst, IGNORE_CURRENT_FONT, RR_ITMZ_NONE); // Replace text up to previous char
SetCharFormat(&CFCurrent, 0, publdr, CFM_CHARSET | CFM_FACE | CFM_SIZE,
CFM2_CHARFORMAT | CFM2_NOCHARSETCHECK);
fReplacedText = TRUE;
}
dwCurrentFontUsed = fFE;
}
}
if (fReplacedText)
{
dwCharMask = (dw & fSYMBOL) ? fSYMBOL : GetCharSetMask();
if(cchM)
cchMove = cchM; // Can only happen on 1st replace
pch = fMultiLine ? pchD : pchS;
cch = 0;
}
}
if(fMultiLine) // In multiline controls, collect
{ // possibly translated chars
if(dw & fSYMBOL) // Convert 0xF000 thru 0xF0FF to
ch &= 0xFF; // SYMBOL_CHARSET with 0x00 thru
*pchD++ = ch; // 0xFF. FUTURE: make work for
} // single line too...
}
ped->OrCharFlags(dwCharFlags, publdr);
cchNew += CheckLimitReplaceRange(cch, pch, fTestLimit, publdr, 0, &cchM, cpFirst,
IGNORE_CURRENT_FONT, RR_ITMZ_NONE);
if(cchM)
cchMove = cchM; // Can only happen on 1st replace
if (pcchMove)
*pcchMove = cchMove;
if (ped->IsComplexScript())
{
if (dwFlags & RR_ITMZ_NONE || ped->IsStreaming())
ped->_fItemizePending = TRUE;
else
ItemizeReplaceRange(cchNew, cchMove, publdr, dwFlags & RR_ITMZ_UNICODEBIDI);
}
return cchNew;
}
/*
* CTxtRange::CheckLimitReplaceRange(cchNew, *pch, fTestLimit, publdr,
* dwFlags, pcchMove, prp, iMatchCurrent, dwFlags)
* @mfunc
* Replace the text in this range by pch using CCharFormat _iFormat
* and updating other text runs as needed.
*
* @rdesc
* Count of new characters added
*
* @devnote
* moves this text pointer to end of replaced text and
* may move text block and formatting arrays
*/
LONG CTxtRange::CheckLimitReplaceRange (
LONG cch, //@parm Length of replacement text
TCHAR const * pch, //@parm Replacement text
BOOL fTestLimit, //@parm Whether to do limit test
IUndoBuilder * publdr, //@parm UndoBuilder to receive antievents
DWORD dwCharFlags, //@parm CharFlags following pch
LONG * pcchMove, //@parm Count of chars moved in 1st replace
LONG cpFirst, //@parm Starting cp for font binding
int iMatchCurrent, //@parm Font matching method
DWORD dwFlags) //@parm ReplaceRange's flags
{
CTxtEdit *ped = GetPed();
if(cch || _cch)
{
if(fTestLimit)
{
LONG cchLen = CalcTextLenNotInRange();
DWORD cchMax = ped->TxGetMaxLength();
if((DWORD)(cch + cchLen) > cchMax) // New plus old count exceeds
{ // max allowed, so truncate
cch = cchMax - cchLen; // down to what fits
cch = max(cch, 0); // Keep it positive
ped->GetCallMgr()->SetMaxText(); // Report exceeded
}
}
if (cch && ped->IsAutoFont() && !ped->_fIMEInProgress)
{
LONG iFormatTemp;
if (fUseUIFont() && GetAdjustedTextLength() != _cch)
{
// Delete the old string first so _iFormat is defined
ReplaceRange(0, NULL, publdr, SELRR_REMEMBERRANGE, pcchMove, dwFlags);
iFormatTemp = _iFormat;
}
else
iFormatTemp = GetiFormat();
BYTE bCharSetCurrent = ped->GetCharFormat(iFormatTemp)->_bCharSet;
if (IsFECharSet(bCharSetCurrent))
{
// Check if current font can handle this string.
INT cpgCurrent = GetCodePage(bCharSetCurrent);
INT cpgNew = VerifyFEString(cpgCurrent, pch, cch, FALSE);
if (cpgCurrent != cpgNew)
{
// Setup the new CodePage to handle this string
CCharFormat CF;
CCFRunPtr rp(_rpCF, ped);
rp.AdvanceCp(cpFirst - GetCp());
CF._bCharSet = GetCharSet(cpgNew);
if(rp.GetPreferredFontInfo(cpgNew, CF._bCharSet, CF._iFont, CF._yHeight,
CF._bPitchAndFamily, _iFormat, iMatchCurrent))
{
SetCharFormat(&CF, 0, publdr, CFM_CHARSET | CFM_FACE | CFM_SIZE,
CFM2_CHARFORMAT | CFM2_NOCHARSETCHECK);
}
}
}
}
cch = ReplaceRange(cch, pch, publdr, SELRR_REMEMBERRANGE, pcchMove, dwFlags);
}
if(dwCharFlags)
{
CCharFormat CF;
CCFRunPtr rp(_rpCF, ped);
rp.AdvanceCp(cpFirst - GetCp());
// If following string contains Hangul or Kana, use Korean or Japanese
// font signatures, respectively. Else use incoming dwCharFlags
dwCharFlags &= ~255;
if(dwCharFlags & fHANGUL)
dwCharFlags = fHANGUL;
else if(dwCharFlags & fKANA)
dwCharFlags = fKANA;
else if(dwCharFlags & fBIG5)
dwCharFlags = fBIG5;
else
Assert(!(dwCharFlags & fCHINESE) || dwCharFlags == (fCHINESE & ~255));
LONG i = W32->ScriptIndexFromFontSig(dwCharFlags >> 8);
CF._bCharSet = GetCharSet(i, NULL);
if(rp.GetPreferredFontInfo(i, CF._bCharSet, CF._iFont, CF._yHeight,
CF._bPitchAndFamily, (_cch ? -1 : _iFormat), iMatchCurrent))
{
SetCharFormat(&CF, 0, publdr, CFM_CHARSET | CFM_FACE | CFM_SIZE,
CFM2_CHARFORMAT | CFM2_NOCHARSETCHECK);
}
}
return cch;
}
/*
* CTxtRange::ReplaceRange(cchNew, *pch, publdr. selaemode, pcchMove)
*
* @mfunc
* Replace the text in this range by pch using CCharFormat _iFormat
* and updating other text runs as needed.
*
* @rdesc
* Count of new characters added
*
* @devnote
* moves this text pointer to end of replaced text and
* may move text block and formatting arrays
*/
LONG CTxtRange::ReplaceRange (
LONG cchNew, //@parm Length of replacement text
TCHAR const * pch, //@parm Replacement text
IUndoBuilder * publdr, //@parm UndoBuilder to receive antievents
SELRR selaemode, //@parm Controls how selection antievents are to be generated.
LONG* pcchMove, //@parm number of chars moved after replace
DWORD dwFlags) //@parm Special flags
{
TRACEBEGIN(TRCSUBSYSRANG, TRCSCOPEINTERN, "CTxtRange::ReplaceRange");
LONG lRet;
LONG iFormat = _iFormat;
BOOL fReleaseFormat = FALSE;
ICharFormatCache * pcf = GetCharFormatCache();
_TEST_INVARIANT_
if(!(cchNew | _cch)) // Nothing to add or delete,
{ // so we're done
if(pcchMove)
*pcchMove = 0;
return 0;
}
if(publdr && selaemode != SELRR_IGNORE)
{
Assert(selaemode == SELRR_REMEMBERRANGE);
HandleSelectionAEInfo(GetPed(), publdr, GetCp(), _cch,
GetCpMin() + cchNew, 0, SELAE_MERGE);
}
if(_cch > 0)
FlipRange();
// If we are replacing a non-degenerate selection, then the Word95
// UI specifies that we should use the rightmost formatting at cpMin.
if(_cch < 0 && _rpCF.IsValid() && !_fDualFontMode && !_fUseiFormat)
{
_rpCF.AdjustForward();
iFormat = _rpCF.GetFormat();
// This is a bit icky, but the idea is to stabilize the
// reference count on iFormat. When we get it above, it's
// not addref'ed, so if we happen to delete the text in the
// range and the range is the only one with that format,
// then the format will go away.
pcf->AddRef(iFormat);
fReleaseFormat = TRUE;
}
_fUseiFormat = FALSE;
LONG cchForReplace = -_cch;
_cch = 0;
lRet = CRchTxtPtr::ReplaceRange(cchForReplace, cchNew, pch, publdr,
iFormat, pcchMove, dwFlags);
if(lRet)
_fMoveBack = FALSE;
Update_iFormat(fReleaseFormat ? iFormat : -1);
if(fReleaseFormat)
{
Assert(pcf);
pcf->Release(iFormat);
}
return lRet;
}
/*
* CTxtRange::Delete(publdr. selaemode)
*
* @mfunc
* Delete text in this range.
*/
void CTxtRange::Delete (
IUndoBuilder * publdr, //@parm UndoBuilder to receive antievents
SELRR selaemode) //@parm Controls generation of selection antievents
{
TRACEBEGIN(TRCSUBSYSRANG, TRCSCOPEINTERN, "CTxtRange::Delete");
if(!_cch)
return; // Nothing to delete
if(!GetPed()->IsBiDi())
{
ReplaceRange(0, NULL, publdr, selaemode, NULL);
return;
}
CFreezeDisplay fd(GetPed()->_pdp);
ReplaceRange(0, NULL, publdr, selaemode);
}
/*
* CTxtRange::GetCharFormat(pCF, flags)
*
* @mfunc
* Set *pCF = CCharFormat for this range. If cbSize = sizeof(CHARFORMAT)
* only transfer CHARFORMAT data.
*
* @rdesc
* Mask of unchanged properties over range (for CHARFORMAT::dwMask)
*
* @devnote
* NINCH means No Input No CHange (a Microsoft Word term). Here used for
* properties that change during the range of cch characters. NINCHed
* properties in a Word-Font dialog have grayed boxes. They are indicated
* by zero values in their respective dwMask bit positions. Note that
* a blank at the end of the range does not participate in the NINCH
* test, i.e., it can have a different CCharFormat without zeroing the
* corresponding dwMask bits. This is done to be compatible with Word
* (see also CTxtSelection::SetCharFormat when _fWordSelMode is TRUE).
*/
DWORD CTxtRange::GetCharFormat (
CCharFormat *pCF, //@parm CCharFormat to fill with results
DWORD flags) const //@parm flags
{
TRACEBEGIN(TRCSUBSYSRANG, TRCSCOPEINTERN, "CTxtRange::GetCharFormat");
_TEST_INVARIANT_
CTxtEdit * const ped = GetPed();
if(!_cch || !_rpCF.IsValid()) // IP or invalid CF
{ // run ptr: use CF at
*pCF = *ped->GetCharFormat(_iFormat); // this text ptr
return CFM_ALL2;
}
LONG cpMin, cpMost; // Nondegenerate range:
LONG cch = GetRange(cpMin, cpMost); // need to scan
LONG cchChunk; // cch in CF run
DWORD dwMask = CFM_ALL2; // Initially all prop def'd
LONG iDirection; // Direction of scan
CFormatRunPtr rp(_rpCF); // Nondegenerate range
/*
* The code below reads character formatting the way Word does it,
* that is, by not including the formatting of the last character in the
* range if that character is a blank.
*
* See also the corresponding code in CTxtSelection::SetCharFormat().
*/
if(cch > 1 && _fSel && (flags & SCF_USEUIRULES))// If more than one char,
{ // don't include trailing
CTxtPtr tp(ped, cpMost - 1); // blank in NINCH test
if(tp.GetChar() == ' ')
{ // Have trailing blank:
cch--; // one less char to check
if(_cch > 0) // Will scan backward, so
rp.AdvanceCp(-1); // backup before blank
}
}
if(_cch < 0) // Setup direction and
{ // initial cchChunk
iDirection = 1; // Scan forward
rp.AdjustForward();
cchChunk = rp.GetCchLeft(); // Chunk size for _rpCF
}
else
{
iDirection = -1; // Scan backward
rp.AdjustBackward(); // If at BOR, go to
cchChunk = rp.GetIch(); // previous EOR
}
*pCF = *ped->GetCharFormat(rp.GetFormat()); // Initialize *pCF to
// starting format
while(cchChunk < cch) // NINCH properties that
{ // change over the range
cch -= cchChunk; // given by cch
if(!rp.ChgRun(iDirection)) // No more runs
break; // (cch too big)
cchChunk = rp.GetRun(0)->_cch;
const CCharFormat *pCFTemp = ped->GetCharFormat(rp.GetFormat());
dwMask &= ~pCFTemp->Delta(pCF, // NINCH properties that
flags & CFM2_CHARFORMAT); // changed, i.e., reset
} // corresponding bits
return dwMask;
}
/*
* CTxtRange::SetCharFormat(pCF, flags, publdr, dwMask, dwMask2)
*
* @mfunc
* apply CCharFormat *pCF to this range. If range is an insertion point,
* and (flags & SCF_WORD) != 0, then apply CCharFormat to word surrounding
* this insertion point
*
* @rdesc
* HRESULT = (successfully set whole range) ? NOERROR : S_FALSE
*
* @devnote
* SetParaFormat() is similar, but simpler, since it doesn't have to
* special case insertion-point ranges or worry about bullet character
* formatting, which is given by EOP formatting.
*/
HRESULT CTxtRange::SetCharFormat (
const CCharFormat *pCF, //@parm CCharFormat to fill with results
DWORD flags, //@parm SCF_WORD OR SCF_IGNORESELAE
IUndoBuilder *publdr, //@parm Undo builder to use
DWORD dwMask, //@parm CHARFORMAT2 mask
DWORD dwMask2) //@parm Second mask
{
TRACEBEGIN(TRCSUBSYSRANG, TRCSCOPEINTERN, "CTxtRange::SetCharFormat");
LONG cch = -_cch; // Defaults for _cch <= 0
LONG cchBack = 0; // cch to back up for formatting
LONG cchFormat; // cch for formatting
CCharFormat CF; // Temporary CF
LONG cp;
LONG cpMin, cpMost;
LONG cpStart = 0;
LONG cpWordMin, cpWordMost;
BOOL fApplyToEOP = FALSE;
BOOL fProtected = FALSE;
HRESULT hr = NOERROR;
LONG iCF;
CTxtEdit * const ped = GetPed(); // defined and not style
ICharFormatCache * pf = GetCharFormatCache();
CFreezeDisplay fd(ped->_pdp);
_TEST_INVARIANT_
if(!Check_rpCF()) // Not rich
return NOERROR;
if(_cch > 0) // Active end at range end
{
cchBack = -_cch; // Setup to back up to
cch = _cch; // start of format area
}
else if(_cch < 0)
_rpCF.AdjustForward();
else if(!cch && (flags & (SCF_WORD | SCF_USEUIRULES)))
{
BOOL fCheckEOP = TRUE;
if(flags & SCF_WORD)
{
FindWord(&cpWordMin, &cpWordMost, FW_EXACT);
// If nearest word is within this range, calculate cchback and cch
// so that we can apply the given format to the word
if(cpWordMin < GetCp() && GetCp() < cpWordMost)
{
// RichEdit 1.0 made 1 final check: ensure word's format
// is constant w.r.t. the format passed in
CTxtRange rg(*this);
rg.Set(cpWordMin, cpWordMin - cpWordMost);
fProtected = rg.WriteAccessDenied();
if(!fProtected && (rg.GetCharFormat(&CF) & dwMask) == dwMask)
{
cchBack = cpWordMin - GetCp();
cch = cpWordMost - cpWordMin;
}
fCheckEOP = FALSE;
}
}
if(fCheckEOP && _rpTX.IsAtEOP() && !GetPF()->_wNumbering)
{
CTxtPtr tp(_rpTX);
cch = tp.AdvanceCpCRLF();
_rpCF.AdjustForward(); // Go onto format EOP
fApplyToEOP = TRUE;
// Apply the characterset and face to EOP because EOP can be in any charset
dwMask2 |= CFM2_NOCHARSETCHECK;
}
}
cchFormat = cch;
BOOL fApplyStyle = pCF->fSetStyle(dwMask, dwMask2);
if(!cch) // Set degenerate-range (IP)
{ // CF
LApplytoIP:
DWORD dwMsk = dwMask;
dwMask2 |= CFM2_NOCHARSETCHECK;
CF = *ped->GetCharFormat(_iFormat); // Copy current CF at IP to CF
if ((CF._dwEffects & CFE_LINK) && // Don't allow our URL
ped->GetDetectURL()) // formatting to be changed
{
dwMsk &= ~CFM_LINK;
}
if(fApplyStyle)
CF.ApplyDefaultStyle(pCF->_sStyle);
hr = CF.Apply(pCF, dwMsk, dwMask2); // Apply *pCF
if(hr != NOERROR) // Cache result if new
return hr;
hr = pf->Cache(&CF, &iCF); // In any case, get iCF
if(hr != NOERROR) // (which AddRef's it)
return hr;
#ifdef LINESERVICES
if (g_pols)
g_pols->DestroyLine(NULL);
#endif
pf->Release(_iFormat);
_iFormat = iCF;
if(fProtected) // Signal to beep if UI
hr = S_FALSE;
}
else // Set nondegenerate-range CF
{ // Get start of affected area
CNotifyMgr *pnm = NULL;
if (!(flags & SCF_IGNORENOTIFY))
{
pnm = ped->GetNotifyMgr(); // Get the notification mgr
if(pnm)
{
cpStart = GetCp() + cchBack; // Bulletting may move
// affected area back if
if(GetPF()->_wNumbering) // formatting hits EOP that
{ // affects bullet at BOP
FindParagraph(&cpMin, &cpMost);
if(cpMost <= GetCpMost())
cpStart = cpMin;
}
pnm->NotifyPreReplaceRange(this, // Notify interested parties of
CP_INFINITE, 0, 0, cpStart, // the impending update
cpStart + cchFormat);
}
}
_rpCF.AdvanceCp(cchBack); // Back up to formatting start
CFormatRunPtr rp(_rpCF); // Clone _rpCF to walk range
cp = GetCp() + cchBack;
if(publdr)
{
LONG cchBackup = 0, cchAdvance = 0;
if (ped->IsBiDi())
{
CRchTxtPtr rtp(*this);
rtp._rpCF.AdvanceCp(-cchBack); // restore previous _rpCF
rtp.Advance(cchBack);
cchBackup = rtp.ExpandRangeFormatting(cch, 0, cchAdvance);
Assert(cchBackup >= 0);
}
rp.AdvanceCp(-cchBackup);
IAntiEvent *pae = gAEDispenser.CreateReplaceFormattingAE(
ped, rp, cch + cchBackup + cchAdvance, pf, CharFormat);
rp.AdvanceCp(cchBackup);
if(pae)
publdr->AddAntiEvent(pae);
}
// Following Word, we translate runs for 8-bit charsets to/from
// SYMBOL_CHARSET
LONG cchRun;
LONG cchTrans;
UINT CodePage = 0;
DWORD dwFontSig = 0;
DWORD dwMaskSave = dwMask;
DWORD dwMask2Save = dwMask2;
LONG cchSkip = 0;
BOOL fSymbolCharSet = IsSymbolOrOEM(pCF->_bCharSet);
BOOL fBiDiCharSet = IsBiDiCharSet(pCF->_bCharSet);
BOOL fFECharSet = IsFECharSet(pCF->_bCharSet);
BOOL fFontCheck = (dwMask2 & CFM2_MATCHFONT);
BOOL fInRange;
CTxtPtr tp(_rpTX);
if(fFontCheck && !fSymbolCharSet)
{
GetFontSignatureFromFace(pCF->_iFont, &dwFontSig);
if(!dwFontSig)
dwFontSig = GetFontSig(pCF->_bCharSet);
}
if (ped->_fIMEInProgress && !(dwMask2 & CFM2_SCRIPT))
dwMask2 |= CFM2_NOCHARSETCHECK; // Don't check charset or it will display garbage
while(cch > 0 && rp.IsValid())
{
CF = *ped->GetCharFormat(rp.GetFormat());// Copy rp CF to temp CF
if(fApplyStyle)
CF.ApplyDefaultStyle(pCF->_sStyle);
cchRun = cch;
if (CF._dwEffects & CFE_RUNISDBCS)
{
// Don't allow charset/face name change for DBCS run
// causing these are garbage characters
dwMask &= ~(CFM_CHARSET | CFM_FACE);
}
else if(fFontCheck) // Only apply font if it
{ // supports run's charset
cchRun = rp.GetCchLeft(); // Translate up to end of
cchRun = min(cch, cchRun); // current CF run
dwMask &= ~CFM_CHARSET; // Default no charset change
if(cchSkip)
{ // Skip cchSkip chars (were
cchRun = cchSkip; // not translatable with
cchSkip = 0; // CodePage)
}
else if(fSymbolCharSet ^ IsSymbolOrOEM(CF._bCharSet))
{ // SYMBOL to/from nonSYMBOL
CodePage = GetCodePage(fSymbolCharSet ? CF._bCharSet : pCF->_bCharSet);
if(!Is8BitCodePage(CodePage))
goto DoASCII;
dwMask |= CFM_CHARSET; // Need to change charset
if(fSymbolCharSet)
CF._wCodePageSave = CodePage;
else if(Is8BitCodePage(CF._wCodePageSave))
{
CodePage = CF._wCodePageSave;
CF._bCharSet = GetCharSet(CodePage);
dwMask &= ~CFM_CHARSET; // Already changed
}
tp.SetCp(cp); // Point tp at start of run
cchTrans = tp.TranslateRange(cchRun, CodePage, fSymbolCharSet,
publdr /*, cchSkip */);
if(cchTrans < cchRun) // Ran into char not in
{ // CodePage, so set up to
cchSkip = 1; // skip the char
cchRun = cchTrans; // FUTURE: use cchSkip out
if(!cchRun) // parm from TranslateRange
continue; // instead of skipping 1 char
} // at a time
}
else if(!fSymbolCharSet)
{
DoASCII: tp.SetCp(cp); // Point tp at start of run
fInRange = tp.GetChar() < 0x80;
if (!fBiDiCharSet && !IsBiDiCharSet(CF._bCharSet) &&
fInRange &&
((dwFontSig & fASCII >> 8) == fASCII >> 8 || fFECharSet || fSymbolCharSet))
{
// ASCII text and new font supports ASCII
// -FUTURE-
// We exlude BiDi here. We cannot allow applying BiDi charset to non-BiDi run or vice versa.
// This because we use charset for BiDi reordering. In the future we should
// evolve to something more elegant than charset.
if (!(GetFontSig(CF._bCharSet) & ~(fASCII >> 8) & dwFontSig))
// New font doesnt support underlying charset,
// apply new charset to ASCII
dwMask |= CFM_CHARSET;
}
else if (!(GetFontSig(CF._bCharSet) & ~(fASCII >> 8) & dwFontSig))
// New font doesnt support underlying charset,
// suppress both new charset and facename
dwMask &= ~CFM_FACE;
cchRun -= tp.MoveWhile(cchRun, 0, 0x7F, fInRange);
}
}
hr = CF.Apply(pCF, dwMask, dwMask2);// Apply *pCF
if(hr != NOERROR)
return hr;
dwMask = dwMaskSave; // Restore mask in case
dwMask2 = dwMask2Save; // changed above
hr = pf->Cache(&CF, &iCF); // Cache result if new, In any
if(hr != NOERROR) // cause, use format index iCF
break;
#ifdef LINESERVICES
if (g_pols)
g_pols->DestroyLine(NULL);
#endif
cchRun = rp.SetFormat(iCF, cchRun, pf);// Set format for this run
// Proper levels will be generated later by BiDi FSM.
pf->Release(iCF); // Release count from Cache above
// rp.SetFormat AddRef's as needed
if(cchRun == CP_INFINITE)
{
ped->GetCallMgr()->SetOutOfMemory();
break;
}
cp += cchRun;
cch -= cchRun;
}
_rpCF.AdjustBackward(); // Expand scope for merging
rp.AdjustForward(); // runs
rp.MergeRuns(_rpCF._iRun, pf); // Merge adjacent runs that
// have the same format
if(cchBack) // Move _rpCF back to where it
_rpCF.AdvanceCp(-cchBack); // was
else // Active end at range start:
_rpCF.AdjustForward(); // don't leave at EOR
if(pnm)
{
pnm->NotifyPostReplaceRange(this, // Notify interested parties
CP_INFINITE, 0, 0, cpStart, // of the change.
cpStart + cchFormat - cch);
}
if(publdr && !(flags & SCF_IGNORESELAE))
{
HandleSelectionAEInfo(ped, publdr, GetCp(), _cch, GetCp(), _cch,
SELAE_FORCEREPLACE);
}
if(!_cch) // In case IP with ApplyToWord
{
if(fApplyToEOP) // Formatting EOP only
goto LApplytoIP;
Update_iFormat(-1);
}
if (ped->IsRich())
ped->GetCallMgr()->SetChangeEvent(CN_GENERIC);
}
if(_fSel && ped->IsRich() && !ped->_f10Mode /*bug fix #5211*/)
ped->GetCallMgr()->SetSelectionChanged();
AssertSz(GetCp() == (cp = _rpCF.CalculateCp()),
"RTR::SetCharFormat(): incorrect format-run ptr");
if (!(dwMask2 & (CFM2_SCRIPT | CFM2_HOLDITEMIZE)) && cchFormat && hr == NOERROR && !cch)
{
// A non-degenerate range not coming from ItemizeRuns
// It's faster to make a copy pointer since we dont need to worry about fExtend.
CRchTxtPtr rtp(*this);
rtp.Advance(cchBack + cchFormat);
rtp.ItemizeReplaceRange(cchFormat, 0, publdr);
return hr;
}
return (hr == NOERROR && cch) ? S_FALSE : hr;
}
/*
* CTxtRange::GetParaFormat(pPF)
*
* @mfunc
* return CParaFormat for this text range. If no PF runs are allocated,
* then return default CParaFormat
*
* @rdesc
* Mask of defined properties: 1 bit means corresponding property is
* defined and constant throughout range. 0 bit means it isn't constant
* throughout range. Note that PARAFORMAT has fewer relevant bits
* (PFM_ALL vs PFM_ALL2)
*/
DWORD CTxtRange::GetParaFormat (
CParaFormat *pPF, //@parm ptr to CParaFormat to be filled
DWORD flags) const // be filled with possibly NINCH'd values
{
TRACEBEGIN(TRCSUBSYSRANG, TRCSCOPEINTERN, "CTxtRange::GetParaFormat");
CTxtEdit * const ped = GetPed();
_TEST_INVARIANT_
DWORD dwMask = flags & PFM_PARAFORMAT // Default presence of
? PFM_ALL : PFM_ALL2; // all properties
CFormatRunPtr rp(_rpPF);
LONG cch = -_cch;
if(cch < 0) // At end of range:
{ // go to start of range
rp.AdvanceCp(cch);
cch = -cch; // Count with cch > 0
}
*pPF = *ped->GetParaFormat(rp.GetFormat()); // Initialize *pPF to
// starting paraformat
if(!cch || !rp.IsValid()) // No cch or invalid PF
return dwMask; // run ptr: use PF at
// this text ptr
LONG cchChunk = rp.GetCchLeft(); // Chunk size for rp
while(cchChunk < cch) // NINCH properties that
{ // change over the range
cch -= cchChunk; // given by cch
if(!rp.NextRun()) // Go to next run // No more runs
break; // (cch too big)
cchChunk = rp.GetCchLeft();
dwMask &= ~ped->GetParaFormat(rp.GetFormat())// NINCH properties that
->Delta(pPF, flags & PFM_PARAFORMAT); // changed, i.e., reset
} // corresponding bits
return dwMask;
}
/*
* CTxtRange::SetParaFormat(pPF, publdr, dwMask)
*
* @mfunc
* apply CParaFormat *pPF to this range.
*
* @rdesc
* if successfully set whole range, return NOERROR, otherwise
* return error code or S_FALSE.
*/
HRESULT CTxtRange::SetParaFormat (
const CParaFormat* pPF, //@parm CParaFormat to apply to this range
IUndoBuilder *publdr, //@parm Undo context for this operation
DWORD dwMask) //@parm Mask to use
{
TRACEBEGIN(TRCSUBSYSRANG, TRCSCOPEINTERN, "CTxtRange::SetParaFormat");
LONG cch; // Length of text to format
LONG cchBack; // cch to back up for formatting
LONG cp;
LONG cpMin, cpMost; // Limits of text to format
LONG delta;
HRESULT hr = NOERROR;
LONG iPF = 0; // Lndex to a CParaFormat
CTxtEdit * const ped = GetPed();
CParaFormat PF; // Temporary CParaFormat
IParaFormatCache * pf = GetParaFormatCache();// Format cache ptr for Cache,
// AddRefFormat, ReleaseFormat
CBiDiLevel* pLevel;
CBiDiLevel lvRTL = {1, 0};
CBiDiLevel lvLTR = {0, 0};
CFreezeDisplay fd(ped->_pdp);
_TEST_INVARIANT_
if(!Check_rpPF())
return E_FAIL;
FindParagraph(&cpMin, &cpMost); // Get limits of text to
cch = cpMost - cpMin; // format, namely closest
CNotifyMgr *pnm = ped->GetNotifyMgr();
if(pnm)
{
pnm->NotifyPreReplaceRange(this, // Notify interested parties of
CP_INFINITE, 0, 0, cpMin, cpMost); // the impending update
}
cchBack = cpMin - GetCp();
_rpPF.AdvanceCp(cchBack); // Back up to formatting start
CFormatRunPtr rp(_rpPF); // Clone _rpPF to walk range
if(publdr)
{
IAntiEvent *pae = gAEDispenser.CreateReplaceFormattingAE(ped,
rp, cch, pf, ParaFormat);
if(pae)
publdr->AddAntiEvent(pae);
}
const CParaFormat* pPFCurrent; // PF at current runptr
BOOL fLevelChanged = FALSE;
BOOL fFullyDefined = FALSE; // Default input PF not fully defined
if (ped->HandleStyle(&PF, pPF, dwMask) == NOERROR &&
pf->Cache(&PF, &iPF) == NOERROR)
{
fFullyDefined = TRUE;
}
do
{
WORD wEffectsCurrent;
pPFCurrent = ped->GetParaFormat(rp.GetFormat());// Get current PF
wEffectsCurrent = pPFCurrent->_wEffects;// Save current effect so we don't
// need to use pPFCurrent because it may
// become invalid after a PF.Apply.
if(!fFullyDefined) // If pPF doesn't specify
{ // full PF, fill in undefined
PF = *pPFCurrent;
hr = PF.Apply(pPF, dwMask); // Apply *pPF
if(hr != NOERROR) // (Probably E_INVALIDARG)
break; // Cache result if new; in any
hr = pf->Cache(&PF, &iPF); // case, get format index iPF
if(hr != NOERROR) // Can't necessarily return
break; // error, since may need
}
if (!fLevelChanged)
fLevelChanged = (wEffectsCurrent ^ PF._wEffects) & PFE_RTLPARA;
pLevel = PF.IsRtlPara() ? &lvRTL : &lvLTR;
delta = rp.SetFormat(iPF, cch, pf, pLevel); // Set format for this run
if(!fFullyDefined) // Release count from Cache above
pf->Release(iPF); // rp.SetFormat AddRefs as needed
if(delta == CP_INFINITE)
{
ped->GetCallMgr()->SetOutOfMemory();
break;
}
cch -= delta;
} while (cch > 0) ;
if(fFullyDefined)
pf->Release(iPF); // Release count from Cache above
_rpPF.AdjustBackward(); // If at BOR, go to prev EOR
rp.MergeRuns(_rpPF._iRun, pf); // Merge any adjacent runs
// that have the same format
if(cchBack) // Move _rpPF back to where it
_rpPF.AdvanceCp(-cchBack); // was
else // Active end at range start:
_rpPF.AdjustForward(); // don't leave at EOR
if(pnm)
{
pnm->NotifyPostReplaceRange(this, // Notify interested parties of
CP_INFINITE, 0, 0, cpMin, cpMost); // the update
}
if(publdr)
{
// Paraformatting works a bit differently, it just remembers the
// current selection. Cast selection to range to avoid including
// _select.h; we only need range methods.
CTxtRange *psel = (CTxtRange *)GetPed()->GetSel();
if(psel)
{
cp = psel->GetCp();
HandleSelectionAEInfo(ped, publdr, cp, psel->GetCch(),
cp, psel->GetCch(), SELAE_FORCEREPLACE);
}
}
ped->GetCallMgr()->SetChangeEvent(CN_GENERIC);
AssertSz(GetCp() == (cp = _rpPF.CalculateCp()),
"RTR::SetParaFormat(): incorrect format-run ptr");
if (fLevelChanged && cpMost > cpMin)
{
ped->OrCharFlags(fBIDI, publdr);
// make sure the CF is valid
Check_rpCF();
CTxtRange rg(*this);
if (publdr)
{
// create anti-events to keep BiDi level of paragraphs in need
//
ICharFormatCache* pcfc = GetCharFormatCache();
CFormatRunPtr rp(_rpCF);
rp.AdvanceCp(cpMin - _rpTX.GetCp());
IAntiEvent *pae = gAEDispenser.CreateReplaceFormattingAE (
ped, rp, cpMost - cpMin, pcfc, CharFormat);
if (pae)
publdr->AddAntiEvent(pae);
}
rg.Set(cpMost, cpMost - cpMin);
rg.ItemizeRuns (publdr);
}
return (hr == NOERROR && cch) ? S_FALSE : hr;
}
/*
* CTxtRange::SetParaStyle(pPF, publdr, dwMask)
*
* @mfunc
* apply CParaFormat *pPF using the style pPF->sStyle to this range.
*
* @rdesc
* if successfully set whole range, return NOERROR, otherwise
* return error code or S_FALSE.
*
* @comm
* If pPF->dwMask & PFM_STYLE is nonzero, this range is expanded to
* complete paragraphs. If it's zero, this call just passes control
* to CTxtRange::SetParaStyle().
*/
HRESULT CTxtRange::SetParaStyle (
const CParaFormat* pPF, //@parm CParaFormat to apply to this range
IUndoBuilder *publdr, //@parm Undo context for this operation
DWORD dwMask) //@parm Mask to use
{
LONG cchSave = _cch; // Save range cp and cch in case
LONG cpSave = GetCp(); // para expand needed
HRESULT hr;
if(publdr)
publdr->StopGroupTyping();
if(pPF->fSetStyle(dwMask))
{
CCharFormat CF; // Need to apply associated CF
LONG cpMin, cpMost;
Expander(tomParagraph, TRUE, NULL, &cpMin, &cpMost);
CF._sStyle = pPF->_sStyle;
hr = SetCharFormat(&CF, 0, publdr, CFM_STYLE, 0);
if(hr != NOERROR)
return hr;
}
hr = SetParaFormat(pPF, publdr, dwMask);
Set(cpSave, cchSave); // Restore this range in case expanded
return hr;
}
/*
* CTxtRange::Update_iFormat(iFmtDefault)
*
* @mfunc
* update _iFormat to CCharFormat at current active end
*
* @devnote
* _iFormat is only used when the range is degenerate
*
* The Word 95 UI specifies that the *previous* format should
* be used if we're in at an ambiguous cp (i.e. where a formatting
* change occurs) _unless_ the previous character is an EOP
* marker _or_ if the previous character is protected.
*/
void CTxtRange::Update_iFormat (
LONG iFmtDefault) //@parm Format index to use if _rpCF isn't valid
{
TRACEBEGIN(TRCSUBSYSRANG, TRCSCOPEINTERN, "CTxtRange::Update_iFormat");
DWORD dwEffects;
LONG ifmt, iFormatForward;
const CCharFormat *pCF, *pCFForward;
if(_cch)
return;
_fSelHasEOP = FALSE; // Empty ranges don't contain
_fSelHasCell = FALSE; // anything, incl EOPs/cells
if(_fDontUpdateFmt) // _iFormat is only used
return; // for degenerate ranges
if(_rpCF.IsValid() && iFmtDefault == -1)
{
// Get forward info before possibly adjusting backward
_rpCF.AdjustForward();
ifmt = iFormatForward = _rpCF.GetFormat();
pCF = pCFForward = GetPed()->GetCharFormat(ifmt);
dwEffects = pCF->_dwEffects;
if(!_rpTX.IsAfterEOP())
{
_rpCF.AdjustBackward(); // Adjust backward
ifmt = _rpCF.GetFormat();
pCF = GetPed()->GetCharFormat(ifmt);
dwEffects = pCF->_dwEffects;
}
if (!(GetPed()->_fIMEInProgress)) // Dont change fomrat during IME
{
if(!_rpTX.GetCp() && (pCF->_dwEffects & CFE_RUNISDBCS))
{
// If at beginning of document, and text is protected, just use
// default format.
ifmt = iFmtDefault;
}
else if(dwEffects & (CFE_PROTECTED | CFE_LINK | CFE_HIDDEN | CFE_RUNISDBCS))
{
// If range is protected or a hyperlink, pick forward format
ifmt = iFormatForward;
}
else if(ifmt != iFormatForward && _fMoveBack &&
IsRTLCharSet(pCF->_bCharSet) != IsRTLCharSet(pCFForward->_bCharSet))
{
ifmt = iFormatForward;
}
}
iFmtDefault = ifmt;
}
// Don't allow _iFormat to include CFE_LINK or CFE_HIDDEN attributes
// unless they're the default
if(iFmtDefault != -1)
{
pCF = GetPed()->GetCharFormat(iFmtDefault);
if(pCF->_dwEffects & (CFE_LINK | CFE_HIDDEN))
{
CCharFormat CF = *pCF;
CF._dwEffects &= ~(CFE_LINK | CFE_HIDDEN);
// This range must be an insertion point!
Assert(_cch == 0);
SetCharFormat(&CF, FALSE, NULL, CFM_ALL2, 0);
return;
}
}
Set_iCF(iFmtDefault);
}
/*
* CTxtRange::GetCharSetMask(fUseDocFormat)
*
* @mfunc
* Get this range's charset mask corresponding to _iFormat.
* If fUseDocFormat is TRUE, then use -1 instead of _iFormat.
*
* @rdesc
* charset mask for range or default document
*/
DWORD CTxtRange::GetCharSetMask(
BOOL fUseDocFormat)
{
LONG iFormat = fUseDocFormat ? -1 : GetiFormat();
DWORD dwMask = GetFontSig((GetPed()->GetCharFormat(iFormat))->_bCharSet) << 8;
if(dwMask & fSYMBOL)
return dwMask;
// For now, Indic fonts match only ASCII digits
dwMask |= fBELOWX40;
if (dwMask < fDEVANAGARI)
dwMask |= fASCII; // fASCIIUPR+fBELOWX40
if ((dwMask & (fKANA | fHANGUL | fCHINESE | fBIG5))
&& W32->IsFESystem() ) // For FE systems
dwMask |= fOTHER; // match fOTHER
else if(dwMask & fLATIN)
dwMask |= fCOMBINING;
return dwMask;
}
/*
* CTxtRange::GetiFormat()
*
* @mfunc
* Return (!_cch || _fUseiFormat) ? _iFormat : iFormat at cpMin
*
* @rdesc
* iFormat at cpMin if nondegenerate and !_fUseiFormat; else _iFormat
*
* @devnote
* This routine doesn't AddRef iFormat, so it shouldn't be used if
* it needs to be valid after character formatting has changed, e.g.,
* by ReplaceRange or SetCharFormat or SetParaStyle
*/
LONG CTxtRange::GetiFormat() const
{
if(!_cch || _fUseiFormat)
return _iFormat;
if(_cch > 0)
{
CFormatRunPtr rp(_rpCF);
rp.AdvanceCp(-_cch);
return rp.GetFormat();
}
return _rpCF.GetFormat();
}
/*
* CTxtRange::Get_iCF()
*
* @mfunc
* Get this range's _iFormat (AddRef'ing, of course)
*
* @devnote
* Get_iCF() is used by the RTF reader
*/
LONG CTxtRange::Get_iCF ()
{
TRACEBEGIN(TRCSUBSYSRANG, TRCSCOPEINTERN, "CTxtRange::Get_iCF");
GetCharFormatCache()->AddRef(_iFormat);
return _iFormat;
}
/*
* CTxtRange::Set_iCF(iFormat)
*
* @mfunc
* Set range's _iFormat to iFormat, AddRefing and Releasing as required.
*
* @rdesc
* TRUE if _iFormat changed
*/
BOOL CTxtRange::Set_iCF (
LONG iFormat) //@parm Index of char format to use
{
TRACEBEGIN(TRCSUBSYSRANG, TRCSCOPEINTERN, "CTxtRange::Set_iCF");
if(iFormat == _iFormat)
return FALSE;
ICharFormatCache *pCFC = GetCharFormatCache();
pCFC->AddRef(iFormat);
pCFC->Release(_iFormat); // Note: _iFormat = -1 doesn't
_iFormat = iFormat; // get AddRef'd or Release'd
AssertSz(GetCF(), "CTxtRange::Set_iCF: illegal format");
return TRUE;
}
/*
* CTxtRange::Get_iPF()
*
* @mfunc
* Get paragraph format at active end
*
* @devnote
* Get_iPF() is used by the RTF reader on encountering a start group
*/
LONG CTxtRange::Get_iPF ()
{
TRACEBEGIN(TRCSUBSYSRANG, TRCSCOPEINTERN, "CTxtRange::Get_iPF");
LONG iPF = _rpPF.GetFormat();
GetParaFormatCache()->AddRef(iPF);
return iPF;
}
/*
* CTxtRange::BiDiLevelFromFSM(pFSM)
*
* @mfunc
* Run BiDi FSM to generate proper embedding level for runs
*
* @rdesc
* HRESULT
*/
HRESULT CTxtRange::BiDiLevelFromFSM (
const CBiDiFSM* pFSM) // in: ptr to FSM
{
AssertSz(pFSM && _rpCF.IsValid(), "Not enough information to run BiDi FSM");
LONG cpMin, cpMost, cp, cchLeft;
LONG ich, cRunsStart, cRuns = 0;
HRESULT hr = S_OK;
GetRange(cpMin, cpMost);
AssertSz (cpMost - cpMin > 0, "FSM: Invalid range");
CRchTxtPtr rtp(*this);
rtp.Advance(cpMin - rtp.GetCp()); // initiate position to cpMin
CFormatRunPtr rpPF(rtp._rpPF); // pointer to current paragraph
cchLeft = cpMost - cpMin;
cp = cpMin;
while (cchLeft > 0 && SUCCEEDED(hr))
{
// accumulate runs within the same paragraph level
cRuns = GetRunsPF(&rtp, &rpPF, cchLeft);
cRunsStart = 0; // assume no start run
ich = rtp.Advance(-rtp.GetIchRunCF()); // locate preceding run
rtp._rpCF.AdjustBackward(); // adjusting format backward
rtp._rpPF.AdjustBackward(); // adjusting format backward
if(rtp._rpPF.SameLevel(&rpPF))
{
// start at the beginning of preceding run
if (rtp.Advance(-rtp.GetCchRunCF()))
cRunsStart++;
}
else
{
// preceding run is not at the same paragraph level, resume position
rtp.Advance(-ich);
}
rtp._rpCF.AdjustForward(); // make sure we have forward run pointers
rtp._rpPF.AdjustForward();
// Run FSM for the number of runs in multiple paragraphs with the same level
hr = pFSM->RunFSM(&rtp, cRuns, cRunsStart, rtp.IsParaRTL() ? 1 : 0);
cp = cpMost - cchLeft;
rtp.Advance(cp - rtp.GetCp()); // Advance to next paragraph(s)
rpPF = rtp._rpPF; // paragraph format at cp
}
AssertSz (cp == cpMost , "Running BiDi FSM partially done!");
_rpCF = rtp._rpCF; // We may have splitted CF runs
return hr;
}
/*
* CTxtRange::GetRunsPF(prtp, prpPF, cchLeft)
*
* @mfunc
* Get the number of CF runs within the same paragraph's base level.
* Its scope could cover multiple paragraphs. As long as they are in the
* same level, we can run them through the FSM in one go.
*
*/
LONG CTxtRange::GetRunsPF(
CRchTxtPtr* prtp, // in: RichText ptr to the first run in range
CFormatRunPtr* prpPF, // in: Pointer to current paragraph run
LONG& cchLeft) // in/out: number of char left
{
Assert (prtp && prtp->_rpPF.SameLevel(prpPF) && cchLeft > 0);
LONG cRuns = 0;
LONG cchRun, cchText = cchLeft;
ICharFormatCache* pf = GetCharFormatCache();
// check if the first CF run is PF bound
//
prtp->_rpPF.AdjustBackward();
if (prtp->GetIchRunCF() > 0 && !prtp->_rpPF.SameLevel(prpPF))
prtp->_rpCF.SplitFormat(pf); // PF breaks inside a CF run, split the run
prtp->_rpPF.AdjustForward(); // make sure we are all forward.
prtp->_rpCF.AdjustForward();
while (cchText > 0)
{
cchRun = min(prtp->GetCchLeftRunPF(), prtp->GetCchLeftRunCF());
cchRun = min(cchText, cchRun); // find out the nearest hop
cchText -= cchRun;
prtp->Advance(cchRun); // to the next hop
if (!prtp->_rpPF.SameLevel(prpPF))
{ // this is a para with different level
prtp->_rpCF.SplitFormat(pf); // split that CF run
cRuns++; // count the splitted
break; // and we're done
}
if (!cchText || // this is the last hop -or-
!prtp->GetIchRunCF() || // we're at the start or the end of a CF run
!prtp->GetCchLeftRunCF())
{
cRuns++; // count this hop
}
}
prtp->Advance(cchText - cchLeft); // resume position
cchLeft = cchText; // update number of char left
return cRuns;
}
/*
* CTxtRange::SpanSubstringDir (pusp, prtp, cchString, puInitLevel, pfNumericFound)
*
* @mfunc
* Span the run of text bound by or contains only block separators
* and share the same charset directionality.
*
* @rdesc
* number of span'ed text characters
*
*/
LONG CTxtRange::SpanSubstring(
CUniscribe* pusp, // in: Uniscribe interface
CFormatRunPtr* prp, // in: Format run pointer
WCHAR* pwchString, // in: Input string
LONG cchString, // in: String character count
WORD& uSubStrLevel, // in/out: BiDi substring initial level
DWORD dwInFlags, // in: Input flags
CCharFlags* pCharflags, // out:Output charflags
WORD& wBiDiLangId) // out:The primary language of a BiDi run
{
Assert (pusp && cchString > 0 && prp && prp->IsValid());
LONG cch, cchLeft;
cch = cchLeft = cchString;
wBiDiLangId = LANG_NEUTRAL; // assume unknown
if (dwInFlags & SUBSTR_INSPANCHARSET)
{
// span runs with same charset's direction
CTxtEdit* ped = GetPed();
CFormatRunPtr rp(*prp);
const CCharFormat* pCF;
BOOL fNext;
BYTE bCharSet1, bCharSet2;
rp.AdjustForward();
pCF = ped->GetCharFormat(rp.GetFormat());
bCharSet1 = bCharSet2 = pCF->_bCharSet;
while (!(bCharSet1 ^ bCharSet2))
{
cch = min(rp.GetCchLeft(), cchLeft);
cchLeft -= cch;
if (!(fNext = rp.NextRun()) || !cchLeft)
break;
bCharSet1 = bCharSet2;
pCF = ped->GetCharFormat(rp.GetFormat());
bCharSet2 = pCF->_bCharSet;
}
uSubStrLevel = IsBiDiCharSet(bCharSet1) ? 1 : 0;
if (uSubStrLevel & 1)
wBiDiLangId = bCharSet1 == ARABIC_CHARSET ? LANG_ARABIC : LANG_HEBREW;
cchString -= cchLeft;
cch = cchString;
dwInFlags |= SUBSTR_INSPANBLOCK;
}
if (dwInFlags & SUBSTR_INSPANBLOCK)
{
// scan the whole substring to collect information about it
DWORD dwBS = IsEOP(*pwchString) ? 1 : 0;
BYTE bCharMask;
cch = 0;
if (pCharflags)
pCharflags->_bFirstStrong = pCharflags->_bContaining = 0;
while (cch < cchString && !((IsEOP(pwchString[cch]) ? 1 : 0) ^ dwBS))
{
if (!dwBS && pCharflags)
{
bCharMask = 0;
switch (MECharClass(pwchString[cch]))
{
case CC_ARABIC:
case CC_HEBREW:
case CC_RTL:
bCharMask = SUBSTR_OUTCCRTL;
break;
case CC_LTR:
bCharMask = SUBSTR_OUTCCLTR;
default:
break;
}
if (bCharMask)
{
if (!pCharflags->_bFirstStrong)
pCharflags->_bFirstStrong |= bCharMask;
pCharflags->_bContaining |= bCharMask;
}
}
cch++;
}
}
return cch;
}
/*
* CTxtRange::ItemizeRuns(publdr, fUnicodeBidi, iCtxBaseLevel)
*
* @mfunc
* Break text range into smaller run(s) containing
*
* 1. Script ID for complex script shaping
* 2. Charset for run internal direction
* 3. BiDi embedding level
*
* @rdesc
* TRUE iff one or more items found.
* The range's active end will be at cpMost upon return.
*
* @devnote
* This routine could handle mixed paragraph runs
*/
BOOL CTxtRange::ItemizeRuns(
IUndoBuilder *publdr, //@parm Undo context for this operation
BOOL fUnicodeBiDi, //@parm TRUE: Caller needs Bidi algorithm
BOOL fUseCtxLevel) //@parm Itemize using context based level (only valid if fUnicodeBiDi is true)
{
LONG cchString;
int cItems = 0;
LONG cpMin, cpMost;
CTxtEdit* ped = GetPed();
CFreezeDisplay fd(ped->_pdp); // Freeze display
int i;
BYTE pbBufIn[MAX_CLIENT_BUF];
PUSP_CLIENT pc = NULL;
const CBiDiFSM* pFSM;
SCRIPT_ITEM* psi;
CUniscribe* pusp;
CTxtPtr tp(_rpTX);
LONG cp, cch, cchSave;
HRESULT hr = E_FAIL;
CCharFormat CF;
BOOL fWhiteChunk; // Chunk contains only whitespaces
WCHAR* pwchString;
WORD uSubStrLevel; // Substring initial level
WORD uParaLevel; // Paragraph initial level
CNotifyMgr* pnm = NULL; // Notification manager
BOOL fRunUnicodeBiDi;
BOOL fStreaming = ped->IsStreaming();
BOOL fChangeCharSet = FALSE;
CCharFlags charflags = {0};
WORD wBiDiLangId;
#ifdef DEBUG
LONG cchText = tp.GetTextLength();
#endif
// Get range and setup text ptr to the start
//
cch = cchString = GetRange(cpMin, cpMost);
if (!cch)
return FALSE;
tp.SetCp(cpMin);
// prepare Uniscribe
pusp = ped->Getusp();
if (!pusp)
goto Exit;
// allocate temp buffer for itemization
pusp->CreateClientStruc(pbBufIn, MAX_CLIENT_BUF, &pc, cchString, cli_Itemize);
if (!pc)
goto Exit;
Assert (tp.GetCp() == cpMin);
if(pnm = ped->GetNotifyMgr())
pnm->NotifyPreReplaceRange(this, CP_INFINITE, 0, 0, cpMin, cpMost);
cp = cpMin; // Set cp starting point at cpMin
Set(cp, 0); // equals to Collapser(tomStart)
SetExtend(TRUE);
Check_rpCF(); // Make sure _rpCF is valid
Check_rpPF(); // _rpPF too
// Always run UnicodeBidi for plain text control
// (2.1 backward compatible)
//
if (!ped->IsRich())
{
fUnicodeBiDi = TRUE;
fUseCtxLevel = FALSE;
}
uSubStrLevel = uParaLevel = IsParaRTL() ? 1 : 0; // initialize substring level
pwchString = pc->si->pwchString;
tp.GetTextForUsp(cchString, pwchString, ped->_fNeutralOverride);
while ( cchString > 0 &&
((cch = SpanSubstring(pusp, &_rpCF, pwchString, cchString, uSubStrLevel,
fUnicodeBiDi ? SUBSTR_INSPANBLOCK : SUBSTR_INSPANCHARSET,
(fStreaming || fUseCtxLevel) ? &charflags : NULL,
wBiDiLangId)) > 0) )
{
cchSave = cch;
fWhiteChunk = FALSE;
if (uSubStrLevel ^ uParaLevel)
{
// Handle Bidi spaces when substring level counters paragraph base direction.
// Spanning leading spaces
cch = 0;
while (cch < cchSave && pwchString[cch] == 0x20)
cch++;
if (cch)
fWhiteChunk = TRUE;
else
{
// Trimming out trailing whitespaces (including CR)
cch = cchSave;
while (cch > 0 && IsWhiteSpace(pwchString[cch-1]))
cch--;
if (!cch)
cch = cchSave;
}
Assert(cch > 0);
}
// Itemize with Unicode Bidi algorithm when
// a. Plain text mode
// b. Caller wants (fUnicodeBidi != 0)
// c. Substring is RTL.
//
fRunUnicodeBiDi = fUnicodeBiDi || uSubStrLevel;
fChangeCharSet = fUnicodeBiDi;
if (!fUnicodeBiDi && uSubStrLevel == 1 && fStreaming)
{
// During RTF streaming if the RTL run contains strong LTR,
// we resolve them using the paragraph base level
if (charflags._bContaining & SUBSTR_OUTCCLTR)
uSubStrLevel = uParaLevel;
fChangeCharSet = TRUE;
}
// Caller wants context based level.
// We want to itemize incoming plain text (into richtext doc) with the base level
// of the first strong character found in each substrings (wchao - 7/15/99)
//
if (fUnicodeBiDi && fUseCtxLevel && charflags._bFirstStrong)
uSubStrLevel = (WORD)(charflags._bFirstStrong & SUBSTR_OUTCCRTL ? 1 : 0);
if (fWhiteChunk || pusp->ItemizeString (pc, uSubStrLevel, &cItems, pwchString, cch,
fRunUnicodeBiDi, wBiDiLangId) > 0)
{
const SCRIPT_PROPERTIES* psp;
DWORD dwMask1;
BYTE bCharSetDefault = ped->GetCharFormat(-1)->_bCharSet;
psi = pc->si->psi;
if (fWhiteChunk)
{
cItems = 1;
psi[0].a.eScript = SCRIPT_WHITE;
psi[0].iCharPos = 0;
psi[1].iCharPos = cch;
}
Assert(cItems > 0);
// process items
//
for (i=0; i < cItems; i++)
{
cp += psi[i+1].iCharPos - psi[i].iCharPos;
AssertNr (cp <= cchText);
SetCp(min(cp, cpMost));
dwMask1 = 0;
// Associate the script properties
psp = pusp->GeteProp(psi[i].a.eScript);
Assert (psp);
if (!psp->fComplex && !psp->fNumeric &&
!psi[i].a.fRTL && psi[i].a.eScript < SCRIPT_MAX_COUNT)
{
// Note: Value 0 here is a valid script ID (SCRIPT_UNDEFINED),
// guaranteed by Uniscribe to be available all the time
// so we're safe using it as our simplified script ID.
//
psi[i].a.eScript = 0;
psp = pusp->GeteProp(0);
}
CF._wScript = psi[i].a.eScript;
// Stamp appropriate charset
//
if (pusp->GetComplexCharSet(psp, bCharSetDefault, CF._bCharSet))
{
// Complex script that has distinctive charset
dwMask1 |= CFM_CHARSET;
}
else if (fChangeCharSet)
{
// We run UnicodeBidi to analyse the whole thing so
// we need to figure out the proper charset to use as well.
//
// Note that we dont want to apply charset in general, say things
// like FarEast or GREEK_CHARSET should remain unchanged by
// this effect. But doing charset check is tough since we deal
// with text in range basis, so we simply call to update it here
// and let CCharFormat::Apply do the charset test in down level.
CF._bCharSet = psp->bCharSet; // assume what Uniscribe has given us
if (psi[i].a.fRTL || psi[i].a.fLayoutRTL)
{
// those of strong RTL and RTL digits need RTL charset
CF._bCharSet = pusp->GetRtlCharSet(ped);
}
Assert(CF._bCharSet != DEFAULT_CHARSET);
dwMask1 |= CFM_CHARSET;
}
// no publdr for this call so no antievent for itemized CF
SetCharFormat(&CF, SCF_IGNORENOTIFY, NULL, dwMask1, CFM2_SCRIPT);
Set(cp, 0);
}
}
else
{
// Itemization fails.
cp += cch;
SetCp(min(cp, cpMost));
// reset script id to 0
CF._wScript = 0;
SetCharFormat(&CF, SCF_IGNORENOTIFY, NULL, 0, CFM2_SCRIPT);
Set(cp, 0);
}
pwchString = &pc->si->pwchString[cp - cpMin]; // point to next substring
cchString -= cch;
uParaLevel = IsParaRTL() ? 1 : 0; // paragraph level might have changed
}
Assert (cpMost == cp);
// restore original range
Set(cpMost, cpMost - cpMin);
// retrieve ptr to Bidi FSM
pFSM = pusp->GetFSM();
if (pFSM)
hr = BiDiLevelFromFSM (pFSM);
AssertSz(SUCCEEDED(hr), "Unable to run or running BiDi FSM fails! We are in deep trouble,");
if (pc && pbBufIn != (BYTE*)pc)
FreePv(pc);
// update flags
ped->_fItemizePending = FALSE;
// Notify backing store change to all notification sinks
if(pnm)
pnm->NotifyPostReplaceRange(this, CP_INFINITE, 0, 0, cpMin, cpMost);
Exit:
return cItems > 0;
}
/*
* CTxtRange::IsProtected(iDirection)
*
* @mfunc
* Return TRUE if any part of this range is protected (HACK: or
* if any part of the range contains DBCS text stored in our Unicode
* backing store). If degenerate,
* use CCharFormat from run specified by iDirection, that is, use run
* valid up to, at, or starting at this GetCp() for iDirection less, =,
* or greater than 0, respectively.
*
* @rdesc
* TRUE iff any part of this range is protected (HACK: or if any part
* of the range contains DBCS text stored in our Unicode backing store
* For this to work correctly, GetCharFormat() needs to return dwMask2
* as well).
*/
BOOL CTxtRange::IsProtected (
LONG iDirection) //@parm Controls which run to check if range is IP
{
TRACEBEGIN(TRCSUBSYSRANG, TRCSCOPEINTERN, "CTxtRange::IsProtected");
CCharFormat CF;
LONG iFormat = -1; // Default default CF
_TEST_INVARIANT_
if(_rpCF.IsValid()) // Active rich-text runs
{
if(_cch) // Range is nondegenerate
{
DWORD dwMask = GetCharFormat(&CF);
if(CF._dwEffects & CFE_RUNISDBCS)
return PROTECTED_YES;
if (!(dwMask & CFM_PROTECTED) ||
(CF._dwEffects & CFE_PROTECTED))
{
return PROTECTED_ASK;
}
return PROTECTED_NO;
}
iFormat = _iFormat; // Degenerate range: default
if(iDirection != 0) // this range's iFormat
{ // Specific run direction
CFormatRunPtr rpCF(_rpCF);
if(iDirection < 0) // If at run ambiguous pos,
rpCF.AdjustBackward(); // use previous run
else
rpCF.AdjustForward();
iFormat = rpCF.GetFormat(); // Get run format
}
}
const CCharFormat *pCF = GetPed()->GetCharFormat(iFormat);
if(pCF->_dwEffects & CFE_RUNISDBCS)
return PROTECTED_YES;
if(pCF->_dwEffects & CFE_PROTECTED)
return PROTECTED_ASK;
return PROTECTED_NO;
}
/*
* CTxtRange::AdjustEndEOP (NewChars)
*
* @mfunc
* If this range is a selection and ends with an EOP and consists of
* more than just this EOP and fAdd is TRUE, or this EOP is the final
* EOP (at the story end), or this selection doesn't begin at the start
* of a paragraph, then move cpMost just before the end EOP. This
* function is used by UI methods that delete the selected text, such
* as PutChar(), Delete(), cut/paste, drag/drop.
*
* @rdesc
* TRUE iff range end has been adjusted
*
* @devnote
* This method leaves the active end at the selection cpMin. It is a
* CTxtRange method to handle the selection when it mascarades as a
* range for Cut/Paste.
*/
BOOL CTxtRange::AdjustEndEOP (
EOPADJUST NewChars) //@parm NEWCHARS if chars will be added
{
TRACEBEGIN(TRCSUBSYSSEL, TRCSCOPEINTERN, "CTxtRange::AdjustEndEOP");
LONG cpMin, cpMost;
LONG cch = GetRange(cpMin, cpMost);
LONG cchSave = _cch;
BOOL fRet = FALSE;
if(cch && (cch < GetTextLength() || NewChars == NEWCHARS))
{
LONG cchEOP = GetPed()->fUseCRLF() ? 2 : 1;
CTxtPtr tp(_rpTX);
if(_cch > 0) // Ensure active end is cpMin
FlipRange(); // (ReplaceRange() needs to
else // do this anyhow)
tp.AdvanceCp(-_cch); // Ensure tp is at cpMost
if(tp.IsAfterEOP()) // Don't delete EOP at sel
{ // end if EOP isn't end of
CPFRunPtr rp(*this); // table row and if there're
rp.AdvanceCp(-_cch); // chars to add, or cpMin
rp.AdjustBackward(); // isn't at BOP and more than
// EOP is selected
if(!rp.InTable() &&
(NewChars == NEWCHARS ||
cpMin && !_rpTX.IsAfterEOP() && cch > cchEOP))
{
_cch -= tp.BackupCpCRLF(); // Shorten range before EOP
// Note: the -= _adds_ to a
Update_iFormat(-1); // negative _cch to make
fRet = TRUE; // it less negative
}
}
if((_cch ^ cchSave) < 0 && _fSel) // Keep active end the same
FlipRange(); // for selection undo
}
return fRet;
}
/*
* CTxtRange::DeleteTerminatingEOP (publdr)
*
* @mfunc
* If this range is an insertion point that follows an EOP, select
* and delete that EOP
*/
void CTxtRange::DeleteTerminatingEOP(
IUndoBuilder *publdr)
{
Assert(!_cch);
if(_rpTX.IsAfterEOP())
{
SetExtend(TRUE);
BackupCRLF();
ReplaceRange(0, NULL, publdr, SELRR_REMEMBERRANGE);
}
}
/*
* CTxtRange::CheckTextLength(cch)
*
* @mfunc
* Check to see if can add cch characters. If not, notify parent
*
* @rdesc
* TRUE if OK to add cch chars
*/
BOOL CTxtRange::CheckTextLength (
LONG cch,
LONG *pcch)
{
TRACEBEGIN(TRCSUBSYSRANG, TRCSCOPEINTERN, "CTxtRange::CheckTextLength");
_TEST_INVARIANT_
DWORD cchNew = (DWORD)(CalcTextLenNotInRange() + cch);
if(cchNew > GetPed()->TxGetMaxLength())
{
if (pcch)
*pcch = cchNew - GetPed()->TxGetMaxLength();
else
GetPed()->GetCallMgr()->SetMaxText();
return FALSE;
}
return TRUE;
}
/*
* CTxtRange::FindObject(pcpMin, pcpMost)
*
* @mfunc
* Set *pcpMin = closest embedded object cpMin <lt>= range cpMin
* Set *pcpMost = closest embedded object cpMost <gt>= range cpMost
*
* @rdesc
* TRUE iff object found
*
* @comm
* An embedded object cpMin points at the first character of an embedded
* object. For RichEdit, this is the WCH_EMBEDDING character. An
* embedded object cpMost follows the last character of an embedded
* object. For RichEdit, this immediately follows the WCH_EMBEDDING
* character.
*/
BOOL CTxtRange::FindObject(
LONG *pcpMin, //@parm Out parm to receive object's cpMin; NULL OK
LONG *pcpMost) const//@parm Out parm to receive object's cpMost; NULL OK
{
TRACEBEGIN(TRCSUBSYSRANG, TRCSCOPEINTERN, "CTxtRange::FindObject");
if(!GetObjectCount()) // No objects: can't move, so
return FALSE; // return FALSE
BOOL bRet = FALSE; // Default no object
LONG cpMin, cpMost;
CTxtPtr tp(_rpTX);
GetRange(cpMin, cpMost);
if(pcpMin)
{
tp.SetCp(cpMin);
if(tp.GetChar() != WCH_EMBEDDING)
{
cpMin = tp.FindExact(tomBackward, szEmbedding);
if(cpMin >= 0)
{
bRet = TRUE;
*pcpMin = cpMin;
}
}
}
if(pcpMost)
{
tp.SetCp(cpMost);
if (tp.PrevChar() != WCH_EMBEDDING &&
tp.FindExact(tomForward, szEmbedding) >= 0)
{
bRet = TRUE;
*pcpMost = tp.GetCp();
}
}
return bRet;
}
/*
* CTxtRange::FindCell(pcpMin, pcpMost)
*
* @mfunc
* Set *pcpMin = closest cell cpMin <lt>= range cpMin (see comment)
* Set *pcpMost = closest cell cpMost <gt>= range cpMost
*
* @comment
* This function does nothing if the range isn't completely in a table.
*/
void CTxtRange::FindCell (
LONG *pcpMin, //@parm Out parm for bounding-cell cpMin
LONG *pcpMost) const //@parm Out parm for bounding-cell cpMost
{
TRACEBEGIN(TRCSUBSYSRANG, TRCSCOPEINTERN, "CTxtRange::FindCell");
WCHAR ch;
LONG cpMin, cpMost;
CRchTxtPtr rtp(*this);
_TEST_INVARIANT_
GetRange(cpMin, cpMost);
if(pcpMin)
{
if(_cch > 0)
rtp.Advance(-_cch);
rtp._rpPF.AdjustBackward();
if(rtp.InTable())
{
while(rtp.GetCp())
{
rtp.BackupCRLF();
ch = rtp.GetChar();
if(IsASCIIEOP(ch) || ch == CELL)
{
rtp.AdvanceCRLF();
break;
}
Assert(rtp.InTable());
}
}
*pcpMin = rtp.GetCp();
}
if(pcpMost)
{
rtp.SetCp(cpMost);
if(rtp.InTable())
{
rtp.BackupCRLF();
do
{
ch = rtp.GetChar();
rtp.AdvanceCRLF();
Assert(rtp.InTable());
} while(ch && !IsASCIIEOP(ch) && ch != CELL);
}
*pcpMost = rtp.GetCp();
}
}
/*
* CTxtRange::FindParagraph(pcpMin, pcpMost)
*
* @mfunc
* Set *pcpMin = closest paragraph cpMin <lt>= range cpMin (see comment)
* Set *pcpMost = closest paragraph cpMost <gt>= range cpMost
*
* @devnote
* If this range's cpMost follows an EOP, use it for bounding-paragraph
* cpMost unless 1) the range is an insertion point, and 2) pcpMin and
* pcpMost are both nonzero, in which case use the next EOP. Both out
* parameters are nonzero if FindParagraph() is used to expand to full
* paragraphs (else StartOf or EndOf is all that's requested). This
* behavior is consistent with the selection/IP UI. Note that FindEOP
* treats the beginning/end of document (BOD/EOD) as a BOP/EOP,
* respectively, but IsAfterEOP() does not.
*/
void CTxtRange::FindParagraph (
LONG *pcpMin, //@parm Out parm for bounding-paragraph cpMin
LONG *pcpMost) const //@parm Out parm for bounding-paragraph cpMost
{
TRACEBEGIN(TRCSUBSYSRANG, TRCSCOPEINTERN, "CTxtRange::FindParagraph");
LONG cpMin, cpMost;
CTxtPtr tp(_rpTX);
_TEST_INVARIANT_
GetRange(cpMin, cpMost);
if(pcpMin)
{
tp.SetCp(cpMin); // tp points at this range's cpMin
if(!tp.IsAfterEOP()) // Unless tp directly follows an
tp.FindEOP(tomBackward); // EOP, search backward for EOP
*pcpMin = cpMin = tp.GetCp();
}
if(pcpMost)
{
tp.SetCp(cpMost); // If range cpMost doesn't follow
if (!tp.IsAfterEOP() || // an EOP or else if expanding
(!cpMost || pcpMin) &&
cpMin == cpMost) // IP at paragraph beginning,
{
tp.FindEOP(tomForward); // search for next EOP
}
*pcpMost = tp.GetCp();
}
}
/*
* CTxtRange::FindSentence(pcpMin, pcpMost)
*
* @mfunc
* Set *pcpMin = closest sentence cpMin <lt>= range cpMin
* Set *pcpMost = closest sentence cpMost <gt>= range cpMost
*
* @devnote
* If this range's cpMost follows a sentence end, use it for bounding-
* sentence cpMost unless the range is an insertion point, in which case
* use the next sentence end. The routine takes care of aligning on
* sentence beginnings in the case of range ends that fall on whitespace
* in between sentences.
*/
void CTxtRange::FindSentence (
LONG *pcpMin, //@parm Out parm for bounding-sentence cpMin
LONG *pcpMost) const //@parm Out parm for bounding-sentence cpMost
{
TRACEBEGIN(TRCSUBSYSRANG, TRCSCOPEINTERN, "CTxtRange::FindSentence");
LONG cpMin, cpMost;
CTxtPtr tp(_rpTX);
_TEST_INVARIANT_
GetRange(cpMin, cpMost);
if(pcpMin) // Find sentence beginning
{
tp.SetCp(cpMin); // tp points at this range's cpMin
if(!tp.IsAtBOSentence()) // If not at beginning of sentence
tp.FindBOSentence(tomBackward); // search backward for one
*pcpMin = cpMin = tp.GetCp();
}
if(pcpMost) // Find sentence end
{ // Point tp at this range's cpLim
tp.SetCp(cpMost); // If cpMost isn't at sentence
if (!tp.IsAtBOSentence() || // beginning or if at story
(!cpMost || pcpMin) && // beginning or expanding
cpMin == cpMost) // IP at sentence beginning,
{ // find next sentence beginning
if(!tp.FindBOSentence(tomForward))
tp.SetCp(GetTextLength()); // End of story counts as
} // sentence end too
*pcpMost = tp.GetCp();
}
}
/*
* CTxtRange::FindVisibleRange(pcpMin, pcpMost)
*
* @mfunc
* Set *pcpMin = _pdp->_cpFirstVisible
* Set *pcpMost = _pdp->_cpLastVisible
*
* @rdesc
* TRUE iff calculated cp's differ from this range's cp's
*
* @devnote
* CDisplay::GetFirstVisible() and GetCliVisible() return the first cp
* on the first visible line and the last cp on the last visible line.
* These won't be visible if they are scrolled off the screen.
* FUTURE: A more general algorithm would CpFromPoint (0,0) and
* (right, bottom).
*/
BOOL CTxtRange::FindVisibleRange (
LONG *pcpMin, //@parm Out parm for cpFirstVisible
LONG *pcpMost) const //@parm Out parm for cpLastVisible
{
TRACEBEGIN(TRCSUBSYSRANG, TRCSCOPEINTERN, "CTxtRange::FindVisibleRange");
_TEST_INVARIANT_
CDisplay * pdp = GetPed()->_pdp;
if(!pdp)
return FALSE;
if(pcpMin)
*pcpMin = pdp->GetFirstVisibleCp();
pdp->GetCliVisible(pcpMost);
return TRUE;
}
/*
* CTxtRange::FindWord(pcpMin, pcpMost, type)
*
* @mfunc
* Set *pcpMin = closest word cpMin <lt>= range cpMin
* Set *pcpMost = closest word cpMost <gt>= range cpMost
*
* @comm
* There are two interesting cases for finding a word. The first,
* (FW_EXACT) finds the exact word, with no extraneous characters.
* This is useful for situations like applying formatting to a
* word. The second case, FW_INCLUDE_TRAILING_WHITESPACE does the
* obvious thing, namely includes the whitespace up to the next word.
* This is useful for the selection double-click semantics and TOM.
*/
void CTxtRange::FindWord(
LONG *pcpMin, //@parm Out parm to receive word's cpMin; NULL OK
LONG *pcpMost, //@parm Out parm to receive word's cpMost; NULL OK
FINDWORD_TYPE type) const //@parm Type of word to find
{
TRACEBEGIN(TRCSUBSYSRANG, TRCSCOPEINTERN, "CTxtRange::FindWord");
LONG cch, cch1;
LONG cpMin, cpMost;
CTxtPtr tp(_rpTX);
_TEST_INVARIANT_
Assert(type == FW_EXACT || type == FW_INCLUDE_TRAILING_WHITESPACE );
GetRange(cpMin, cpMost);
if(pcpMin)
{
tp.SetCp(cpMin);
if(!tp.IsAtBOWord()) // cpMin not at BOW:
cpMin += tp.FindWordBreak(WB_MOVEWORDLEFT); // go there
*pcpMin = cpMin;
Assert(cpMin >= 0 && cpMin <= GetTextLength());
}
if(pcpMost)
{
tp.SetCp(cpMost);
if (!tp.IsAtBOWord() || // If not at word strt
(!cpMost || pcpMin) && cpMin == cpMost) // or there but need
{ // to expand IP,
cch = tp.FindWordBreak(WB_MOVEWORDRIGHT); // move to next word
if(cch && type == FW_EXACT) // If moved and want
{ // word proper, move
cch1 = tp.FindWordBreak(WB_LEFTBREAK); // back to end of
if(cch + cch1 > 0) // preceding word
cch += cch1; // Only do so if were
} // not already at end
cpMost += cch;
}
*pcpMost = cpMost;
Assert(cpMost >= 0 && cpMost <= GetTextLength());
Assert(cpMin <= cpMost);
}
}
/*
* CTxtRange::FindAttributes(pcpMin, pcpMost, dwMask)
*
* @mfunc
* Set *pcpMin = closest attribute-combo cpMin <lt>= range cpMin
* Set *pcpMost = closest attribute-combo cpMost <gt>= range cpMost
* The attribute combo is given by Unit and is any OR combination of
* TOM attributes, e.g., tomBold, tomItalic, or things like
* tomBold | tomItalic. The combo is found if any of the attributes
* is present.
*
* @devnote
* Plan to add other logical combinations: tomAND, tomExact
*/
void CTxtRange::FindAttributes (
LONG *pcpMin, //@parm Out parm for bounding-sentence cpMin
LONG *pcpMost, //@parm Out parm for bounding-sentence cpMost
LONG Unit) const //@parm TOM attribute mask
{
TRACEBEGIN(TRCSUBSYSRANG, TRCSCOPEINTERN, "CTxtRange::FindAttributes");
LONG cch;
LONG cpMin, cpMost;
DWORD dwMask = Unit & ~0x80000000; // Kill sign bit
CCFRunPtr rp(*this);
Assert(Unit < 0);
GetRange(cpMin, cpMost);
if(!rp.IsValid()) // No CF runs instantiated
{
if(rp.IsMask(dwMask)) // Applies to default CF
{
if(pcpMin)
*pcpMin = 0;
if(pcpMost)
*pcpMost = GetTextLength();
}
return;
}
// Start at cpMin
if(_cch > 0)
rp.AdvanceCp(-_cch);
// Go backward until we don't match dwMask
if(pcpMin)
{
rp.AdjustBackward();
while(rp.IsMask(dwMask) && rp.GetIch())
{
cpMin -= rp.GetIch();
rp.AdvanceCp(-rp.GetIch());
rp.AdjustBackward();
}
*pcpMin = cpMin;
}
// Now go forward from cpMost until we don't match dwMask
if(pcpMost)
{
rp.AdvanceCp(cpMost - cpMin);
rp.AdjustForward(); // In case cpMin = cpMost
cch = rp.GetCchLeft();
while(rp.IsMask(dwMask) && cch)
{
cpMost += cch;
rp.AdvanceCp(cch);
cch = rp.GetCchLeft();
}
*pcpMost = cpMost;
}
}
/*
* CTxtRange::CalcTextLenNotInRange()
*
* @mfunc
* Helper function that calculates the total length of text
* excluding the current range.
*
* @comm
* Used for limit testing. The problem being solved is that
* the range can contain the final EOP which is not included
* in the adjusted text length.
*/
LONG CTxtRange::CalcTextLenNotInRange()
{
LONG cchAdjLen = GetPed()->GetAdjustedTextLength();
LONG cchLen = cchAdjLen - abs(_cch);
LONG cpMost = GetCpMost();
if (cpMost > cchAdjLen)
{
// Selection extends beyond adjusted length. Put amount back in the
// selection as it has become too small by the difference.
cchLen += cpMost - cchAdjLen;
}
return cchLen;
}
////////////////////////// Outline Support //////////////////////////////////
/*
* CTxtRange::Promote(lparam, publdr)
*
* @mfunc
* Promote selected text according to:
*
* LOWORD(lparam) == 0 ==> promote to body-text
* LOWORD(lparam) != 0 ==> promote/demote current selection by
* LOWORD(lparam) levels
* @rdesc
* TRUE iff promotion occurred
*
* @devnote
* Changes this range
*/
HRESULT CTxtRange::Promote (
LPARAM lparam, //@parm 0 to body, < 0 demote, > 0 promote
IUndoBuilder *publdr) //@parm undo builder to receive antievents
{
TRACEBEGIN(TRCSUBSYSSEL, TRCSCOPEINTERN, "CTxtRange::Promote");
if(abs(lparam) >= NHSTYLES)
return E_INVALIDARG;
if(publdr)
publdr->StopGroupTyping();
if(_cch > 0) // Point at cpMin
FlipRange();
LONG cchText = GetTextLength();
LONG cpEnd = GetCpMost();
LONG cpMin, cpMost;
BOOL fHeading = TRUE; // Default heading in range
HRESULT hr;
LONG Level;
LONG nHeading = NHSTYLES; // Setup to find any heading
CParaFormat PF;
const CParaFormat *pPF;
CPFRunPtr rp(*this);
LONG cch = rp.FindHeading(abs(_cch), nHeading);
WORD wEffects;
if(!lparam) // Demote to subtext
{
if(cch) // Already in subtext so don't
return S_FALSE; // need to demote
CTxtPtr tp(_rpTX);
if(!tp.IsAfterEOP())
cch = tp.FindEOP(tomBackward);
nHeading = 1;
if(tp.GetCp()) // Get previous level and convert
{ // to heading to set up
rp.AdvanceCp(cch); // following Level code
rp.AdjustBackward();
nHeading = rp.GetOutlineLevel()/2 + 1;
}
}
else if(cch == tomBackward) // No heading in range
{ // Set up to promote to
nHeading = rp.GetOutlineLevel()/2 // heading
+ (lparam > 0 ? 2 : 1);
fHeading = FALSE; // Signal no heading in range
}
else if(cch) // Range starts in subtext
{
SetExtend(TRUE);
Advance(cch); // Bypass initial nonheading
}
Level = 2*(nHeading - 1); // Heading level
PF._bOutlineLevel = (BYTE)(Level | 1); // Corresponding subtext level
if (!Level && lparam > 0 || // Can't promote Heading 1
nHeading == NHSTYLES && lparam < 0) // or demote Heading 9
{
return S_FALSE;
}
do
{
_cch = 0;
Level -= long(2*lparam); // Promote Level
pPF = GetPF();
wEffects = pPF->_wEffects;
if(pPF->_bOutlineLevel & 1) // Handle contiguous text in
{ // one fell swoop
cch = fHeading ? _rpPF.GetCchLeft() : cpEnd - GetCp();
if(cch > 0)
{
SetExtend(TRUE);
Advance(cch);
}
}
Expander(tomParagraph, TRUE, NULL, &cpMin, &cpMost);
if((unsigned)Level < 2*NHSTYLES)
{ // Promoted Level is valid
DWORD dwMask = PFM_OUTLINELEVEL;// Default setting subtext level
if(!(Level & 1) && lparam) // Promoting or demoting heading
{ // Preserve collapse status
PF._wEffects = Level ? wEffects : 0; // H1 is aways expanded
PF._sStyle = (SHORT)(-Level/2 + STYLE_HEADING_1);
PF._bOutlineLevel = (BYTE)(Level | 1);// Set up subtext
dwMask = PFM_STYLE + PFM_COLLAPSED;
}
else if(!lparam) // Changing heading to subtext
{ // or uncollapsing subtext
PF._wEffects = 0; // Turn off collapsed
PF._sStyle = STYLE_NORMAL;
dwMask = PFM_STYLE + PFM_OUTLINELEVEL + PFM_COLLAPSED;
}
hr = SetParaStyle(&PF, publdr, dwMask);
if(hr != NOERROR)
return hr;
}
if(GetCp() >= cchText) // Have handled last PF run
break;
Assert(_cch > 0); // Para/run should be selected
pPF = GetPF(); // Points at next para
Level = pPF->_bOutlineLevel;
} // Iterate until past range &
while((Level & 1) || fHeading && // any subtext that follows
(GetCp() < cpEnd || pPF->_wEffects & PFE_COLLAPSED));
return NOERROR;
}
/*
* CTxtRange::ExpandOutline(Level, fWholeDocument)
*
* @mfunc
* Expand outline according to Level and fWholeDocument. Wraps
* OutlineExpander() helper function and updates selection/view
*
* @rdesc
* NOERROR if success
*/
HRESULT CTxtRange::ExpandOutline(
LONG Level, //@parm If < 0, collapse; else expand, etc.
BOOL fWholeDocument) //@parm If TRUE, whole document
{
if (!IsInOutlineView())
return NOERROR;
HRESULT hres = OutlineExpander(Level, fWholeDocument);
if(hres != NOERROR)
return hres;
GetPed()->TxNotify(EN_PARAGRAPHEXPANDED, NULL);
return GetPed()->UpdateOutline();
}
/*
* CTxtRange::OutlineExpander(Level, fWholeDocument)
*
* @mfunc
* Expand/collapse outline for this range according to Level
* and fWholeDocument. If fWholeDocument is TRUE, then
* 1 <= Level <= NHSTYLES collapses all headings with numbers
* greater than Level and collapses all nonheadings. Level = -1
* expands all.
*
* fWholeDocument = FALSE expands/collapses (Level > 0 or < 0)
* paragraphs depending on whether an EOP and heading are included
* in the range. If Level = 0, toggle heading's collapsed status.
*
* @rdesc
* (change made) ? NOERROR : S_FALSE
*/
HRESULT CTxtRange::OutlineExpander(
LONG Level, //@parm If < 0, collapse; else expand, etc.
BOOL fWholeDocument) //@parm If TRUE, whole document
{
CParaFormat PF;
if(fWholeDocument) // Apply to whole document
{
if (IN_RANGE(1, Level, NHSTYLES) || // Collapse to heading
Level == -1) // -1 means all
{
Set(0, tomBackward); // Select whole document
PF._sStyle = (SHORT)(STYLE_COMMAND + (BYTE)Level);
SetParaFormat(&PF, NULL, PFM_STYLE);// No undo
return NOERROR;
}
return S_FALSE; // Nothing happened (illegal
} // arg)
// Expand/Collapse for Level positive/negative, respectively
LONG cpMin, cpMost; // Get range cp's
LONG cchMax = GetRange(cpMin, cpMost);
if(_cch > 0) // Ensure cpMin is active
FlipRange(); // for upcoming rp and tp
LONG nHeading = NHSTYLES; // Setup to find any heading
LONG nHeading1;
CTxtEdit *ped = GetPed();
CPFRunPtr rp(*this);
LONG cch = rp.FindHeading(cchMax, nHeading);
if(cch == tomBackward) // No heading found within range
return S_FALSE; // Do nothing
Assert(cch <= cchMax && (Level || !cch)); // cch is count up to heading
CTxtPtr tp(_rpTX);
cpMin += cch; // Bypass any nonheading text
tp.AdvanceCp(cch); // at start of range
// If toggle collapse or if range contains an EOP,
// collapse/expand all subordinates
cch = tp.FindEOP(tomForward); // Find next para
if(!cch)
return NOERROR;
if(!Level || cch < -_cch) // Level = 0 or EOP in range
{
if(!Level) // Toggle collapse status
{
LONG cchLeft = rp.GetCchLeft();
if (cch < cchLeft || !rp.NextRun() ||
nHeading == STYLE_HEADING_1 - rp.GetStyle() + 1)
{
return NOERROR; // Next para has same heading
}
Assert(cch == cchLeft);
Level = rp.IsCollapsed();
rp.AdvanceCp(-cchLeft);
}
PF._wEffects = Level > 0 ? 0 : PFE_COLLAPSED;
while(cpMin < cpMost)
{ // We're at a heading
tp.SetCp(cpMin);
cch = tp.FindEOP(-_cch);
cpMin += cch; // Bypass it
if(!rp.AdvanceCp(cch)) // Point at next para
break; // No more, we're done
nHeading1 = nHeading; // Setup to find heading <= nHeading
cch = rp.FindHeading(tomForward, nHeading1);
if(cch == tomBackward) // No more higher headings
cch = GetTextLength() - cpMin; // Format to end of text
Set(cpMin, -cch); // Collapse/expand up to here
SetParaFormat(&PF, NULL, PFM_COLLAPSED);
cpMin += cch; // Move past formatted area
nHeading = nHeading1; // Update nHeading to possibly
} // lower heading #
return NOERROR;
}
// Range contains no EOP: expand/collapse deepest level.
// If collapsing, collapse all nonheading text too. Expand
// nonheading text only if all subordinate levels are expanded.
BOOL fCollapsed;
LONG nHeadStart, nHeadDeepNC, nHeadDeep;
LONG nNonHead = -1; // No nonHeading found yet
const CParaFormat *pPF;
cpMin = tp.GetCp(); // Point at start of
cpMost = cpMin; // next para
pPF = ped->GetParaFormat(_rpPF.GetFormat());
nHeading = pPF->_bOutlineLevel;
Assert(!(nHeading & 1) && // Must start with a heading
!(pPF->_wEffects & PFE_COLLAPSED)); // that isn't collapsed
nHeadStart = nHeading/2 + 1; // Convert outline level to
nHeadDeep = nHeadDeepNC = nHeadStart; // heading number
while(cch) // Determine deepest heading
{ // and deepest collapsed
rp.AdvanceCp(cch); // heading
pPF = ped->GetParaFormat(rp.GetFormat());
fCollapsed = pPF->_wEffects & PFE_COLLAPSED;
nHeading = pPF->_bOutlineLevel;
if(nHeading & 1) // Text found
{ // Set nNonHead > 0 if
nNonHead = fCollapsed; // collapsed; else 0
cch = rp.GetCchLeft(); // Zip to end of contiguous
tp.AdvanceCp(cch); // text paras
}
else // It's a heading
{
nHeading = nHeading/2 + 1; // Convert to heading number
if(nHeading <= nHeadStart) // If same or shallower as
break; // start heading we're done
// Update deepest and deepest nonCollapsed heading #'s
nHeadDeep = max(nHeadDeep, nHeading);
if(!fCollapsed)
nHeadDeepNC = max(nHeadDeepNC, nHeading);
cch = tp.FindEOP(tomForward); // Go to next paragraph
}
cpMost = tp.GetCp(); // Include up to it
}
PF._sStyle = (SHORT)(STYLE_COMMAND + nHeadDeepNC);
if(Level > 0) // Expand
{
if(nHeadDeepNC < nHeadDeep) // At least one collapsed
PF._sStyle++; // heading: expand shallowest
else // All heads expanded: do others
PF._sStyle = (unsigned short) (STYLE_COMMAND + 0xFF);
} // In any case, expand nonheading
else if(nNonHead) // Collapse. If text collapsed
{ // or missing, do headings
if(nHeadDeepNC == nHeadStart)
return S_FALSE; // Everything already collapsed
PF._sStyle--; // Collapse to next shallower
} // heading
Set(cpMin, cpMin - cpMost); // Select range to change
SetParaFormat(&PF, NULL, PFM_STYLE); // No undo
return NOERROR;
}
/*
* CTxtRange::CheckOutlineLevel(publdr)
*
* @mfunc
* If the paragraph style at this range isn't a heading, make
* sure its outline level is compatible with the preceeding one
*/
void CTxtRange::CheckOutlineLevel(
IUndoBuilder *publdr) //@parm Undo context for this operation
{
LONG LevelBackward, LevelForward;
CPFRunPtr rp(*this);
Assert(!_cch);
rp.AdjustBackward();
LevelBackward = rp.GetOutlineLevel() | 1; // Nonheading level corresponding
// to previous PF run
rp.AdjustForward();
LevelForward = rp.GetOutlineLevel();
if (!(LevelForward & 1) || // Any heading can follow
LevelForward == LevelBackward) // any style. Also if
{ // forward level is correct,
return; // return
}
LONG cch; // One or more nonheadings
LONG lHeading = NHSTYLES; // with incorrect outline
CParaFormat PF; // levels follow
PF._bOutlineLevel = (BYTE)LevelBackward; // level
cch = rp.FindHeading(tomForward, lHeading); // Find next heading
if(cch == tomBackward)
cch = tomForward;
Set(GetCp(), -cch); // Select all nonheading text
SetParaFormat(&PF, publdr, PFM_OUTLINELEVEL);// Change its outline level
Set(GetCp(), 0); // Restore range to IP
}
#if defined(DEBUG)
/*
* CTxtRange::::DebugFont (void)
*
* @mfunc
* Dump out the character and Font info for current selection.
*/
void CTxtRange::DebugFont (void)
{
LONG ch;
LONG cpMin, cpMost;
LONG cch = GetRange(cpMin, cpMost);
LONG i;
char szTempBuf[64];
CTxtEdit *ped = GetPed();
const WCHAR *wszFontname;
const CCharFormat *CF; // Temporary CF
const WCHAR *GetFontName(LONG iFont);
char szTempPath[MAX_PATH] = "\0";
DWORD cchLength;
HANDLE hfileDump;
DWORD cbWritten;
SideAssert(cchLength = GetTempPathA(MAX_PATH, szTempPath));
// append trailing backslash if neccessary
if(szTempPath[cchLength - 1] != '\\')
{
szTempPath[cchLength] = '\\';
szTempPath[cchLength + 1] = 0;
}
strcat(szTempPath, "DumpFontInfo.txt");
SideAssert(hfileDump = CreateFileA(szTempPath,
GENERIC_WRITE,
FILE_SHARE_READ,
NULL,
CREATE_ALWAYS,
FILE_ATTRIBUTE_NORMAL,
NULL));
if(_cch > 0) // start from cpMin
FlipRange();
CFormatRunPtr rp(_rpCF);
for (i=0; i <= cch; i++)
{
LONG iFormat;
if (GetChar(&ch) != NOERROR)
break;
if (ch <= 0x07f)
sprintf(szTempBuf, "Char= '%c'\r\n", (char)ch);
else
sprintf(szTempBuf, "Char= 0x%x\r\n", ch);
OutputDebugStringA(szTempBuf);
if (hfileDump)
WriteFile(hfileDump, szTempBuf, strlen(szTempBuf), &cbWritten, NULL);
iFormat = rp.GetFormat();
CF = ped->GetCharFormat(iFormat);
Assert(CF);
sprintf(szTempBuf, "Font iFormat= %d, Charset= %d, Size= %d\r\nName= ",
iFormat, CF->_bCharSet, CF->_yHeight);
OutputDebugStringA(szTempBuf);
if (hfileDump)
WriteFile(hfileDump, szTempBuf, strlen(szTempBuf), &cbWritten, NULL);
wszFontname = GetFontName(CF->_iFont);
if (wszFontname)
{
if (*wszFontname <= 0x07f)
{
szTempBuf[0] = '\'';
WCTMB(CP_ACP, 0,
wszFontname, -1, &szTempBuf[1], sizeof(szTempBuf)-1,
NULL, NULL, NULL);
strcat(szTempBuf,"\'");
OutputDebugStringA(szTempBuf);
if (hfileDump)
WriteFile(hfileDump, szTempBuf, strlen(szTempBuf), &cbWritten, NULL);
}
else
{
for (; *wszFontname; wszFontname++)
{
sprintf(szTempBuf, "0x%x,", *wszFontname);
OutputDebugStringA(szTempBuf);
if (hfileDump)
WriteFile(hfileDump, szTempBuf, strlen(szTempBuf), &cbWritten, NULL);
}
}
}
OutputDebugStringA("\r\n");
if (hfileDump)
WriteFile(hfileDump, "\r\n", 2, &cbWritten, NULL);
Advance(1);
rp.AdvanceCp(1);
}
// Now dump the doc font info
CF = ped->GetCharFormat(-1);
Assert(CF);
sprintf(szTempBuf, "Default Font iFormat= -1, Charset= %d, Size= %d\r\nName= ",
CF->_bCharSet, CF->_yHeight);
OutputDebugStringA(szTempBuf);
if (hfileDump)
WriteFile(hfileDump, szTempBuf, strlen(szTempBuf), &cbWritten, NULL);
wszFontname = GetFontName(CF->_iFont);
if (wszFontname)
{
if (*wszFontname <= 0x07f)
{
szTempBuf[0] = '\'';
WCTMB(CP_ACP, 0,
wszFontname, -1, &szTempBuf[1], sizeof(szTempBuf),
NULL, NULL, NULL);
strcat(szTempBuf,"\'");
OutputDebugStringA(szTempBuf);
if (hfileDump)
WriteFile(hfileDump, szTempBuf, strlen(szTempBuf), &cbWritten, NULL);
}
else
{
for (; *wszFontname; wszFontname++)
{
sprintf(szTempBuf, "0x%x,", *wszFontname);
OutputDebugStringA(szTempBuf);
if (hfileDump)
WriteFile(hfileDump, szTempBuf, strlen(szTempBuf), &cbWritten, NULL);
}
}
}
OutputDebugStringA("\r\n");
if (hfileDump)
WriteFile(hfileDump, "\r\n", 2, &cbWritten, NULL);
if (ped->IsRich())
{
if (ped->fUseUIFont())
sprintf(szTempBuf, "Rich Text with UI Font");
else
sprintf(szTempBuf, "Rich Text Control");
}
else
sprintf(szTempBuf, "Plain Text Control");
OutputDebugStringA(szTempBuf);
if (hfileDump)
WriteFile(hfileDump, szTempBuf, strlen(szTempBuf), &cbWritten, NULL);
OutputDebugStringA("\r\n");
if (hfileDump)
WriteFile(hfileDump, "\r\n", 2, &cbWritten, NULL);
if (hfileDump)
CloseHandle(hfileDump);
}
#endif