3211 lines
106 KiB
C++
3211 lines
106 KiB
C++
|
/*
|
||
|
|
* @doc TOM
|
||
|
|
*
|
||
|
|
* @module TOMRANGE.CPP - Implement the CTxtRange Class |
|
||
|
|
*
|
||
|
|
* This module contains the implementation of the TOM ITextRange
|
||
|
|
* interface on the CTxtRange object
|
||
|
|
*
|
||
|
|
* History: <nl>
|
||
|
|
* 5/24/95 - Alex Gounares: stubs created <nl>
|
||
|
|
* 8/95 - MurrayS: main implementation <nl>
|
||
|
|
* 11/95 - MurrayS: upgrade to TOM spec of 12/10/95 <nl>
|
||
|
|
* 5/96 - MurrayS: added zombie protection
|
||
|
|
*
|
||
|
|
* @comm
|
||
|
|
* All ITextRange methods return HRESULTs. If the method can move a
|
||
|
|
* range cp, the HRESULT is NOERROR if movement occurs and S_FALSE if
|
||
|
|
* no movement occurs. These methods usually take a <p pDelta> argument
|
||
|
|
* that returns the count of characters or Units actually moved. If this
|
||
|
|
* parameter is NULL, E_INVALIDARG is returned. Other return values
|
||
|
|
* include E_NOTIMPL, e.g., for Unit values not implemented,
|
||
|
|
* E_OUTOFMEMORY, e.g., when allocations fail, and CO_E_RELEASED, when
|
||
|
|
* the CTxtEdit (_ped) to which the range is attached has been deleted.
|
||
|
|
*
|
||
|
|
* For more complete documentation, please see tom.doc
|
||
|
|
*
|
||
|
|
* @devnote
|
||
|
|
* All ptr parameters must be validated before use and all entry points
|
||
|
|
* need to check whether this range is a zombie. These checks are
|
||
|
|
* done in one of three places: 1) immediately on entry to a function,
|
||
|
|
* 2) immediately on entry to a helper function (e.g., private Mover()
|
||
|
|
* for the move methods), or 3) before storing the out value.
|
||
|
|
* Alternative 3) is used for optional return values, such as pDelta
|
||
|
|
* and pB.
|
||
|
|
*
|
||
|
|
* To achieve a simple, efficient inheritance model, CTxtSelection
|
||
|
|
* inherits ITextSelection through CTxtRange. Otherwise we'd have a
|
||
|
|
* diamond inheritance, since ITextSelection itself inherits from
|
||
|
|
* ITextRange. Diamond inheritance creates two copies of the multiply
|
||
|
|
* inherited class unless that class is inherited virtually. Virtual
|
||
|
|
* inheritance uses run-time base-offset tables and is slower and
|
||
|
|
* bigger. To avoid such a mess, we include the extra ITextSelection
|
||
|
|
* methods in CTxtRange, with the intention that they'll never be called
|
||
|
|
* and therefore they return E_NOTIMPL. This is overridden for
|
||
|
|
* ITextSelection objects
|
||
|
|
*
|
||
|
|
* @future
|
||
|
|
* 1) Finder match ^p, etc.
|
||
|
|
* 2) Fast GetEffects() method. Would speed up the myriad IsProtected()
|
||
|
|
* calls and be useful for getting other effects as well.
|
||
|
|
* 3) Fast copies/pastes of RichEdit binary format. This can be done by
|
||
|
|
* creating a method to copy a range to a new CTxtStory and a method
|
||
|
|
* to insert a CTxtStory.
|
||
|
|
* 4) Delayed rendering
|
||
|
|
*
|
||
|
|
* Copyright (c) 1995-1998, Microsoft Corporation. All rights reserved.
|
||
|
|
*/
|
||
|
|
|
||
|
|
#include "_common.h"
|
||
|
|
#include "_select.h"
|
||
|
|
#include "_edit.h"
|
||
|
|
#include "_line.h"
|
||
|
|
#include "_frunptr.h"
|
||
|
|
#include "_tomfmt.h"
|
||
|
|
#include "_disp.h"
|
||
|
|
#include "_objmgr.h"
|
||
|
|
#include "_callmgr.h"
|
||
|
|
#include "_measure.h"
|
||
|
|
|
||
|
|
ASSERTDATA
|
||
|
|
|
||
|
|
#define DEBUG_CLASSNAME CTxtRange
|
||
|
|
#include "_invar.h"
|
||
|
|
|
||
|
|
HRESULT QueryInterface (REFIID riid, REFIID riid1, IUnknown *punk,
|
||
|
|
void **ppv, BOOL fZombie);
|
||
|
|
|
||
|
|
|
||
|
|
//----------------- CTxtRange (ITextRange) PUBLIC methods ----------------------------------
|
||
|
|
|
||
|
|
//----------------------- CTxtRange IUnknown Methods -------------------------------------
|
||
|
|
|
||
|
|
/*
|
||
|
|
* CTxtRange::QueryInterface (riid, ppv)
|
||
|
|
*
|
||
|
|
* @mfunc
|
||
|
|
* IUnknown method
|
||
|
|
*
|
||
|
|
* @rdesc
|
||
|
|
* HRESULT = (!ppv) ? E_INVALIDARG :
|
||
|
|
* (interface found) ? NOERROR : E_NOINTERFACE
|
||
|
|
*/
|
||
|
|
STDMETHODIMP CTxtRange::QueryInterface (
|
||
|
|
REFIID riid, //@parm Reference to requested interface ID
|
||
|
|
void ** ppv) //@parm Out parm to receive interface ptr
|
||
|
|
{
|
||
|
|
TRACEBEGIN(TRCSUBSYSTOM, TRCSCOPEEXTERN, "CTxtRange::QueryInterface");
|
||
|
|
|
||
|
|
REFIID riid1 = _fSel && IsEqualIID(riid, IID_ITextSelection)
|
||
|
|
? IID_ITextSelection : IID_ITextRange;
|
||
|
|
#ifndef PEGASUS
|
||
|
|
return ::QueryInterface(riid, riid1, this, ppv, IsZombie());
|
||
|
|
#else
|
||
|
|
return 0;
|
||
|
|
#endif
|
||
|
|
}
|
||
|
|
|
||
|
|
/*
|
||
|
|
* CTxtRange::AddRef()
|
||
|
|
*
|
||
|
|
* @mfunc
|
||
|
|
* IUnknown method
|
||
|
|
*
|
||
|
|
* @rdesc
|
||
|
|
* ULONG - incremented reference count
|
||
|
|
*/
|
||
|
|
STDMETHODIMP_(ULONG) CTxtRange::AddRef()
|
||
|
|
{
|
||
|
|
TRACEBEGIN(TRCSUBSYSTOM, TRCSCOPEEXTERN, "CTxtRange::AddRef");
|
||
|
|
|
||
|
|
return ++_cRefs;
|
||
|
|
}
|
||
|
|
|
||
|
|
/*
|
||
|
|
* CTxtRange::Release()
|
||
|
|
*
|
||
|
|
* @mfunc
|
||
|
|
* IUnknown method
|
||
|
|
*
|
||
|
|
* @rdesc
|
||
|
|
* ULONG - decremented reference count
|
||
|
|
*/
|
||
|
|
STDMETHODIMP_(ULONG) CTxtRange::Release()
|
||
|
|
{
|
||
|
|
TRACEBEGIN(TRCSUBSYSTOM, TRCSCOPEEXTERN, "CTxtRange::Release");
|
||
|
|
|
||
|
|
_cRefs--;
|
||
|
|
|
||
|
|
if(!_cRefs)
|
||
|
|
{
|
||
|
|
delete this;
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
Assert(_cRefs > 0);
|
||
|
|
return _cRefs;
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
//------------------------ CTxtRange IDispatch Methods -------------------------------------
|
||
|
|
|
||
|
|
/*
|
||
|
|
* CTxtRange::GetTypeInfoCount(pcTypeInfo)
|
||
|
|
*
|
||
|
|
* @mfunc
|
||
|
|
* Get the number of TYPEINFO elements (1)
|
||
|
|
*
|
||
|
|
* @rdesc
|
||
|
|
* HRESULT
|
||
|
|
*/
|
||
|
|
STDMETHODIMP CTxtRange::GetTypeInfoCount (
|
||
|
|
UINT * pcTypeInfo) //@parm Out parm to receive type-info count
|
||
|
|
{
|
||
|
|
TRACEBEGIN(TRCSUBSYSTOM, TRCSCOPEEXTERN, "CTxtRange::GetTypeInfoCount");
|
||
|
|
|
||
|
|
if(!pcTypeInfo)
|
||
|
|
return E_INVALIDARG;
|
||
|
|
|
||
|
|
*pcTypeInfo = 1;
|
||
|
|
return NOERROR;
|
||
|
|
}
|
||
|
|
|
||
|
|
/*
|
||
|
|
* CTxtRange::GetTypeInfo(iTypeInfo, lcid, ppTypeInfo)
|
||
|
|
*
|
||
|
|
* @mfunc
|
||
|
|
* Return ptr to type information object for ITextSelection interface
|
||
|
|
*
|
||
|
|
* @rdesc
|
||
|
|
* HRESULT
|
||
|
|
*/
|
||
|
|
STDMETHODIMP CTxtRange::GetTypeInfo (
|
||
|
|
UINT iTypeInfo, //@parm Index of type info to return
|
||
|
|
LCID lcid, //@parm Local ID of type info
|
||
|
|
ITypeInfo **ppTypeInfo) //@parm Out parm to receive type info
|
||
|
|
{
|
||
|
|
TRACEBEGIN(TRCSUBSYSTOM, TRCSCOPEEXTERN, "CTxtRange::GetTypeInfo");
|
||
|
|
|
||
|
|
return ::GetTypeInfo(iTypeInfo, g_pTypeInfoSel, ppTypeInfo);
|
||
|
|
}
|
||
|
|
|
||
|
|
/*
|
||
|
|
* CTxtRange::GetIDsOfNames(riid, rgszNames, cNames, lcid, rgdispid)
|
||
|
|
*
|
||
|
|
* @mfunc
|
||
|
|
* Get DISPIDs for methods in the ITextSelection, ITextRange, ITextFont,
|
||
|
|
* and ITextPara interfaces
|
||
|
|
*
|
||
|
|
* @rdesc
|
||
|
|
* HRESULT
|
||
|
|
*
|
||
|
|
* @devnote
|
||
|
|
* If the ITextFont and ITextPara ever offer more methods than exposed
|
||
|
|
* in their type libraries, the code should delegate to the corresponding
|
||
|
|
* GetIDsOfNames. The current code only gets DISPIDs for the methods in
|
||
|
|
* type libraries, thereby not having to instantiate the objects.
|
||
|
|
*/
|
||
|
|
STDMETHODIMP CTxtRange::GetIDsOfNames (
|
||
|
|
REFIID riid, //@parm Interface ID to interpret names for
|
||
|
|
OLECHAR ** rgszNames, //@parm Array of names to be mapped
|
||
|
|
UINT cNames, //@parm Count of names to be mapped
|
||
|
|
LCID lcid, //@parm Local ID to use for interpretation
|
||
|
|
DISPID * rgdispid) //@parm Out parm to receive name mappings
|
||
|
|
{
|
||
|
|
TRACEBEGIN(TRCSUBSYSTOM, TRCSCOPEEXTERN, "CTxtRange::GetIDsOfNames");
|
||
|
|
|
||
|
|
HRESULT hr = GetTypeInfoPtrs(); // Ensure TypeInfo ptrs are OK
|
||
|
|
if(hr != NOERROR)
|
||
|
|
return hr;
|
||
|
|
|
||
|
|
if(g_pTypeInfoSel->GetIDsOfNames(rgszNames, cNames, rgdispid) == NOERROR)
|
||
|
|
return NOERROR;
|
||
|
|
|
||
|
|
if(g_pTypeInfoFont->GetIDsOfNames(rgszNames, cNames, rgdispid) == NOERROR)
|
||
|
|
return NOERROR;
|
||
|
|
|
||
|
|
return g_pTypeInfoPara->GetIDsOfNames(rgszNames, cNames, rgdispid);
|
||
|
|
}
|
||
|
|
|
||
|
|
/*
|
||
|
|
* CTxtRange::Invoke(dispidMember, riid, lcid, wFlags, pdispparams,
|
||
|
|
* pvarResult, pexcepinfo, puArgError)
|
||
|
|
* @mfunc
|
||
|
|
* Invoke methods for the ITextRange and ITextSelection objects, as
|
||
|
|
* well as for ITextFont and ITextPara interfaces on those objects.
|
||
|
|
*
|
||
|
|
* @rdesc
|
||
|
|
* HRESULT
|
||
|
|
*/
|
||
|
|
STDMETHODIMP CTxtRange::Invoke (
|
||
|
|
DISPID dispidMember, //@parm Identifies member function
|
||
|
|
REFIID riid, //@parm Pointer to interface ID
|
||
|
|
LCID lcid, //@parm Locale ID for interpretation
|
||
|
|
USHORT wFlags, //@parm Flags describing context of call
|
||
|
|
DISPPARAMS *pdispparams, //@parm Ptr to method arguments
|
||
|
|
VARIANT * pvarResult, //@parm Out parm for result (if not NULL)
|
||
|
|
EXCEPINFO * pexcepinfo, //@parm Out parm for exception info
|
||
|
|
UINT * puArgError) //@parm Out parm for error
|
||
|
|
{
|
||
|
|
TRACEBEGIN(TRCSUBSYSTOM, TRCSCOPEEXTERN, "CTxtRange::Invoke");
|
||
|
|
|
||
|
|
HRESULT hr = GetTypeInfoPtrs(); // Ensure TypeInfo ptrs are OK
|
||
|
|
if(hr != NOERROR)
|
||
|
|
return hr;
|
||
|
|
|
||
|
|
if(IsZombie())
|
||
|
|
return CO_E_RELEASED;
|
||
|
|
|
||
|
|
IDispatch * pDispatch;
|
||
|
|
ITypeInfo * pTypeInfo;
|
||
|
|
|
||
|
|
if((DWORD)dispidMember <= 0x2ff) // Include default (0), selection,
|
||
|
|
{ // and range DISPIDs
|
||
|
|
pTypeInfo = g_pTypeInfoSel;
|
||
|
|
pDispatch = this;
|
||
|
|
AddRef(); // Compensate for Release() below
|
||
|
|
}
|
||
|
|
else if((DWORD)dispidMember <= 0x3ff) // 0x300 to 0x3ff: DISPIDs
|
||
|
|
{ // reserved for ITextFont
|
||
|
|
pTypeInfo = g_pTypeInfoFont;
|
||
|
|
hr = GetFont((ITextFont**)&pDispatch);
|
||
|
|
}
|
||
|
|
else if((DWORD)dispidMember <= 0x4ff) // 0x400 to 0x4ff: DISPIDs
|
||
|
|
{ // reserved for ITextPara
|
||
|
|
pTypeInfo = g_pTypeInfoPara;
|
||
|
|
hr = GetPara((ITextPara **)&pDispatch);
|
||
|
|
}
|
||
|
|
else // dispidMember is negative or
|
||
|
|
return DISP_E_MEMBERNOTFOUND; // > 0x4ff, i.e., not TOM
|
||
|
|
|
||
|
|
if(hr != NOERROR) // Couldn't instantiate ITextFont
|
||
|
|
return hr; // or ITextPara
|
||
|
|
|
||
|
|
hr = pTypeInfo->Invoke(pDispatch, dispidMember, wFlags,
|
||
|
|
pdispparams, pvarResult, pexcepinfo, puArgError);
|
||
|
|
#ifndef PEGASUS
|
||
|
|
pDispatch->Release();
|
||
|
|
#endif
|
||
|
|
return hr;
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
//----------------------- ITextRange Methods/Properties ------------------------
|
||
|
|
|
||
|
|
/*
|
||
|
|
* CTxtRange::CanEdit (pB)
|
||
|
|
*
|
||
|
|
* @mfunc
|
||
|
|
* Set *<p pB> = tomTrue iff this range can be edited and
|
||
|
|
* pB isn't NULL
|
||
|
|
*
|
||
|
|
* @rdesc
|
||
|
|
* HRESULT = (can edit) ? NOERROR : S_FALSE
|
||
|
|
*/
|
||
|
|
STDMETHODIMP CTxtRange::CanEdit (
|
||
|
|
long * pB) //@parm Out parm to receive boolean value
|
||
|
|
{
|
||
|
|
TRACEBEGIN(TRCSUBSYSTOM, TRCSCOPEEXTERN, "CTxtRange::CanEdit");
|
||
|
|
|
||
|
|
if(IsZombie())
|
||
|
|
return CO_E_RELEASED;
|
||
|
|
|
||
|
|
CCallMgr callmgr(GetPed());
|
||
|
|
return IsTrue(!WriteAccessDenied(), pB);
|
||
|
|
}
|
||
|
|
|
||
|
|
/*
|
||
|
|
* CTxtRange::CanPaste (pVar, long Format, pB)
|
||
|
|
*
|
||
|
|
* @mfunc
|
||
|
|
* Set *<p pB> = tomTrue iff the data object <p pVar>->punkVal can be
|
||
|
|
* pasted into this range and pB isn't NULL. If <p pVar> is NULL,
|
||
|
|
* use the clipboard instead.
|
||
|
|
*
|
||
|
|
* @rdesc
|
||
|
|
* HRESULT = (can paste) ? NOERROR : S_FALSE
|
||
|
|
*/
|
||
|
|
STDMETHODIMP CTxtRange::CanPaste (
|
||
|
|
VARIANT * pVar, //@parm Data object to paste
|
||
|
|
long Format, //@parm Desired clipboard format
|
||
|
|
long * pB) //@parm Out parm to receive boolean value
|
||
|
|
{
|
||
|
|
#ifndef PEGASUS
|
||
|
|
TRACEBEGIN(TRCSUBSYSTOM, TRCSCOPEEXTERN, "CTxtRange::CanPaste");
|
||
|
|
|
||
|
|
if(IsZombie())
|
||
|
|
return CO_E_RELEASED;
|
||
|
|
|
||
|
|
CCallMgr callmgr(GetPed());
|
||
|
|
HRESULT hr;
|
||
|
|
IDataObject * pdo = NULL; // Default clipboard
|
||
|
|
|
||
|
|
if(pVar && pVar->vt == VT_UNKNOWN)
|
||
|
|
pVar->punkVal->QueryInterface(IID_IDataObject, (void **)&pdo);
|
||
|
|
|
||
|
|
hr = IsTrue(!WriteAccessDenied() &&
|
||
|
|
(GetPed()->GetDTE()->CanPaste(pdo, (CLIPFORMAT)Format,
|
||
|
|
RECO_PASTE)), pB);
|
||
|
|
if(pdo)
|
||
|
|
pdo->Release();
|
||
|
|
|
||
|
|
return hr;
|
||
|
|
#else
|
||
|
|
return 0;
|
||
|
|
#endif
|
||
|
|
}
|
||
|
|
|
||
|
|
/*
|
||
|
|
* ITextRange::ChangeCase (long Type)
|
||
|
|
*
|
||
|
|
* @mfunc
|
||
|
|
* Change the case of letters in this range according to Type:
|
||
|
|
*
|
||
|
|
* tomSentenceCase = 0: capitalize first letter of each sentence
|
||
|
|
* tomLowerCase = 1: change all letters to lower case
|
||
|
|
* tomUpperCase = 2: change all letters to upper case
|
||
|
|
* tomTitleCase = 3: capitalize the first letter of each word
|
||
|
|
* tomToggleCase = 4: toggle the case of each letter
|
||
|
|
*
|
||
|
|
* @rdesc
|
||
|
|
* HRESULT = (WriteAccessDenied) ? E_ACCESSDENIED :
|
||
|
|
* (if change) ? NOERROR : S_FALSE
|
||
|
|
*/
|
||
|
|
STDMETHODIMP CTxtRange::ChangeCase (
|
||
|
|
long Type) //@parm Type of case change. Default value: tomLower
|
||
|
|
{
|
||
|
|
TRACEBEGIN(TRCSUBSYSTOM, TRCSCOPEEXTERN, "CTxtRange::ChangeCase");
|
||
|
|
|
||
|
|
if(IsZombie())
|
||
|
|
return CO_E_RELEASED;
|
||
|
|
|
||
|
|
CCallMgr callmgr(GetPed());
|
||
|
|
|
||
|
|
if(WriteAccessDenied())
|
||
|
|
return E_ACCESSDENIED;
|
||
|
|
|
||
|
|
IUndoBuilder * publdr;
|
||
|
|
CGenUndoBuilder undobldr(GetPed(), UB_AUTOCOMMIT, &publdr);
|
||
|
|
LONG cpMin, cpMax;
|
||
|
|
LONG cch = GetRange(cpMin, cpMax);
|
||
|
|
CRchTxtPtr rtp(*this);
|
||
|
|
|
||
|
|
undobldr.StopGroupTyping();
|
||
|
|
|
||
|
|
rtp.SetCp(cpMin);
|
||
|
|
return (rtp.ChangeCase(cch, Type, publdr)) ? NOERROR : S_FALSE;
|
||
|
|
}
|
||
|
|
|
||
|
|
/*
|
||
|
|
* CTxtRange::Collapse (bStart)
|
||
|
|
*
|
||
|
|
* @mfunc
|
||
|
|
* Collapse this range into a degenerate point either at the
|
||
|
|
* the start (<p bStart> is nonzero or the end (<p bStart> = 0)
|
||
|
|
*
|
||
|
|
* @rdesc
|
||
|
|
* HRESULT = (if change) ? NOERROR : S_FALSE
|
||
|
|
*/
|
||
|
|
STDMETHODIMP CTxtRange::Collapse (
|
||
|
|
long bStart) //@parm Flag specifying end to collapse at
|
||
|
|
{
|
||
|
|
TRACEBEGIN(TRCSUBSYSTOM, TRCSCOPEEXTERN, "CTxtRange::Collapse");
|
||
|
|
|
||
|
|
if(IsZombie())
|
||
|
|
return CO_E_RELEASED;
|
||
|
|
|
||
|
|
CCallMgr callmgr(GetPed());
|
||
|
|
|
||
|
|
if(!_cch) // Already collapsed
|
||
|
|
return S_FALSE; // Signal that no change occurred
|
||
|
|
|
||
|
|
Collapser(bStart);
|
||
|
|
Update(TRUE); // Update selection
|
||
|
|
return NOERROR; // Signal that change occurred
|
||
|
|
}
|
||
|
|
|
||
|
|
/*
|
||
|
|
* CTxtRange::Copy (pVar)
|
||
|
|
*
|
||
|
|
* @mfunc
|
||
|
|
* Copy the plain and/or rich text to a data object and return the
|
||
|
|
* object ptr in <p pVar>. If <p pVar> is null, copy to the clipboard.
|
||
|
|
*
|
||
|
|
* @rdesc
|
||
|
|
* HRESULT = (if success) ? NOERROR : E_OUTOFMEMORY
|
||
|
|
*/
|
||
|
|
STDMETHODIMP CTxtRange::Copy (
|
||
|
|
VARIANT * pVar) //@parm Out parm for data object
|
||
|
|
{
|
||
|
|
#ifndef PEGASUS
|
||
|
|
TRACEBEGIN(TRCSUBSYSTOM, TRCSCOPEEXTERN, "CTxtRange::Copy");
|
||
|
|
|
||
|
|
if(IsZombie())
|
||
|
|
return CO_E_RELEASED;
|
||
|
|
|
||
|
|
CLightDTEngine * pldte = &GetPed()->_ldte;
|
||
|
|
|
||
|
|
if(pVar && pVar->vt == (VT_UNKNOWN | VT_BYREF))
|
||
|
|
{
|
||
|
|
return pldte->RangeToDataObject(this, SF_TEXT | SF_RTF,
|
||
|
|
(IDataObject **)pVar->ppunkVal);
|
||
|
|
}
|
||
|
|
return pldte->CopyRangeToClipboard(this);
|
||
|
|
#else
|
||
|
|
return 0;
|
||
|
|
#endif
|
||
|
|
}
|
||
|
|
|
||
|
|
/*
|
||
|
|
* CTxtRange::Cut (pVar)
|
||
|
|
*
|
||
|
|
* @mfunc
|
||
|
|
* Cut the plain and/or rich text to a data object and return the
|
||
|
|
* object ptr in <p pVar>. If <p pVar> is null,
|
||
|
|
* cut to the clipboard.
|
||
|
|
*
|
||
|
|
* @rdesc
|
||
|
|
* HRESULT = (if success) ? NOERROR : E_OUTOFMEMORY
|
||
|
|
*/
|
||
|
|
STDMETHODIMP CTxtRange::Cut (
|
||
|
|
VARIANT * pVar) //@parm Out parm for data object
|
||
|
|
{
|
||
|
|
TRACEBEGIN(TRCSUBSYSTOM, TRCSCOPEEXTERN, "CTxtRange::Cut");
|
||
|
|
|
||
|
|
if(IsZombie())
|
||
|
|
return CO_E_RELEASED;
|
||
|
|
|
||
|
|
CCallMgr callmgr(GetPed());
|
||
|
|
|
||
|
|
if(WriteAccessDenied())
|
||
|
|
return E_ACCESSDENIED;
|
||
|
|
|
||
|
|
HRESULT hr = Copy(pVar);
|
||
|
|
|
||
|
|
Replacer(0, NULL);
|
||
|
|
return hr;
|
||
|
|
}
|
||
|
|
|
||
|
|
/*
|
||
|
|
* CTxtRange::Delete (Unit, Count, pDelta)
|
||
|
|
*
|
||
|
|
* @mfunc
|
||
|
|
* If this range is nondegenerate, delete it along with |Count| - 1 Units
|
||
|
|
* in the direction specified by the sign of Count. If this range is
|
||
|
|
* degenerate, delete Count Units.
|
||
|
|
*
|
||
|
|
* @rdesc
|
||
|
|
* HRESULT = (WriteAccessDenied) ? E_ACCESSDENIED :
|
||
|
|
* (all requested Units deleted) ? NOERROR : S_FALSE
|
||
|
|
*/
|
||
|
|
STDMETHODIMP CTxtRange::Delete (
|
||
|
|
long Unit, //@parm Unit to use
|
||
|
|
long Count, //@parm Number of chars to delete
|
||
|
|
long * pDelta) //@parm Out parm to receive count of units deleted
|
||
|
|
{
|
||
|
|
TRACEBEGIN(TRCSUBSYSTOM, TRCSCOPEEXTERN, "CTxtRange::Delete");
|
||
|
|
|
||
|
|
if(pDelta)
|
||
|
|
*pDelta = 0;
|
||
|
|
|
||
|
|
if(IsZombie())
|
||
|
|
return CO_E_RELEASED;
|
||
|
|
|
||
|
|
CCallMgr callmgr(GetPed());
|
||
|
|
|
||
|
|
if(WriteAccessDenied())
|
||
|
|
return E_ACCESSDENIED;
|
||
|
|
|
||
|
|
LONG cchSave = _cch; // Remember initial count
|
||
|
|
LONG cchText = GetAdjustedTextLength();
|
||
|
|
LONG CountOrg = Count;
|
||
|
|
LONG cpMin, cpMost;
|
||
|
|
LONG cUnit = 0; // Default no Units
|
||
|
|
MOVES Mode = (Count >= 0) ? MOVE_END : MOVE_START;
|
||
|
|
|
||
|
|
GetRange(cpMin, cpMost);
|
||
|
|
if(cpMost > cchText) // Can't delete final CR. To get
|
||
|
|
{ // *pDelta right, handle here
|
||
|
|
Set(cpMin, cpMin - cchText); // Backup before CR & set active
|
||
|
|
if(Count > 0) // end at cpMin since there's
|
||
|
|
{ // nothing to delete forward
|
||
|
|
Count = 0;
|
||
|
|
if(!_cch) // Only collapsed selection of
|
||
|
|
Mode = MOVE_IP; // final CR: set up nothing
|
||
|
|
} // deleted (MOVE_IP = 0)
|
||
|
|
}
|
||
|
|
if(Count)
|
||
|
|
{
|
||
|
|
if((_cch ^ Mode) < 0) // Be sure active end is in
|
||
|
|
FlipRange(); // deletion direction
|
||
|
|
if(cchSave) // Deleting nondegenerate range
|
||
|
|
Count -= Mode; // counts as one unit
|
||
|
|
if(Mover(Unit, Count, &cUnit, Mode) // Try to expand range for
|
||
|
|
== E_INVALIDARG) // remaining Count Units
|
||
|
|
{
|
||
|
|
if(pDelta)
|
||
|
|
*pDelta = 0;
|
||
|
|
return E_INVALIDARG;
|
||
|
|
}
|
||
|
|
if(GetCp() > cchText && cUnit > 0) // Range includes final CR, which
|
||
|
|
{ // cannot be deleted. Reduce
|
||
|
|
if(Unit == tomCharacter) // counts for some Units
|
||
|
|
cUnit -= GetTextLength() - cchText;
|
||
|
|
else if(Unit == tomWord)
|
||
|
|
cUnit--; // An EOP qualifies as a tomWord
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
if(cchSave) // Deleting nondegenerate range
|
||
|
|
cUnit += Mode; // counts as a Unit
|
||
|
|
|
||
|
|
if(pDelta)
|
||
|
|
*pDelta = cUnit;
|
||
|
|
|
||
|
|
if(_cch) // Mover() may have changed _cch
|
||
|
|
{
|
||
|
|
IUndoBuilder * publdr;
|
||
|
|
CGenUndoBuilder undobldr(GetPed(), UB_AUTOCOMMIT, &publdr);
|
||
|
|
|
||
|
|
if (publdr)
|
||
|
|
{
|
||
|
|
publdr->StopGroupTyping();
|
||
|
|
publdr->SetNameID(UID_DELETE);
|
||
|
|
}
|
||
|
|
|
||
|
|
// FUTURE (murrays): the cchSave case should set up undo to
|
||
|
|
// restore the original range, not the extended range resulting
|
||
|
|
// when |CountOrg| > 1. This could be done using two calls to
|
||
|
|
// ReplaceRange(), one to delete the original range and one to
|
||
|
|
// delete the rest
|
||
|
|
SELRR selrr = !_fSel || cchSave ? SELRR_REMEMBERRANGE :
|
||
|
|
CountOrg > 0 ? SELRR_REMEMBERCPMIN :
|
||
|
|
SELRR_REMEMBERENDIP;
|
||
|
|
|
||
|
|
ReplaceRange(0, NULL, publdr, selrr);
|
||
|
|
|
||
|
|
if (cUnit == CountOrg || // Delete(Unit,0,0)
|
||
|
|
cUnit == 1 && !CountOrg) // deletes one "Unit", namely
|
||
|
|
{ // what's selected
|
||
|
|
return NOERROR; // Signal everything deleted as
|
||
|
|
} // requested
|
||
|
|
}
|
||
|
|
else if(cchSave) // Collapsed selection of final CR
|
||
|
|
{ // but didn't delete anything
|
||
|
|
Update(TRUE); // Selection highlighting changed
|
||
|
|
}
|
||
|
|
return S_FALSE; // Less deleted than requested
|
||
|
|
}
|
||
|
|
|
||
|
|
/*
|
||
|
|
* CTxtRange::EndOf (Unit, Extend, pDelta)
|
||
|
|
*
|
||
|
|
* @mfunc
|
||
|
|
* Move this range end(s) to end of the first overlapping Unit in
|
||
|
|
* the range.
|
||
|
|
*
|
||
|
|
* @rdesc
|
||
|
|
* HRESULT = (if change) ? NOERROR :
|
||
|
|
* (if Unit supported) ? S_FALSE : E_NOTIMPL
|
||
|
|
*/
|
||
|
|
STDMETHODIMP CTxtRange::EndOf (
|
||
|
|
long Unit, //@parm Unit to use
|
||
|
|
long Extend, //@parm If true, leave other end alone
|
||
|
|
long * pDelta) //@parm Count of chars that End is moved
|
||
|
|
{
|
||
|
|
TRACEBEGIN(TRCSUBSYSTOM, TRCSCOPEEXTERN, "CTxtRange::EndOf");
|
||
|
|
|
||
|
|
CCallMgr callmgr(GetPed());
|
||
|
|
LONG cpMost;
|
||
|
|
|
||
|
|
HRESULT hr = Expander (Unit, Extend, pDelta, NULL, &cpMost);
|
||
|
|
if(hr == NOERROR)
|
||
|
|
Update(TRUE); // Update selection
|
||
|
|
|
||
|
|
return hr;
|
||
|
|
}
|
||
|
|
|
||
|
|
/*
|
||
|
|
* CTxtRange::Expand (Unit, pDelta)
|
||
|
|
*
|
||
|
|
* @mfunc
|
||
|
|
* Expand this range so that any partial Units it contains are
|
||
|
|
* completely contained. If this range consists of one or more full
|
||
|
|
* Units, no change is made. If this range is an insertion point at
|
||
|
|
* the beginning or within a Unit, Expand() expands this range to include
|
||
|
|
* that Unit. If this range is an insertion point at the end of the
|
||
|
|
* story, Expand() tries to set this range to include the last Unit in
|
||
|
|
* the story. The active end is always cpMost except for the last case.
|
||
|
|
*
|
||
|
|
* @rdesc
|
||
|
|
* HRESULT = (if change) ? NOERROR :
|
||
|
|
* (if Unit supported) ? S_FALSE : E_NOTIMPL
|
||
|
|
*/
|
||
|
|
STDMETHODIMP CTxtRange::Expand (
|
||
|
|
long Unit, //@parm Unit to expand range to
|
||
|
|
long * pDelta) //@parm Out parm to receive count of chars added
|
||
|
|
{
|
||
|
|
TRACEBEGIN(TRCSUBSYSTOM, TRCSCOPEEXTERN, "CTxtRange::Expand");
|
||
|
|
|
||
|
|
CCallMgr callmgr(GetPed());
|
||
|
|
LONG cpMin, cpMost;
|
||
|
|
|
||
|
|
HRESULT hr = Expander (Unit, TRUE, pDelta, &cpMin, &cpMost);
|
||
|
|
if(hr == NOERROR)
|
||
|
|
Update(TRUE); // Update selection
|
||
|
|
|
||
|
|
return hr;
|
||
|
|
}
|
||
|
|
|
||
|
|
/*
|
||
|
|
* CTxtRange::FindText (bstr, cch, Flags, pLength)
|
||
|
|
*
|
||
|
|
* @mfunc
|
||
|
|
* If this range isn't an insertion point already, convert it into an
|
||
|
|
* insertion point at its End if <p cch> <gt> 0 and at its Start if
|
||
|
|
* <p cch> <lt> 0. Then search up to <p cch> characters of the range
|
||
|
|
* looking for the string <p bstr> subject to the compare flags
|
||
|
|
* <p Flags>. If <p cch> <gt> 0, the search is forward and if <p cch>
|
||
|
|
* <lt> 0 the search is backward. If the string is found, the range
|
||
|
|
* limits are changed to be those of the matched string and *<p pLength>
|
||
|
|
* is set equal to the length of the string. If the string isn't found,
|
||
|
|
* the range remains unchanged and *<p pLength> is set equal to 0.
|
||
|
|
*
|
||
|
|
* @rdesc
|
||
|
|
* HRESULT = (if <p bstr> found) ? NOERROR : S_FALSE
|
||
|
|
*
|
||
|
|
* @devnote
|
||
|
|
* Argument validation of the three Find methods is done by the helper
|
||
|
|
* function CTxtRange::Finder(bstr, cch, dwFlags, pDelta, fExtend, fFlip)
|
||
|
|
*/
|
||
|
|
STDMETHODIMP CTxtRange::FindText (
|
||
|
|
BSTR bstr, //@parm String to find
|
||
|
|
long Count, //@parm Max count of chars to search
|
||
|
|
long Flags, //@parm Flags governing compares
|
||
|
|
long * pDelta) //@parm Out parm to receive count of chars moved
|
||
|
|
{
|
||
|
|
TRACEBEGIN(TRCSUBSYSTOM, TRCSCOPEEXTERN, "CTxtRange::FindText");
|
||
|
|
|
||
|
|
return Finder(bstr, Count, Flags, pDelta, MOVE_IP);
|
||
|
|
}
|
||
|
|
|
||
|
|
/*
|
||
|
|
* CTxtRange::FindTextEnd (bstr, cch, Flags, pLength)
|
||
|
|
*
|
||
|
|
* @mfunc
|
||
|
|
* Starting from this range's End, search up to <p cch> characters
|
||
|
|
* looking for the string <p bstr> subject to the compare flags
|
||
|
|
* <p Flags>. If <p cch> <gt> 0, the search is forward and if <p cch>
|
||
|
|
* <lt> 0 the search is backward. If the string is found, the range
|
||
|
|
* limits are changed to be those of the matched string and *<p pLength>
|
||
|
|
* is set equal to the length of the string. If the string isn't found,
|
||
|
|
* the range remains unchanged and *<p pLength> is set equal to 0.
|
||
|
|
*
|
||
|
|
* @rdesc
|
||
|
|
* HRESULT = (if <p bstr> found) ? NOERROR : S_FALSE
|
||
|
|
*/
|
||
|
|
STDMETHODIMP CTxtRange::FindTextEnd (
|
||
|
|
BSTR bstr, //@parm String to find
|
||
|
|
long Count, //@parm Max count of chars to search
|
||
|
|
long Flags, //@parm Flags governing compares
|
||
|
|
long * pDelta) //@parm Out parm to receive count of chars moved
|
||
|
|
{
|
||
|
|
TRACEBEGIN(TRCSUBSYSTOM, TRCSCOPEEXTERN, "CTxtRange::FindTextEnd");
|
||
|
|
|
||
|
|
return Finder(bstr, Count, Flags, pDelta, MOVE_END);
|
||
|
|
}
|
||
|
|
|
||
|
|
/*
|
||
|
|
* CTxtRange::FindTextStart (bstr, cch, Flags, pDelta)
|
||
|
|
*
|
||
|
|
* @mfunc
|
||
|
|
* Starting from this range's Start, search up to <p cch> characters
|
||
|
|
* looking for the string <p bstr> subject to the compare flags
|
||
|
|
* <p Flags>. If <p cch> <gt> 0, the search is forward and if <p cch>
|
||
|
|
* <lt> 0 the search is backward. If the string is found, the range
|
||
|
|
* limits are changed to be those of the matched string and *<p pLength>
|
||
|
|
* is set equal to the length of the string. If the string isn't found,
|
||
|
|
* the range remains unchanged and *<p pLength> is set equal to 0.
|
||
|
|
*
|
||
|
|
* @rdesc
|
||
|
|
* HRESULT = (if <p bstr> found) ? NOERROR : S_FALSE
|
||
|
|
*/
|
||
|
|
STDMETHODIMP CTxtRange::FindTextStart (
|
||
|
|
BSTR bstr, //@parm String to find
|
||
|
|
long Count, //@parm Max count of chars to search
|
||
|
|
long Flags, //@parm Flags governing compares
|
||
|
|
long * pDelta) //@parm Out parm to receive count of chars moved
|
||
|
|
{
|
||
|
|
TRACEBEGIN(TRCSUBSYSTOM, TRCSCOPEEXTERN, "CTxtRange::FindTextStart");
|
||
|
|
|
||
|
|
return Finder(bstr, Count, Flags, pDelta, MOVE_START);
|
||
|
|
}
|
||
|
|
|
||
|
|
/*
|
||
|
|
* CTxtRange::GetChar (pChar)
|
||
|
|
*
|
||
|
|
* @mfunc
|
||
|
|
* Set *<p pChar> equal to the character at cpFirst
|
||
|
|
*
|
||
|
|
* @rdesc
|
||
|
|
* HRESULT = (<p pChar>) NOERROR ? E_INVALIDARG
|
||
|
|
*
|
||
|
|
* @devnote
|
||
|
|
* This method is very handy for walking a range character by character
|
||
|
|
* from the Start. Accordingly, it's desirable that the active end
|
||
|
|
* is at the Start. We set this up for a range, since the API doesn't
|
||
|
|
* care which range end is active. But we can't do this for a selection,
|
||
|
|
* since the selection API depends on the active end.
|
||
|
|
*/
|
||
|
|
STDMETHODIMP CTxtRange::GetChar (
|
||
|
|
long * pChar) //@parm Out parm for char
|
||
|
|
{
|
||
|
|
TRACEBEGIN(TRCSUBSYSTOM, TRCSCOPEEXTERN, "CTxtRange::GetChar");
|
||
|
|
|
||
|
|
HRESULT hr = GetLong(0, pChar);
|
||
|
|
if(hr != NOERROR)
|
||
|
|
return hr;
|
||
|
|
|
||
|
|
if(_cch > 0) // Active end at cpMost (End)
|
||
|
|
{
|
||
|
|
if(_fSel)
|
||
|
|
{
|
||
|
|
CTxtPtr tp(_rpTX); // For selection, can't change
|
||
|
|
tp.AdvanceCp(-_cch); // active end
|
||
|
|
*pChar = (long)(tp.GetChar());
|
||
|
|
return NOERROR;
|
||
|
|
}
|
||
|
|
FlipRange(); // For range, it's more efficient
|
||
|
|
} // to work from cpFirst and API
|
||
|
|
*(DWORD *)pChar = _rpTX.GetChar(); // doesn't expose RichEdit active
|
||
|
|
// end
|
||
|
|
return NOERROR;
|
||
|
|
}
|
||
|
|
|
||
|
|
/*
|
||
|
|
* CTxtRange::GetDuplicate (ppRange)
|
||
|
|
*
|
||
|
|
* @mfunc
|
||
|
|
* Get a clone of this range object. For example, you may want to
|
||
|
|
* create an insertion point to traverse a range, so you clone the
|
||
|
|
* range and then set the clone's cpLim equal to its cpFirst. A range
|
||
|
|
* is characterized by its cpFirst, cpLim, and the story it belongs to.
|
||
|
|
*
|
||
|
|
* @rdesc
|
||
|
|
* HRESULT = (if success) ? NOERROR :
|
||
|
|
* (<p ppRange>) ? E_OUTOFMEMORY : E_INVALIDARG
|
||
|
|
*
|
||
|
|
* @comm
|
||
|
|
* Even if this range is a selection, the clone returned is still only
|
||
|
|
* a range.
|
||
|
|
*/
|
||
|
|
STDMETHODIMP CTxtRange::GetDuplicate (
|
||
|
|
ITextRange ** ppRange) //@parm Out parm to receive duplicate of range
|
||
|
|
{
|
||
|
|
TRACEBEGIN(TRCSUBSYSTOM, TRCSCOPEEXTERN, "CTxtRange::GetDuplicate");
|
||
|
|
|
||
|
|
HRESULT hr = GetLong(NULL, (LONG *)ppRange);
|
||
|
|
if(hr != NOERROR)
|
||
|
|
return hr;
|
||
|
|
|
||
|
|
ITextRange *prg = new CTxtRange(*this);
|
||
|
|
if(prg)
|
||
|
|
{
|
||
|
|
*ppRange = prg;
|
||
|
|
prg->AddRef();
|
||
|
|
return NOERROR;
|
||
|
|
}
|
||
|
|
return E_OUTOFMEMORY;
|
||
|
|
}
|
||
|
|
|
||
|
|
/*
|
||
|
|
* ITextRange::GetEmbeddedObject (ppV)
|
||
|
|
*
|
||
|
|
* @mfunc
|
||
|
|
* Property get method that gets a ptr to the object at cpFirst
|
||
|
|
*
|
||
|
|
* @rdesc
|
||
|
|
* HRESULT = (!ppV) ? E_INVALIDARG :
|
||
|
|
* (object found) ? NOERROR : S_FALSE
|
||
|
|
*/
|
||
|
|
STDMETHODIMP CTxtRange::GetEmbeddedObject (
|
||
|
|
IUnknown **ppV) //@parm Out parm to receive embedded object
|
||
|
|
{
|
||
|
|
HRESULT hr = GetLong(NULL, (LONG *)ppV);
|
||
|
|
if(hr != NOERROR)
|
||
|
|
return hr;
|
||
|
|
|
||
|
|
if(GetObjectCount())
|
||
|
|
{
|
||
|
|
COleObject *pobj = GetPed()->_pobjmgr->GetObjectFromCp(GetCpMin());
|
||
|
|
|
||
|
|
if(pobj && (*ppV = pobj->GetIUnknown()) != NULL)
|
||
|
|
{
|
||
|
|
(*ppV)->AddRef();
|
||
|
|
return NOERROR;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return S_FALSE;
|
||
|
|
}
|
||
|
|
|
||
|
|
/*
|
||
|
|
* CTxtRange::GetEnd (pcpLim)
|
||
|
|
*
|
||
|
|
* @mfunc
|
||
|
|
* Get this range's End (cpMost) cp
|
||
|
|
*
|
||
|
|
* @rdesc
|
||
|
|
* HRESULT = (<p pcpLim>) ? NOERROR : E_INVALIDARG
|
||
|
|
*/
|
||
|
|
STDMETHODIMP CTxtRange::GetEnd (
|
||
|
|
long * pcpLim) //@parm Out parm to receive End cp value
|
||
|
|
{
|
||
|
|
TRACEBEGIN(TRCSUBSYSTOM, TRCSCOPEEXTERN, "CTxtRange::GetEnd");
|
||
|
|
|
||
|
|
return GetLong(GetCpMost(), pcpLim);
|
||
|
|
}
|
||
|
|
|
||
|
|
/*
|
||
|
|
* CTxtRange::GetFont (ppFont)
|
||
|
|
*
|
||
|
|
* @mfunc
|
||
|
|
* Get an ITextFont object with the character attributes of this range
|
||
|
|
*
|
||
|
|
* @rdesc
|
||
|
|
* HRESULT = <p ppFont> ? NOERROR : E_INVALIDARG
|
||
|
|
*/
|
||
|
|
STDMETHODIMP CTxtRange::GetFont (
|
||
|
|
ITextFont ** ppFont) //@parm Out parm to receive ITextFont object
|
||
|
|
{
|
||
|
|
TRACEBEGIN(TRCSUBSYSTOM, TRCSCOPEEXTERN, "CTxtRange::GetFont");
|
||
|
|
|
||
|
|
HRESULT hr = GetLong(NULL, (LONG *)ppFont);
|
||
|
|
if(hr != NOERROR)
|
||
|
|
return hr;
|
||
|
|
|
||
|
|
*ppFont = (ITextFont *) new CTxtFont(this);
|
||
|
|
return *ppFont ? NOERROR : E_OUTOFMEMORY;
|
||
|
|
}
|
||
|
|
|
||
|
|
/*
|
||
|
|
* CTxtRange::GetFormattedText (ppRange)
|
||
|
|
*
|
||
|
|
* @mfunc
|
||
|
|
* Retrieves an ITextRange with this range's formatted text.
|
||
|
|
* If <p ppRange> is NULL, the clipboard is the target.
|
||
|
|
*
|
||
|
|
* @rdesc
|
||
|
|
* HRESULT = (if success) ? NOERROR :
|
||
|
|
* (<p ppRange>) ? E_OUTOFMEMORY : E_INVALIDARG
|
||
|
|
*/
|
||
|
|
STDMETHODIMP CTxtRange::GetFormattedText (
|
||
|
|
ITextRange ** ppRange) //@parm Out parm to receive formatted text
|
||
|
|
{
|
||
|
|
TRACEBEGIN(TRCSUBSYSTOM, TRCSCOPEEXTERN, "CTxtRange::GetFormattedText");
|
||
|
|
|
||
|
|
return GetDuplicate(ppRange);
|
||
|
|
}
|
||
|
|
|
||
|
|
/*
|
||
|
|
* CTxtRange::GetIndex (Unit, pIndex)
|
||
|
|
*
|
||
|
|
* @mfunc
|
||
|
|
* Set *<p pIndex> equal to the Unit number at this range's cpFirst
|
||
|
|
*
|
||
|
|
* @rdesc
|
||
|
|
* HRESULT = (!<p pIndex>) ? E_INVALIDARG :
|
||
|
|
* (Unit not implemented) ? E_NOTIMPL :
|
||
|
|
* (Unit available) ? NOERROR : S_FALSE
|
||
|
|
* @future
|
||
|
|
* implement tomWindow?
|
||
|
|
*/
|
||
|
|
STDMETHODIMP CTxtRange::GetIndex (
|
||
|
|
long Unit, //@parm Unit to index
|
||
|
|
long * pIndex) //@parm Out parm to receive index value
|
||
|
|
{
|
||
|
|
TRACEBEGIN(TRCSUBSYSTOM, TRCSCOPEEXTERN, "CTxtRange::GetIndex");
|
||
|
|
|
||
|
|
HRESULT hr = GetLong(0, pIndex);
|
||
|
|
if(hr != NOERROR)
|
||
|
|
return hr;
|
||
|
|
|
||
|
|
LONG cp;
|
||
|
|
LONG cUnit = tomBackward;
|
||
|
|
CTxtRange rg(*this);
|
||
|
|
|
||
|
|
hr = rg.Expander(Unit, FALSE, NULL, // Go to Start of Unit; else
|
||
|
|
&cp, NULL); // UnitCounter gives 1 extra
|
||
|
|
if(FAILED(hr))
|
||
|
|
return hr; // Unit not recognized
|
||
|
|
|
||
|
|
LONG cch = rg.UnitCounter(Unit, cUnit, 0);
|
||
|
|
|
||
|
|
if(cch == tomForward) // UnitCounter() doesn't know
|
||
|
|
return E_NOTIMPL; // Unit
|
||
|
|
|
||
|
|
if(cch == tomBackward) // Unit not in story
|
||
|
|
return S_FALSE;
|
||
|
|
|
||
|
|
*pIndex = -cUnit + 1; // Make count positive and
|
||
|
|
// 1-based
|
||
|
|
return NOERROR;
|
||
|
|
}
|
||
|
|
|
||
|
|
/*
|
||
|
|
* CTxtRange::GetPara (ppPara)
|
||
|
|
*
|
||
|
|
* @mfunc
|
||
|
|
* Get an ITextPara object with the paragraph attributes of this range
|
||
|
|
*
|
||
|
|
* @rdesc
|
||
|
|
* HRESULT = <p ppPara> ? NOERROR : E_INVALIDARG
|
||
|
|
*/
|
||
|
|
STDMETHODIMP CTxtRange::GetPara (
|
||
|
|
ITextPara ** ppPara) //@parm Out parm to receive ITextPara object
|
||
|
|
{
|
||
|
|
TRACEBEGIN(TRCSUBSYSTOM, TRCSCOPEEXTERN, "CTxtRange::GetPara");
|
||
|
|
|
||
|
|
HRESULT hr = GetLong(NULL, (LONG *)ppPara);
|
||
|
|
if(hr != NOERROR)
|
||
|
|
return hr;
|
||
|
|
|
||
|
|
*ppPara = (ITextPara *) new CTxtPara(this);
|
||
|
|
return *ppPara ? NOERROR : E_OUTOFMEMORY;
|
||
|
|
}
|
||
|
|
|
||
|
|
/*
|
||
|
|
* CTxtRange::GetPoint (px, py, Type)
|
||
|
|
*
|
||
|
|
* @mfunc
|
||
|
|
* Get point for selection Start or End and intraline position
|
||
|
|
* as determined by <p Type>.
|
||
|
|
*
|
||
|
|
* @rdesc
|
||
|
|
* HRESULT = (!<p px> or !<p py>) ? E_INVALIDARG :
|
||
|
|
* (if success) ? NOERROR : S_FALSE
|
||
|
|
*/
|
||
|
|
STDMETHODIMP CTxtRange::GetPoint (
|
||
|
|
long Type, //@parm Type of point
|
||
|
|
long * px, //@parm Out parm for x coordinate
|
||
|
|
long * py) //@parm Out parm for y coordinate
|
||
|
|
{
|
||
|
|
TRACEBEGIN(TRCSUBSYSTOM, TRCSCOPEEXTERN, "CTxtSelection::GetPoint");
|
||
|
|
|
||
|
|
if(!px || !py)
|
||
|
|
return E_INVALIDARG;
|
||
|
|
|
||
|
|
*px = *py = 0;
|
||
|
|
|
||
|
|
if(IsZombie())
|
||
|
|
return CO_E_RELEASED;
|
||
|
|
|
||
|
|
LONG ili;
|
||
|
|
BOOL fAtEnd = _cch > 0; // Default value for IP
|
||
|
|
POINT pt;
|
||
|
|
CRchTxtPtr rtp(*this); // Default active end
|
||
|
|
CTxtEdit * ped = GetPed();
|
||
|
|
CDisplay * pdp = ped->_pdp; // Save indirections
|
||
|
|
|
||
|
|
if(!pdp || !ped->fInplaceActive())
|
||
|
|
return E_FAIL; // No display or not active
|
||
|
|
// then we can do nothing.
|
||
|
|
if(fAtEnd ^ !(Type & tomStart)) // Move tp to active end
|
||
|
|
rtp.Advance(-_cch);
|
||
|
|
|
||
|
|
ili = pdp->PointFromTp(rtp, NULL, fAtEnd, pt, NULL, Type & 0x1f);
|
||
|
|
|
||
|
|
RECT rcView; // Verify return value makes
|
||
|
|
// sense since PointFromTp
|
||
|
|
pdp->GetViewRect(rcView, NULL); // may return values outside
|
||
|
|
// client rect
|
||
|
|
rcView.bottom++; // Enlarge Rect to include
|
||
|
|
rcView.right++; // bottom and right edges
|
||
|
|
if(ili >= 0 && PtInRect(&rcView, pt)) // Function succeeded
|
||
|
|
{
|
||
|
|
// Caller wants screen coordinates?
|
||
|
|
if ( !(Type & tomClientCoord) )
|
||
|
|
ped->TxClientToScreen(&pt);
|
||
|
|
|
||
|
|
*px = pt.x;
|
||
|
|
*py = pt.y;
|
||
|
|
return NOERROR;
|
||
|
|
}
|
||
|
|
return S_FALSE; // Function failed
|
||
|
|
}
|
||
|
|
|
||
|
|
/*
|
||
|
|
* CTxtRange::GetStart (pcpFirst)
|
||
|
|
*
|
||
|
|
* @mfunc
|
||
|
|
* Get this range's Start (cpMin) cp
|
||
|
|
*
|
||
|
|
* @rdesc
|
||
|
|
* HRESULT = (<p pcpFirst>) ? NOERROR : E_INVALIDARG
|
||
|
|
*/
|
||
|
|
STDMETHODIMP CTxtRange::GetStart (
|
||
|
|
long * pcpFirst) //@parm Out parm to receive Start cp value
|
||
|
|
{
|
||
|
|
TRACEBEGIN(TRCSUBSYSTOM, TRCSCOPEEXTERN, "CTxtRange::GetStart");
|
||
|
|
|
||
|
|
return GetLong(GetCpMin(), pcpFirst);
|
||
|
|
}
|
||
|
|
|
||
|
|
/*
|
||
|
|
* CTxtRange::GetStoryLength (pcch)
|
||
|
|
*
|
||
|
|
* @mfunc
|
||
|
|
* Set *<p pcch> = count of chars in this range's story
|
||
|
|
*
|
||
|
|
* @rdesc
|
||
|
|
* HRESULT = (<p pcch>) ? NOERROR : E_INVALIDARG
|
||
|
|
*/
|
||
|
|
STDMETHODIMP CTxtRange::GetStoryLength (
|
||
|
|
long * pcch) //@parm Out parm to get length of this range's story
|
||
|
|
{
|
||
|
|
TRACEBEGIN(TRCSUBSYSTOM, TRCSCOPEEXTERN, "CTxtRange::GetStoryLength");
|
||
|
|
|
||
|
|
return GetLong(GetTextLength(), pcch);
|
||
|
|
}
|
||
|
|
|
||
|
|
/*
|
||
|
|
* ITextRange::GetStoryType (pValue)
|
||
|
|
*
|
||
|
|
* @mfunc
|
||
|
|
* Property get method that gets the type of this range's
|
||
|
|
* story.
|
||
|
|
*
|
||
|
|
* @rdesc
|
||
|
|
* HRESULT = (pValue) NOERROR ? E_INVALIDARG
|
||
|
|
*/
|
||
|
|
STDMETHODIMP CTxtRange::GetStoryType (
|
||
|
|
long *pValue) //@parm Out parm to get type of this range's story
|
||
|
|
{
|
||
|
|
TRACEBEGIN(TRCSUBSYSTOM, TRCSCOPEEXTERN, "CTxtRange::GetStoryType");
|
||
|
|
|
||
|
|
return GetLong(tomUnknownStory, pValue);
|
||
|
|
}
|
||
|
|
|
||
|
|
/*
|
||
|
|
* CTxtRange::GetText (pbstr)
|
||
|
|
*
|
||
|
|
* @mfunc
|
||
|
|
* Get plain text in this range. The Text property is the default
|
||
|
|
* property for ITextRange.
|
||
|
|
*
|
||
|
|
* @rdesc
|
||
|
|
* HRESULT = (if success) ? NOERROR :
|
||
|
|
* (!<p pbstr>) ? E_INVALIDARG : E_OUTOFMEMORY
|
||
|
|
*/
|
||
|
|
STDMETHODIMP CTxtRange::GetText (
|
||
|
|
BSTR * pbstr) //@parm Out parm to receive bstr
|
||
|
|
{
|
||
|
|
TRACEBEGIN(TRCSUBSYSTOM, TRCSCOPEEXTERN, "CTxtRange::GetText");
|
||
|
|
|
||
|
|
HRESULT hr = GetLong(NULL, (LONG *)pbstr);
|
||
|
|
if(hr != NOERROR)
|
||
|
|
return hr;
|
||
|
|
|
||
|
|
if(!GetCch())
|
||
|
|
return NOERROR;
|
||
|
|
|
||
|
|
LONG cpMin, cpMost;
|
||
|
|
LONG cch = GetRange(cpMin, cpMost);
|
||
|
|
|
||
|
|
*pbstr = SysAllocStringLen(NULL, cch);
|
||
|
|
if(!*pbstr)
|
||
|
|
return E_OUTOFMEMORY;
|
||
|
|
|
||
|
|
CTxtPtr tp(_rpTX);
|
||
|
|
tp.SetCp(cpMin);
|
||
|
|
tp.GetText( cch, (TCHAR*) * pbstr );
|
||
|
|
return NOERROR;
|
||
|
|
}
|
||
|
|
|
||
|
|
/*
|
||
|
|
* CTxtRange::InRange (pRange, pB)
|
||
|
|
*
|
||
|
|
* @mfunc
|
||
|
|
* Returns *<p pB> = tomTrue iff this range points within or at the same
|
||
|
|
* text as <p pRange> does
|
||
|
|
*
|
||
|
|
* @rdesc
|
||
|
|
* HRESULT = (within range) ? NOERROR : S_FALSE
|
||
|
|
*/
|
||
|
|
STDMETHODIMP CTxtRange::InRange (
|
||
|
|
ITextRange * pRange, //@parm ITextRange to compare with
|
||
|
|
long * pB) //@parm Out parm for comparison result
|
||
|
|
{
|
||
|
|
TRACEBEGIN(TRCSUBSYSTOM, TRCSCOPEEXTERN, "CTxtRange::InRange");
|
||
|
|
|
||
|
|
return IsTrue(Comparer(pRange), pB);
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
/*
|
||
|
|
* CTxtRange::InStory (pRange, pB)
|
||
|
|
*
|
||
|
|
* @mfunc
|
||
|
|
* Return *pB = tomTrue iff this range's story is the same as
|
||
|
|
* <p pRange>'s
|
||
|
|
*
|
||
|
|
* @rdesc
|
||
|
|
* HRESULT = (in story) ? NOERROR : S_FALSE
|
||
|
|
*
|
||
|
|
* @future
|
||
|
|
* If RichEdit acquires the ability to have multiple stories and
|
||
|
|
* therefore ranges get a _story member, then compare that member
|
||
|
|
* instead of calling _rpTX.SameRuns().
|
||
|
|
*/
|
||
|
|
STDMETHODIMP CTxtRange::InStory (
|
||
|
|
ITextRange *pRange, //@parm ITextRange to query for private interface
|
||
|
|
long * pB) //@parm Out parm to receive tomBool result
|
||
|
|
{
|
||
|
|
#ifndef PEGASUS
|
||
|
|
TRACEBEGIN(TRCSUBSYSTOM, TRCSCOPEEXTERN, "CTxtRange::InStory");
|
||
|
|
|
||
|
|
return IsTrue(IsSameVtables(this, pRange) && // Same vtables,
|
||
|
|
_rpTX.SameRuns(&((CTxtRange *)pRange)->_rpTX), // same Runs
|
||
|
|
pB);
|
||
|
|
#else
|
||
|
|
return 0;
|
||
|
|
#endif
|
||
|
|
}
|
||
|
|
|
||
|
|
/*
|
||
|
|
* CTxtRange::IsEqual (pRange, pB)
|
||
|
|
*
|
||
|
|
* @mfunc
|
||
|
|
* Returns *<p pB> = tomTrue iff this range points at the same text (cp's
|
||
|
|
* and story) as <p pRange> does and pB isn't NULL.
|
||
|
|
*
|
||
|
|
* @rdesc
|
||
|
|
* HRESULT = (equal objects) ? NOERROR : S_FALSE
|
||
|
|
*/
|
||
|
|
STDMETHODIMP CTxtRange::IsEqual (
|
||
|
|
ITextRange * pRange, //@parm ITextRange to compare with
|
||
|
|
long * pB) //@parm Out parm for comparison result
|
||
|
|
{
|
||
|
|
TRACEBEGIN(TRCSUBSYSTOM, TRCSCOPEEXTERN, "CTxtRange::IsEqual");
|
||
|
|
|
||
|
|
return IsTrue(Comparer(pRange) < 0, pB);
|
||
|
|
}
|
||
|
|
|
||
|
|
/*
|
||
|
|
* CTxtRange::Move (Unit, Count, pDelta)
|
||
|
|
*
|
||
|
|
* @mfunc
|
||
|
|
* Move end(s) <p Count> <p Unit>'s, returning *<p pDelta> = # units
|
||
|
|
* actually moved. In general, this method converts a range into an
|
||
|
|
* insertion point if it isn't already, and moves the insertion point.
|
||
|
|
* If <p Count> <gt> 0, motion is forward toward the end of the story;
|
||
|
|
* if <p Count> <lt> 0, motion is backward toward the beginning.
|
||
|
|
* <p Count> = 0 moves cpFirst to the beginning of the <p Unit>
|
||
|
|
* containing cpFirst.
|
||
|
|
*
|
||
|
|
* @rdesc
|
||
|
|
* HRESULT = (if change) ? NOERROR :
|
||
|
|
* (if Unit supported) ? S_FALSE : E_NOTIMPL
|
||
|
|
* @devnote
|
||
|
|
* Argument validation of the three Move methods is done by the helper
|
||
|
|
* function CTxtRange::Mover(Unit, Count, pDelta, Mode)
|
||
|
|
*/
|
||
|
|
STDMETHODIMP CTxtRange::Move (
|
||
|
|
long Unit, //@parm Unit to use
|
||
|
|
long Count, //@parm Number of Units to move
|
||
|
|
long * pDelta) //@parm Out parm to receive actual count of
|
||
|
|
// Units end is moved
|
||
|
|
{
|
||
|
|
TRACEBEGIN(TRCSUBSYSTOM, TRCSCOPEEXTERN, "CTxtRange::Move");
|
||
|
|
CCallMgr callmgr(GetPed());
|
||
|
|
|
||
|
|
return Mover(Unit, Count, pDelta, MOVE_IP);
|
||
|
|
}
|
||
|
|
|
||
|
|
/*
|
||
|
|
* CTxtRange::MoveEnd (Unit, Count, pDelta)
|
||
|
|
*
|
||
|
|
* @mfunc
|
||
|
|
* Move End end <p Count> <p Unit>'s, returning *<p pDelta> = # units
|
||
|
|
* actually moved
|
||
|
|
*
|
||
|
|
* @rdesc
|
||
|
|
* HRESULT = (if change) ? NOERROR :
|
||
|
|
* (if Unit supported) ? S_FALSE : E_NOTIMPL
|
||
|
|
*/
|
||
|
|
STDMETHODIMP CTxtRange::MoveEnd (
|
||
|
|
long Unit, //@parm Unit to use
|
||
|
|
long Count, //@parm Number of Units to move
|
||
|
|
long * pDelta) //@parm Out parm to receive actual count of
|
||
|
|
// Units end is moved
|
||
|
|
{
|
||
|
|
TRACEBEGIN(TRCSUBSYSTOM, TRCSCOPEEXTERN, "CTxtRange::MoveEnd");
|
||
|
|
CCallMgr callmgr(GetPed());
|
||
|
|
|
||
|
|
return Mover(Unit, Count, pDelta, MOVE_END);
|
||
|
|
}
|
||
|
|
|
||
|
|
/*
|
||
|
|
* CTxtRange::MoveEndUntil (Cset, Count, pDelta)
|
||
|
|
*
|
||
|
|
* @mfunc
|
||
|
|
* Move the End just past all contiguous characters that are not found
|
||
|
|
* in the set of characters specified by the VARIANT <p Cset> parameter.
|
||
|
|
*
|
||
|
|
* @rdesc
|
||
|
|
* HRESULT = (if change) ? NOERROR :
|
||
|
|
* (if <p Cset> valid) ? S_FALSE : E_INVALIDARG
|
||
|
|
*/
|
||
|
|
STDMETHODIMP CTxtRange::MoveEndUntil (
|
||
|
|
VARIANT * Cset, //@parm Character match set to use
|
||
|
|
long Count, //@parm Max number of characters to move past
|
||
|
|
long * pDelta) //@parm Out parm to receive actual count of
|
||
|
|
// characters end is moved
|
||
|
|
{
|
||
|
|
TRACEBEGIN(TRCSUBSYSTOM, TRCSCOPEEXTERN, "CTxtRange::MoveEndUntil");
|
||
|
|
|
||
|
|
return Matcher(Cset, Count, pDelta, MOVE_END, MATCH_UNTIL);
|
||
|
|
}
|
||
|
|
|
||
|
|
/*
|
||
|
|
* CTxtRange::MoveEndWhile (Cset, Count, pDelta)
|
||
|
|
*
|
||
|
|
* @mfunc
|
||
|
|
* Move the End just past all contiguous characters that are found in
|
||
|
|
* the set of characters specified by the VARIANT <p Cset> parameter.
|
||
|
|
*
|
||
|
|
* @rdesc
|
||
|
|
* HRESULT = (if change) ? NOERROR :
|
||
|
|
* (if <p Cset> valid) ? S_FALSE : E_INVALIDARG
|
||
|
|
*/
|
||
|
|
STDMETHODIMP CTxtRange::MoveEndWhile (
|
||
|
|
VARIANT * Cset, //@parm Character match set to use
|
||
|
|
long Count, //@parm Max number of characters to move past
|
||
|
|
long * pDelta) //@parm Out parm to receive actual count of
|
||
|
|
// characters end is moved
|
||
|
|
{
|
||
|
|
TRACEBEGIN(TRCSUBSYSTOM, TRCSCOPEEXTERN, "CTxtRange::MoveEndWhile");
|
||
|
|
|
||
|
|
return Matcher(Cset, Count, pDelta, MOVE_END, MATCH_WHILE);
|
||
|
|
}
|
||
|
|
|
||
|
|
/*
|
||
|
|
* CTxtRange::MoveStart (Unit, Count, pDelta)
|
||
|
|
*
|
||
|
|
* @mfunc
|
||
|
|
* Move Start end <p Count> <p Unit>'s, returning *<p pDelta> = # units
|
||
|
|
* actually moved
|
||
|
|
*
|
||
|
|
* @rdesc
|
||
|
|
* HRESULT = (if change) ? NOERROR :
|
||
|
|
* (if Unit supported) ? S_FALSE : E_NOTIMPL
|
||
|
|
*/
|
||
|
|
STDMETHODIMP CTxtRange::MoveStart (
|
||
|
|
long Unit, //@parm Unit to use
|
||
|
|
long Count, //@parm Number of Units to move
|
||
|
|
long * pDelta) //@parm Out parm to receive actual count of
|
||
|
|
// Units end is moved
|
||
|
|
{
|
||
|
|
TRACEBEGIN(TRCSUBSYSTOM, TRCSCOPEEXTERN, "CTxtRange::MoveStart");
|
||
|
|
CCallMgr callmgr(GetPed());
|
||
|
|
|
||
|
|
return Mover(Unit, Count, pDelta, MOVE_START);
|
||
|
|
}
|
||
|
|
|
||
|
|
/*
|
||
|
|
* CTxtRange::MoveStartUntil (Cset, Count, pDelta)
|
||
|
|
*
|
||
|
|
* @mfunc
|
||
|
|
* Move the Start just past all contiguous characters that are not found
|
||
|
|
* in the set of characters specified by the VARIANT <p Cset> parameter.
|
||
|
|
*
|
||
|
|
* @rdesc
|
||
|
|
* HRESULT = (if change) ? NOERROR :
|
||
|
|
* (if <p Cset> valid) ? S_FALSE : E_INVALIDARG
|
||
|
|
*/
|
||
|
|
STDMETHODIMP CTxtRange::MoveStartUntil (
|
||
|
|
VARIANT * Cset, //@parm Character match set to use
|
||
|
|
long Count, //@parm Max number of characters to move past
|
||
|
|
long * pDelta) //@parm Out parm to receive actual count of
|
||
|
|
// characters end is moved
|
||
|
|
{
|
||
|
|
TRACEBEGIN(TRCSUBSYSTOM, TRCSCOPEEXTERN, "CTxtRange::MoveStartUntil");
|
||
|
|
|
||
|
|
return Matcher(Cset, Count, pDelta, MOVE_START, MATCH_UNTIL);
|
||
|
|
}
|
||
|
|
|
||
|
|
/*
|
||
|
|
* CTxtRange::MoveStartWhile (Cset, Count, pDelta)
|
||
|
|
*
|
||
|
|
* @mfunc
|
||
|
|
* Move the Start just past all contiguous characters that are found in
|
||
|
|
* the set of characters specified by the VARIANT <p Cset> parameter.
|
||
|
|
*
|
||
|
|
* @rdesc
|
||
|
|
* HRESULT = (if change) ? NOERROR :
|
||
|
|
* (if <p Cset> valid) ? S_FALSE : E_INVALIDARG
|
||
|
|
*/
|
||
|
|
STDMETHODIMP CTxtRange::MoveStartWhile (
|
||
|
|
VARIANT * Cset, //@parm Character match set to use
|
||
|
|
long Count, //@parm Max number of characters to move past
|
||
|
|
long * pDelta) //@parm Out parm to receive actual count of
|
||
|
|
// characters end is moved
|
||
|
|
{
|
||
|
|
TRACEBEGIN(TRCSUBSYSTOM, TRCSCOPEEXTERN, "CTxtRange::MoveStartWhile");
|
||
|
|
|
||
|
|
return Matcher(Cset, Count, pDelta, MOVE_START, MATCH_WHILE);
|
||
|
|
}
|
||
|
|
|
||
|
|
/*
|
||
|
|
* CTxtRange::MoveUntil (Cset,Count, pDelta)
|
||
|
|
*
|
||
|
|
* @mfunc
|
||
|
|
* Convert this range into an insertion point if it isn't already,
|
||
|
|
* and keep moving the insertion point until encountering any
|
||
|
|
* character in the set of characters specified by the VARIANT cset
|
||
|
|
* parameter.
|
||
|
|
*
|
||
|
|
* @rdesc
|
||
|
|
* HRESULT = (if change) ? NOERROR :
|
||
|
|
* (if <p Cset> valid) ? S_FALSE : E_INVALIDARG
|
||
|
|
*/
|
||
|
|
STDMETHODIMP CTxtRange::MoveUntil (
|
||
|
|
VARIANT * Cset, //@parm Character match set to use
|
||
|
|
long Count, //@parm Max number of characters to move past
|
||
|
|
long * pDelta) //@parm Out parm to receive actual count of
|
||
|
|
// characters end is moved
|
||
|
|
{
|
||
|
|
TRACEBEGIN(TRCSUBSYSTOM, TRCSCOPEEXTERN, "CTxtRange::MoveUntil");
|
||
|
|
|
||
|
|
return Matcher(Cset, Count, pDelta, MOVE_IP, MATCH_UNTIL);
|
||
|
|
}
|
||
|
|
|
||
|
|
/*
|
||
|
|
* CTxtRange::MoveWhile (Cset, Count, pDelta)
|
||
|
|
*
|
||
|
|
* @mfunc
|
||
|
|
* Convert this range into an insertion point if it isn't already,
|
||
|
|
* and keep moving the insertion point so long as (while) the
|
||
|
|
* characters past by are found in set of characters specified by
|
||
|
|
* the VARIANT cset parameter. Such a contiguous set of characters
|
||
|
|
* is known as a span of characters. The magnitude of the <p Count>
|
||
|
|
* parameter gives the maximum number of characters to move past and
|
||
|
|
* the sign of <p Count> specifies the direction to move in.
|
||
|
|
*
|
||
|
|
* @rdesc
|
||
|
|
* HRESULT = (if change) ? NOERROR :
|
||
|
|
* (if <p Cset> valid) ? S_FALSE : E_INVALIDARG
|
||
|
|
*
|
||
|
|
* @devnote
|
||
|
|
* Argument validation of the MoveWhile and MoveUntil methods is done by
|
||
|
|
* the helper CTxtRange::Matcher (Cset, Count, pDelta, fExtend, fSpan)
|
||
|
|
*/
|
||
|
|
STDMETHODIMP CTxtRange::MoveWhile (
|
||
|
|
VARIANT * Cset, //@parm Character match set to use
|
||
|
|
long Count, //@parm Max number of characters to move past
|
||
|
|
long * pDelta) //@parm Out parm to receive actual count of
|
||
|
|
// characters end is moved
|
||
|
|
{
|
||
|
|
TRACEBEGIN(TRCSUBSYSTOM, TRCSCOPEEXTERN, "CTxtRange::MoveWhile");
|
||
|
|
|
||
|
|
return Matcher(Cset, Count, pDelta, MOVE_IP, MATCH_WHILE);
|
||
|
|
}
|
||
|
|
|
||
|
|
/*
|
||
|
|
* CTxtRange::Paste (pVar, ClipboardFormat)
|
||
|
|
*
|
||
|
|
* @mfunc
|
||
|
|
* Paste the data object <p pVar> into this range. If
|
||
|
|
* <p pVar> is null, paste from the clipboard.
|
||
|
|
*
|
||
|
|
* @rdesc
|
||
|
|
* HRESULT = (WriteAccessDenied) ? E_ACCESSDENIED :
|
||
|
|
* (if success) ? NOERROR : E_OUTOFMEMORY
|
||
|
|
*/
|
||
|
|
STDMETHODIMP CTxtRange::Paste (
|
||
|
|
VARIANT *pVar, //@parm Data object to paste
|
||
|
|
long ClipboardFormat) //@parm Desired clipboard format
|
||
|
|
{
|
||
|
|
#ifndef PEGASUS
|
||
|
|
TRACEBEGIN(TRCSUBSYSTOM, TRCSCOPEEXTERN, "CTxtRange::Paste");
|
||
|
|
|
||
|
|
if(IsZombie())
|
||
|
|
return CO_E_RELEASED;
|
||
|
|
|
||
|
|
CCallMgr callmgr(GetPed());
|
||
|
|
HRESULT hr;
|
||
|
|
IDataObject * pdo = NULL; // Default clipboard
|
||
|
|
IUndoBuilder * publdr;
|
||
|
|
CGenUndoBuilder undobldr(GetPed(), UB_AUTOCOMMIT, &publdr);
|
||
|
|
|
||
|
|
if(WriteAccessDenied())
|
||
|
|
return E_ACCESSDENIED;
|
||
|
|
|
||
|
|
if(pVar)
|
||
|
|
if (pVar->vt == VT_UNKNOWN)
|
||
|
|
pVar->punkVal->QueryInterface(IID_IDataObject, (void **)&pdo);
|
||
|
|
else if (pVar->vt == (VT_UNKNOWN | VT_BYREF))
|
||
|
|
pdo = (IDataObject *)(*pVar->ppunkVal);
|
||
|
|
|
||
|
|
hr = GetPed()->PasteDataObjectToRange (pdo, this,
|
||
|
|
(WORD)ClipboardFormat, NULL, publdr, PDOR_NONE);
|
||
|
|
|
||
|
|
if(pdo && pVar->vt == VT_UNKNOWN)
|
||
|
|
pdo->Release();
|
||
|
|
Update(TRUE); // Update selection
|
||
|
|
return hr;
|
||
|
|
#else
|
||
|
|
return 0;
|
||
|
|
#endif
|
||
|
|
}
|
||
|
|
|
||
|
|
/*
|
||
|
|
* ITextRange::ScrollIntoView(long Code)
|
||
|
|
*
|
||
|
|
* @mfunc
|
||
|
|
* Method that scrolls this range into view according to the
|
||
|
|
* code Code defined below.
|
||
|
|
*
|
||
|
|
* @rdesc
|
||
|
|
* HRESULT = (if success) ? NOERROR : S_FALSE
|
||
|
|
*/
|
||
|
|
STDMETHODIMP CTxtRange::ScrollIntoView (
|
||
|
|
long Code) //@parm Scroll code
|
||
|
|
{
|
||
|
|
#ifndef PEGASUS
|
||
|
|
TRACEBEGIN(TRCSUBSYSTOM, TRCSCOPEEXTERN, "CTxtRange::ScrollIntoView");
|
||
|
|
|
||
|
|
// Check for invalid bits
|
||
|
|
if (Code & ~(tomStart + tomEnd + TA_LEFT + TA_TOP + TA_BOTTOM +
|
||
|
|
TA_CENTER + TA_STARTOFLINE + TA_ENDOFLINE + TA_LOGICAL))
|
||
|
|
return E_INVALIDARG;
|
||
|
|
|
||
|
|
// Validate parameter
|
||
|
|
long lCode = tomEnd;
|
||
|
|
if (Code & tomStart)
|
||
|
|
lCode = tomStart;
|
||
|
|
|
||
|
|
Code &= ~tomStart;
|
||
|
|
|
||
|
|
if(IsZombie())
|
||
|
|
return CO_E_RELEASED;
|
||
|
|
|
||
|
|
// Get local copy of ped to save some indirections.
|
||
|
|
CTxtEdit *ped = GetPed();
|
||
|
|
|
||
|
|
if (!ped->fInplaceActive())
|
||
|
|
{
|
||
|
|
// If the control is not active, we can't get the information
|
||
|
|
// because no one knows what our client rect is.
|
||
|
|
return E_FAIL;
|
||
|
|
}
|
||
|
|
|
||
|
|
// Get a local copy of display to save some indirections.
|
||
|
|
CDisplay *pdp = ped->_pdp;
|
||
|
|
|
||
|
|
if (pdp->IsFrozen())
|
||
|
|
{
|
||
|
|
return E_FAIL;
|
||
|
|
}
|
||
|
|
|
||
|
|
LONG cpStart;
|
||
|
|
LONG cpForEnd;
|
||
|
|
|
||
|
|
GetRange(cpStart, cpForEnd);
|
||
|
|
|
||
|
|
// Get the view rectangle so we can compute the absolute x/y
|
||
|
|
RECT rcView;
|
||
|
|
pdp->GetViewRect(rcView, NULL);
|
||
|
|
|
||
|
|
// Set up tp for PointFromTp call
|
||
|
|
CRchTxtPtr rtp(*this);
|
||
|
|
|
||
|
|
if(_cch > 0)
|
||
|
|
rtp.Advance(-_cch);
|
||
|
|
|
||
|
|
// Values used for making returned point locations absolute since
|
||
|
|
// PointFromTp adjusts the point returned to be relative to the
|
||
|
|
// display.
|
||
|
|
const LONG xScrollAdj = pdp->GetXScroll() - rcView.left;
|
||
|
|
const LONG yScrollAdj = pdp->GetYScroll() - rcView.top;
|
||
|
|
|
||
|
|
// Get the left/top for the start
|
||
|
|
BOOL taMask = Code & TA_STARTOFLINE; //set beginning of line flag
|
||
|
|
BOOL fAtEnd = _cch ? TRUE : !rtp._rpTX.IsAfterEOP();
|
||
|
|
POINT ptStart;
|
||
|
|
CLinePtr rpStart(pdp);
|
||
|
|
LONG iliStart = pdp->PointFromTp(rtp, NULL, _cch ? FALSE : fAtEnd,
|
||
|
|
ptStart, &rpStart, (lCode == tomStart && Code) ? Code :
|
||
|
|
TA_TOP + TA_LEFT);
|
||
|
|
ptStart.x += xScrollAdj;
|
||
|
|
ptStart.y += yScrollAdj;
|
||
|
|
|
||
|
|
// Get the right/bottom for the end
|
||
|
|
rtp.SetCp(cpForEnd);
|
||
|
|
|
||
|
|
POINT ptEnd;
|
||
|
|
CLinePtr rpEnd(pdp);
|
||
|
|
LONG iliEnd = pdp->PointFromTp(rtp, NULL, fAtEnd, ptEnd, &rpEnd,
|
||
|
|
(lCode == tomEnd && Code) ? Code :
|
||
|
|
TA_BOTTOM + TA_RIGHT);
|
||
|
|
ptEnd.x += xScrollAdj;
|
||
|
|
ptEnd.y += yScrollAdj;
|
||
|
|
|
||
|
|
//
|
||
|
|
// Calculate the yScroll
|
||
|
|
//
|
||
|
|
|
||
|
|
// The basic idea is to display both the start and the end if possible. But
|
||
|
|
// if it is not possible then display the requested end based on the input
|
||
|
|
// parameter.
|
||
|
|
|
||
|
|
LONG yHeightView = pdp->GetViewHeight();
|
||
|
|
LONG yScroll;
|
||
|
|
|
||
|
|
if (tomStart == lCode)
|
||
|
|
{
|
||
|
|
// Scroll the Start cp to the top of the view
|
||
|
|
yScroll = ptStart.y;
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
// Scroll the End cp to the bottom of the view
|
||
|
|
yScroll = ptEnd.y - yHeightView;
|
||
|
|
}
|
||
|
|
|
||
|
|
//
|
||
|
|
// Calculate the X Scroll
|
||
|
|
//
|
||
|
|
|
||
|
|
// Default scroll to beginning of the line
|
||
|
|
LONG xScroll = 0;
|
||
|
|
|
||
|
|
// Make view local to save a number of indirections
|
||
|
|
LONG xWidthView = pdp->GetViewWidth();
|
||
|
|
|
||
|
|
if (iliStart == iliEnd)
|
||
|
|
{
|
||
|
|
// Entire selection is on the same line so we want to display as
|
||
|
|
// much of it as is possible.
|
||
|
|
LONG xWidthSel = ptEnd.x - ptStart.x;
|
||
|
|
|
||
|
|
if (xWidthSel > xWidthView)
|
||
|
|
{
|
||
|
|
// Selection length is greater than display width
|
||
|
|
if (tomStart == lCode)
|
||
|
|
{
|
||
|
|
// Show Start requested - just start from beginning
|
||
|
|
// of selection
|
||
|
|
xScroll = ptStart.x;
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
// Show end requested - show as much of selection as
|
||
|
|
// possible, ending with last character in the
|
||
|
|
// selection.
|
||
|
|
xScroll = ptEnd.x - xWidthView;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
else if (xWidthSel < 0)
|
||
|
|
{
|
||
|
|
xWidthSel = -xWidthSel;
|
||
|
|
if (xWidthSel > xWidthView)
|
||
|
|
{
|
||
|
|
if (tomStart == lCode)
|
||
|
|
{
|
||
|
|
// Show Requested Start;
|
||
|
|
xScroll = max(0, ptStart.x - xWidthView);
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
xScroll = max(0, ptEnd.x - xWidthView);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
else if (ptEnd.x > xWidthView || ptStart.x > xWidthView)
|
||
|
|
{
|
||
|
|
// Check mask if position is outside the boundaries
|
||
|
|
if (taMask)
|
||
|
|
xScroll = ptStart.x - xWidthView;
|
||
|
|
else
|
||
|
|
xScroll = ptEnd.x - xWidthView;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
else if (ptEnd.x > xWidthView || ptStart.x > xWidthView)
|
||
|
|
{
|
||
|
|
// Check mask if position is outside the boundaries
|
||
|
|
if (taMask)
|
||
|
|
xScroll = ptStart.x - xWidthView;
|
||
|
|
else
|
||
|
|
xScroll = ptEnd.x - xWidthView;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
// Multiline selection. Display as much as possible of the requested
|
||
|
|
// end's line.
|
||
|
|
|
||
|
|
// Calc width of line
|
||
|
|
LONG xWidthLine = (tomStart == lCode)
|
||
|
|
? rpStart->_xWidth + rpStart->_xLeft
|
||
|
|
: rpEnd->_xWidth + rpEnd->_xLeft;
|
||
|
|
|
||
|
|
|
||
|
|
// If line width is less than or equal to view, start at
|
||
|
|
// 0 otherwise we need to adjust starting position to
|
||
|
|
// show as much of the requested end's selection line
|
||
|
|
// as possible.
|
||
|
|
if(xWidthLine > xWidthView)
|
||
|
|
{
|
||
|
|
if(tomStart == lCode)
|
||
|
|
{
|
||
|
|
// Start end to be displayed
|
||
|
|
|
||
|
|
if(xWidthLine - ptStart.x > xWidthView)
|
||
|
|
{
|
||
|
|
// Selection is bigger than view, so start at beginning
|
||
|
|
// and display as much as possible.
|
||
|
|
xScroll = ptStart.x;
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
// Remember that this is a multiline selection so the
|
||
|
|
// selection on this line goes from ptStart.x to the
|
||
|
|
// end of line. Since the selection width is less than
|
||
|
|
// the width of the view, we just back up the width
|
||
|
|
// of view to show the entire selection.
|
||
|
|
xScroll = xWidthLine - xWidthView;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
// Show the end of the selection. In the multiline case,
|
||
|
|
// this goes from the beginning of the line to End. So
|
||
|
|
// we only have to adjust if the End is beyond the view.
|
||
|
|
if(ptEnd.x > xWidthView)
|
||
|
|
{
|
||
|
|
// End beyond the view. Show as much as possible
|
||
|
|
// of the selection.
|
||
|
|
xScroll = ptEnd.x - xWidthView;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
// Do the scroll
|
||
|
|
pdp->ScrollView(xScroll, yScroll, FALSE, FALSE);
|
||
|
|
|
||
|
|
return S_OK;
|
||
|
|
#else
|
||
|
|
return 0;
|
||
|
|
#endif
|
||
|
|
}
|
||
|
|
|
||
|
|
/*
|
||
|
|
* CTxtRange::Select ()
|
||
|
|
*
|
||
|
|
* @mfunc
|
||
|
|
* Copy this range's cp's and story ptr to the active selection.
|
||
|
|
*
|
||
|
|
* @rdesc
|
||
|
|
* HRESULT = (if selection exists) ? NOERROR : S_FALSE
|
||
|
|
*/
|
||
|
|
STDMETHODIMP CTxtRange::Select ()
|
||
|
|
{
|
||
|
|
TRACEBEGIN(TRCSUBSYSTOM, TRCSCOPEEXTERN, "CTxtRange::Select");
|
||
|
|
|
||
|
|
if(IsZombie())
|
||
|
|
return CO_E_RELEASED;
|
||
|
|
|
||
|
|
CTxtSelection *pSel = GetPed()->GetSel();
|
||
|
|
if(pSel)
|
||
|
|
{
|
||
|
|
LONG cpMin, cpMost;
|
||
|
|
GetRange(cpMin, cpMost);
|
||
|
|
pSel->SetRange(cpMin, cpMost);
|
||
|
|
return NOERROR;
|
||
|
|
}
|
||
|
|
return S_FALSE;
|
||
|
|
}
|
||
|
|
|
||
|
|
/*
|
||
|
|
* CTxtRange::SetChar (Char)
|
||
|
|
*
|
||
|
|
* @mfunc
|
||
|
|
* Set char at cpFirst = <p Char>
|
||
|
|
*
|
||
|
|
* @rdesc
|
||
|
|
* HRESULT = (WriteAccessDenied) ? E_ACCESSDENIED :
|
||
|
|
* (char stored) ? NOERROR : S_FALSE
|
||
|
|
*
|
||
|
|
* @devnote
|
||
|
|
* Special cases could be much faster, e.g., just overtype the plain-
|
||
|
|
* text backing store unless at EOD or EOR. Code below uses a cloned
|
||
|
|
* range to handle all cases easily and preserve undo capability.
|
||
|
|
*/
|
||
|
|
STDMETHODIMP CTxtRange::SetChar (
|
||
|
|
long Char) //@parm New value for char at cpFirst
|
||
|
|
{
|
||
|
|
TRACEBEGIN(TRCSUBSYSTOM, TRCSCOPEEXTERN, "CTxtRange::SetChar");
|
||
|
|
|
||
|
|
if(IsZombie())
|
||
|
|
return CO_E_RELEASED;
|
||
|
|
|
||
|
|
CTxtEdit * ped = GetPed();
|
||
|
|
CCallMgr callmgr(ped);
|
||
|
|
TCHAR ch = (TCHAR)Char; // Avoid endian problems
|
||
|
|
CTxtRange rg(*this);
|
||
|
|
IUndoBuilder * publdr;
|
||
|
|
CGenUndoBuilder undobldr(ped, UB_AUTOCOMMIT, &publdr);
|
||
|
|
CFreezeDisplay fd(ped->_pdp);
|
||
|
|
|
||
|
|
if(WriteAccessDenied())
|
||
|
|
return E_ACCESSDENIED;
|
||
|
|
|
||
|
|
if(!ped->_pdp->IsMultiLine() && IsEOP(Char))// EOPs are not allowed in
|
||
|
|
return FALSE; // single-line edit controls
|
||
|
|
|
||
|
|
undobldr.StopGroupTyping();
|
||
|
|
|
||
|
|
rg.Collapser(tomStart); // Collapse at cpMin
|
||
|
|
rg.SetExtend(TRUE); // Setup to select
|
||
|
|
rg.Advance(1); // Try to select char at IP
|
||
|
|
ped->OrCharFlags(GetCharFlags(ch), publdr);
|
||
|
|
if(rg.ReplaceRange(1, &ch, publdr, SELRR_REMEMBERRANGE))
|
||
|
|
{
|
||
|
|
Update(TRUE); // Update selection
|
||
|
|
return NOERROR;
|
||
|
|
}
|
||
|
|
return S_FALSE;
|
||
|
|
}
|
||
|
|
|
||
|
|
/*
|
||
|
|
* CTxtRange::SetEnd (cp)
|
||
|
|
*
|
||
|
|
* @mfunc
|
||
|
|
* Set this range's End cp
|
||
|
|
*
|
||
|
|
* @rdesc
|
||
|
|
* HRESULT = (if change) ? NOERROR : S_FALSE
|
||
|
|
*
|
||
|
|
* @comm
|
||
|
|
* Note that setting this range's cpMost to <p cp> also sets cpMin to
|
||
|
|
* <p cp> if <p cp> < cpMin.
|
||
|
|
*/
|
||
|
|
STDMETHODIMP CTxtRange::SetEnd (
|
||
|
|
long cp) //@parm Desired new End cp
|
||
|
|
{
|
||
|
|
TRACEBEGIN(TRCSUBSYSTOM, TRCSCOPEEXTERN, "CTxtRange::SetEnd");
|
||
|
|
|
||
|
|
if(IsZombie())
|
||
|
|
return CO_E_RELEASED;
|
||
|
|
|
||
|
|
LONG cpMin = GetCpMin();
|
||
|
|
|
||
|
|
ValidateCp(cp);
|
||
|
|
return SetRange(min(cpMin, cp), cp); // Active end is End
|
||
|
|
}
|
||
|
|
|
||
|
|
/*
|
||
|
|
* CTxtRange::SetFont (pFont)
|
||
|
|
*
|
||
|
|
* @mfunc
|
||
|
|
* Set this range's character attributes to those given by <p pFont>.
|
||
|
|
* This method is a "character format painter".
|
||
|
|
*
|
||
|
|
* @rdesc
|
||
|
|
* HRESULT = (!pFont) ? E_INVALIDARG :
|
||
|
|
* (if success) ? NOERROR :
|
||
|
|
* (protected) ? E_ACCESSDENIED : E_OUTOFMEMORY
|
||
|
|
*/
|
||
|
|
STDMETHODIMP CTxtRange::SetFont (
|
||
|
|
ITextFont * pFont) //@parm Font object with desired character formatting
|
||
|
|
{
|
||
|
|
TRACEBEGIN(TRCSUBSYSTOM, TRCSCOPEEXTERN, "CTxtRange::SetFont");
|
||
|
|
|
||
|
|
if(!pFont)
|
||
|
|
return E_INVALIDARG;
|
||
|
|
|
||
|
|
if(IsZombie())
|
||
|
|
return CO_E_RELEASED;
|
||
|
|
|
||
|
|
ITextFont *pFontApply = (ITextFont *) new CTxtFont(this);
|
||
|
|
|
||
|
|
if(!pFontApply)
|
||
|
|
return E_OUTOFMEMORY;
|
||
|
|
|
||
|
|
HRESULT hr;
|
||
|
|
if(*(LONG *)pFontApply == *(LONG *)pFont) // If same vtable, use
|
||
|
|
hr = CharFormatSetter(&((CTxtFont *)pFont)->_CF, // its copy
|
||
|
|
((CTxtFont *)pFont)->_dwMask);
|
||
|
|
else // Else copy
|
||
|
|
hr = pFontApply->SetDuplicate(pFont); // to clone and apply
|
||
|
|
|
||
|
|
pFontApply->Release();
|
||
|
|
return hr;
|
||
|
|
}
|
||
|
|
|
||
|
|
/*
|
||
|
|
* CTxtRange::SetFormattedText (pRange)
|
||
|
|
*
|
||
|
|
* @mfunc
|
||
|
|
* Replace this range's text with formatted text given by <p pRange>.
|
||
|
|
* If <p pRange> is NULL, paste from the clipboard.
|
||
|
|
*
|
||
|
|
* @rdesc
|
||
|
|
* HRESULT = (WriteAccessDenied) ? E_ACCESSDENIED :
|
||
|
|
* (if success) ? NOERROR : E_OUTOFMEMORY
|
||
|
|
*
|
||
|
|
* @FUTURE
|
||
|
|
* Do this more efficiently if pRange points at a RichEdit range. This
|
||
|
|
* would also help with RichEdit D&D to RichEdit targets
|
||
|
|
*/
|
||
|
|
STDMETHODIMP CTxtRange::SetFormattedText (
|
||
|
|
ITextRange * pRange) //@parm Formatted text to replace this
|
||
|
|
// range's text
|
||
|
|
{
|
||
|
|
#ifndef PEGASUS
|
||
|
|
TRACEBEGIN(TRCSUBSYSTOM, TRCSCOPEEXTERN, "CTxtRange::SetFormattedText");
|
||
|
|
|
||
|
|
if(IsZombie())
|
||
|
|
return CO_E_RELEASED;
|
||
|
|
|
||
|
|
CCallMgr callmgr(GetPed());
|
||
|
|
LONG cpMin = GetCpMin();
|
||
|
|
HRESULT hr;
|
||
|
|
IUnknown * pdo = NULL;
|
||
|
|
VARIANT vr;
|
||
|
|
|
||
|
|
if(!pRange)
|
||
|
|
return NOERROR; // Nothing to paste
|
||
|
|
|
||
|
|
if(WriteAccessDenied())
|
||
|
|
return E_ACCESSDENIED;
|
||
|
|
|
||
|
|
VariantInit(&vr);
|
||
|
|
vr.vt = VT_UNKNOWN | VT_BYREF;
|
||
|
|
vr.ppunkVal = &pdo;
|
||
|
|
|
||
|
|
hr = pRange->Copy(&vr);
|
||
|
|
if(hr == NOERROR)
|
||
|
|
{
|
||
|
|
hr = Paste(&vr, 0);
|
||
|
|
pdo->Release(); // Release the data object
|
||
|
|
_cch = GetCp() - cpMin; // Select the new text
|
||
|
|
}
|
||
|
|
return hr;
|
||
|
|
#else
|
||
|
|
return 0;
|
||
|
|
#endif
|
||
|
|
}
|
||
|
|
|
||
|
|
/*
|
||
|
|
* CTxtRange::SetIndex (Unit, Index, Extend)
|
||
|
|
*
|
||
|
|
* @mfunc
|
||
|
|
* If <p Extend> is zero, convert this range into an insertion point
|
||
|
|
* at the start of the <p Index>th <p Unit> in the current story. If
|
||
|
|
* <p Extend> is nonzero, set this range to consist of this unit. The
|
||
|
|
* start of the story corresponds to <p Index> = 0 for all units.
|
||
|
|
*
|
||
|
|
* Positive indices are 1-based and index relative to the beginning of
|
||
|
|
* the story. Negative indices are -1-based and index relative to the
|
||
|
|
* end of the story. So an index of 1 refers to the first Unit in the
|
||
|
|
* story and an index of -1 refers to the last Unit in the story.
|
||
|
|
*
|
||
|
|
* @rdesc
|
||
|
|
* HRESULT = (invalid index) ? E_INVALIDARG :
|
||
|
|
* (Unit not supported) ? E_NOTIMPL :
|
||
|
|
* (change) ? NOERROR : S_FALSE
|
||
|
|
*
|
||
|
|
* @devnote
|
||
|
|
* Currently moves out <p Index> <p Unit>s from the start of the story.
|
||
|
|
* Might be faster to move from current position, but would need to know
|
||
|
|
* the current index.
|
||
|
|
*/
|
||
|
|
STDMETHODIMP CTxtRange::SetIndex (
|
||
|
|
long Unit, //@parm Unit to index
|
||
|
|
long Index, //@parm Index value to use
|
||
|
|
long Extend) //@parm if nonzero, set range to <p Unit>
|
||
|
|
{
|
||
|
|
TRACEBEGIN(TRCSUBSYSTOM, TRCSCOPEEXTERN, "CTxtRange::SetIndex");
|
||
|
|
|
||
|
|
if(IsZombie())
|
||
|
|
return CO_E_RELEASED;
|
||
|
|
|
||
|
|
if(!Index)
|
||
|
|
return E_INVALIDARG;
|
||
|
|
|
||
|
|
CCallMgr callmgr(GetPed());
|
||
|
|
|
||
|
|
LONG cchText = GetTextLength();
|
||
|
|
CTxtRange rg(GetPed()); // Create IP at cp = 0
|
||
|
|
|
||
|
|
if(Index > 0) // Index going forward First
|
||
|
|
Index--; // Unit is at start of story
|
||
|
|
else // Index from end of story
|
||
|
|
rg.Set(cchText, cchText); // selecting whole story
|
||
|
|
|
||
|
|
LONG cUnit;
|
||
|
|
HRESULT hr = rg.Mover(Unit, Index, &cUnit, MOVE_END);
|
||
|
|
if(FAILED(hr))
|
||
|
|
return hr;
|
||
|
|
|
||
|
|
if(Index != cUnit || rg.GetCp() == cchText) // No such index in story
|
||
|
|
return E_INVALIDARG;
|
||
|
|
|
||
|
|
rg._cch = 0; // Collapse at active end
|
||
|
|
// namely at cpMost
|
||
|
|
LONG cpMin, cpMost;
|
||
|
|
if(Extend) // Select Index'th Unit
|
||
|
|
rg.Expander(Unit, TRUE, NULL, &cpMin, &cpMost);
|
||
|
|
|
||
|
|
if(Set(rg.GetCp(), rg._cch)) // Something changed
|
||
|
|
{
|
||
|
|
Update(TRUE);
|
||
|
|
return NOERROR;
|
||
|
|
}
|
||
|
|
return S_FALSE;
|
||
|
|
}
|
||
|
|
|
||
|
|
/*
|
||
|
|
* CTxtRange::SetPara (pPara)
|
||
|
|
*
|
||
|
|
* @mfunc
|
||
|
|
* Set this range's paragraph attributes to those given by <p pPara>
|
||
|
|
* This method is a "Paragraph format painter".
|
||
|
|
*
|
||
|
|
* @rdesc
|
||
|
|
* HRESULT = (!pPara) ? E_INVALIDARG :
|
||
|
|
* (if success) ? NOERROR :
|
||
|
|
* (protected) ? E_ACCESSDENIED : E_OUTOFMEMORY
|
||
|
|
*/
|
||
|
|
STDMETHODIMP CTxtRange::SetPara (
|
||
|
|
ITextPara * pPara) //@parm Paragraph object with desired paragraph
|
||
|
|
{ // formatting
|
||
|
|
TRACEBEGIN(TRCSUBSYSTOM, TRCSCOPEEXTERN, "CTxtRange::SetPara");
|
||
|
|
|
||
|
|
if(!pPara)
|
||
|
|
return E_INVALIDARG;
|
||
|
|
|
||
|
|
if(IsZombie())
|
||
|
|
return CO_E_RELEASED;
|
||
|
|
|
||
|
|
ITextPara * pParaApply = (ITextPara *) new CTxtPara(this);
|
||
|
|
|
||
|
|
if(!pParaApply)
|
||
|
|
return E_OUTOFMEMORY;
|
||
|
|
|
||
|
|
HRESULT hr;
|
||
|
|
|
||
|
|
if(*(LONG *)pParaApply == *(LONG *)pPara) // If same vtable, use
|
||
|
|
{ // its _PF
|
||
|
|
hr = ParaFormatSetter(&((CTxtPara *)pPara)->_PF,
|
||
|
|
((CTxtPara *)pPara)->_dwMask);
|
||
|
|
}
|
||
|
|
else // Else copy
|
||
|
|
hr = pParaApply->SetDuplicate(pPara); // to clone and apply
|
||
|
|
|
||
|
|
pParaApply->Release();
|
||
|
|
return hr;
|
||
|
|
}
|
||
|
|
|
||
|
|
/*
|
||
|
|
* CTxtRange::SetPoint (x, y, Type, Extend)
|
||
|
|
*
|
||
|
|
* @mfunc
|
||
|
|
* Select text at or up through (depending on <p Extend>) the point
|
||
|
|
* (<p x>, <p y>).
|
||
|
|
*
|
||
|
|
* @rdesc
|
||
|
|
* HRESULT = NOERROR
|
||
|
|
*/
|
||
|
|
STDMETHODIMP CTxtRange::SetPoint (
|
||
|
|
long x, //@parm Horizontal coord of point to select
|
||
|
|
long y, //@parm Vertical coord of point to select
|
||
|
|
long Type, //@parm Defines the end to extend if Extend != 0.
|
||
|
|
long Extend) //@parm Whether to extend selection to point
|
||
|
|
{
|
||
|
|
TRACEBEGIN(TRCSUBSYSTOM, TRCSCOPEEXTERN, "CTxtRange::SetPoint");
|
||
|
|
|
||
|
|
if(IsZombie())
|
||
|
|
return CO_E_RELEASED;
|
||
|
|
|
||
|
|
// Copy the ped locally once to save some indirections
|
||
|
|
CTxtEdit *ped = GetPed();
|
||
|
|
CCallMgr callmgr(ped);
|
||
|
|
|
||
|
|
if(Type != tomStart && Type != tomEnd)
|
||
|
|
return E_INVALIDARG;
|
||
|
|
|
||
|
|
if(!ped->fInplaceActive())
|
||
|
|
{
|
||
|
|
// If we aren't inplace active we can't get a DC to
|
||
|
|
// calculate the cp.
|
||
|
|
return OLE_E_NOT_INPLACEACTIVE;
|
||
|
|
}
|
||
|
|
|
||
|
|
// Convert (x, y) from screen coordinates to client coordinates
|
||
|
|
POINT pt = {x, y};
|
||
|
|
// Caller specifies screen coordinates?
|
||
|
|
if ( !(Type & tomClientCoord) )
|
||
|
|
if(!ped->TxScreenToClient(&pt))
|
||
|
|
return E_FAIL; // It is unexpected for this to happen
|
||
|
|
|
||
|
|
// Get cp for (x, y)
|
||
|
|
LONG cpSel = ped->_pdp->CpFromPoint(pt, NULL, NULL, NULL, TRUE);
|
||
|
|
if(cpSel == -1)
|
||
|
|
return E_FAIL; // It is highly unexpected for this to fail
|
||
|
|
|
||
|
|
// Extend range as requested
|
||
|
|
LONG cchForSel = 0;
|
||
|
|
if(Extend)
|
||
|
|
{
|
||
|
|
LONG cpMin, cpMost;
|
||
|
|
GetRange(cpMin, cpMost);
|
||
|
|
if(Type == tomStart)
|
||
|
|
cchForSel = cpSel - cpMin;
|
||
|
|
else
|
||
|
|
cchForSel = cpSel - cpMost;
|
||
|
|
}
|
||
|
|
|
||
|
|
// Update range
|
||
|
|
Set(cpSel, cchForSel);
|
||
|
|
return S_OK;
|
||
|
|
}
|
||
|
|
|
||
|
|
/*
|
||
|
|
* CTxtRange::SetRange (cp1, cp2)
|
||
|
|
*
|
||
|
|
* @mfunc
|
||
|
|
* Set this range's ends
|
||
|
|
*
|
||
|
|
* @rdesc
|
||
|
|
* HRESULT = (cp1 > cp2) ? E_INVALIDARG
|
||
|
|
* : (if change) ? NOERROR : S_FALSE
|
||
|
|
*/
|
||
|
|
STDMETHODIMP CTxtRange::SetRange (
|
||
|
|
long cp1, //@parm Char position for Start end
|
||
|
|
long cp2) //@parm Char position for End end
|
||
|
|
{
|
||
|
|
TRACEBEGIN(TRCSUBSYSTOM, TRCSCOPEEXTERN, "CTxtRange::SetRange");
|
||
|
|
|
||
|
|
if(IsZombie())
|
||
|
|
return CO_E_RELEASED;
|
||
|
|
|
||
|
|
CCallMgr callmgr(GetPed());
|
||
|
|
LONG cpMin, cpMost; // Save starting cp's for
|
||
|
|
// change determination
|
||
|
|
GetRange(cpMin, cpMost);
|
||
|
|
ValidateCp(cp1);
|
||
|
|
ValidateCp(cp2);
|
||
|
|
|
||
|
|
Set(cp2, cp2 - cp1);
|
||
|
|
GetRange(cp1, cp2); // See if either range end changed
|
||
|
|
if(cp1 != cpMin || cp2 != cpMost) // (independent of active end)
|
||
|
|
{
|
||
|
|
Update(TRUE); // Update selection
|
||
|
|
return NOERROR;
|
||
|
|
}
|
||
|
|
return S_FALSE;
|
||
|
|
}
|
||
|
|
|
||
|
|
/*
|
||
|
|
* CTxtRange::SetStart (cp)
|
||
|
|
*
|
||
|
|
* @mfunc
|
||
|
|
* Set this range's Start cp
|
||
|
|
*
|
||
|
|
* @rdesc
|
||
|
|
* HRESULT = (if change) ? NOERROR : S_FALSE
|
||
|
|
*
|
||
|
|
* @comm
|
||
|
|
* Note that setting this range's cpMin to <p cp> also sets cpMost to
|
||
|
|
* <p cp> if <p cp> > cpMost.
|
||
|
|
*/
|
||
|
|
STDMETHODIMP CTxtRange::SetStart (
|
||
|
|
long cp) //@parm Desired new Start cp
|
||
|
|
{
|
||
|
|
TRACEBEGIN(TRCSUBSYSTOM, TRCSCOPEEXTERN, "CTxtRange::SetStart");
|
||
|
|
|
||
|
|
if(IsZombie())
|
||
|
|
return CO_E_RELEASED;
|
||
|
|
|
||
|
|
LONG cpMost = GetCpMost();
|
||
|
|
|
||
|
|
ValidateCp(cp);
|
||
|
|
return SetRange(max(cpMost, cp), cp); // Active end is Start
|
||
|
|
}
|
||
|
|
|
||
|
|
/*
|
||
|
|
* CTxtRange::SetText (bstr)
|
||
|
|
*
|
||
|
|
* @mfunc
|
||
|
|
* Replace text in this range by that given by <p bstr>. If <p bstr>
|
||
|
|
* is NULL, delete text in range.
|
||
|
|
*
|
||
|
|
* @rdesc
|
||
|
|
* HRESULT = (WriteAccessDenied) ? E_ACCESSDENIED :
|
||
|
|
* (if success) ? NOERROR : S_FALSE
|
||
|
|
*/
|
||
|
|
STDMETHODIMP CTxtRange::SetText (
|
||
|
|
BSTR bstr) //@parm Text to replace text in this range by
|
||
|
|
{
|
||
|
|
TRACEBEGIN(TRCSUBSYSTOM, TRCSCOPEEXTERN, "CTxtRange::SetText");
|
||
|
|
|
||
|
|
if(IsZombie())
|
||
|
|
return CO_E_RELEASED;
|
||
|
|
|
||
|
|
CCallMgr callmgr(GetPed());
|
||
|
|
|
||
|
|
if(WriteAccessDenied())
|
||
|
|
return E_ACCESSDENIED;
|
||
|
|
|
||
|
|
LONG cchNew = bstr ? SysStringLen(bstr) : 0;
|
||
|
|
_cch = Replacer(cchNew, (TCHAR *)bstr, RR_ITMZ_UNICODEBIDI); // Select the new text
|
||
|
|
|
||
|
|
_TEST_INVARIANT_
|
||
|
|
|
||
|
|
GetPed()->TxSetMaxToMaxText();
|
||
|
|
|
||
|
|
return _cch == cchNew ? NOERROR : S_FALSE;
|
||
|
|
}
|
||
|
|
|
||
|
|
/*
|
||
|
|
* CTxtRange::StartOf (Unit, Extend, pDelta)
|
||
|
|
*
|
||
|
|
* @mfunc
|
||
|
|
* Move this range end(s) to start of the first overlapping Unit in
|
||
|
|
* the range.
|
||
|
|
*
|
||
|
|
* @rdesc
|
||
|
|
* HRESULT = (if change) ? NOERROR :
|
||
|
|
* (if <p Unit> valid) ? S_FALSE : E_INVALIDARG
|
||
|
|
*/
|
||
|
|
STDMETHODIMP CTxtRange::StartOf (
|
||
|
|
long Unit, //@parm Unit to use
|
||
|
|
long Extend, //@parm If true, leave other end alone
|
||
|
|
long * pDelta) //@parm Out parm to get count of chars that
|
||
|
|
// StartOf moved
|
||
|
|
{
|
||
|
|
TRACEBEGIN(TRCSUBSYSTOM, TRCSCOPEEXTERN, "CTxtRange::StartOf");
|
||
|
|
|
||
|
|
CCallMgr callmgr(GetPed());
|
||
|
|
LONG cpMin;
|
||
|
|
HRESULT hr = Expander (Unit, Extend, pDelta, &cpMin, NULL);
|
||
|
|
|
||
|
|
if(hr == NOERROR)
|
||
|
|
Update(TRUE); // Update selection
|
||
|
|
|
||
|
|
return hr;
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
//---------------------- CTxtRange ITextSelection stubs -----------------------------
|
||
|
|
|
||
|
|
// Dummy CTxtRange routines to simplify CTxtSelection inheritance hierarchy
|
||
|
|
|
||
|
|
STDMETHODIMP CTxtRange::GetFlags (long * pFlags)
|
||
|
|
{
|
||
|
|
TRACEBEGIN(TRCSUBSYSTOM, TRCSCOPEEXTERN, "CTxtRange::GetFlags");
|
||
|
|
return E_NOTIMPL;
|
||
|
|
}
|
||
|
|
|
||
|
|
STDMETHODIMP CTxtRange::SetFlags (long Flags)
|
||
|
|
{
|
||
|
|
TRACEBEGIN(TRCSUBSYSTOM, TRCSCOPEEXTERN, "CTxtRange::SetFlags");
|
||
|
|
return E_NOTIMPL;
|
||
|
|
}
|
||
|
|
|
||
|
|
STDMETHODIMP CTxtRange::GetType (long * pType)
|
||
|
|
{
|
||
|
|
TRACEBEGIN(TRCSUBSYSTOM, TRCSCOPEEXTERN, "CTxtRange::GetType");
|
||
|
|
return E_NOTIMPL;
|
||
|
|
}
|
||
|
|
|
||
|
|
STDMETHODIMP CTxtRange::MoveLeft (long Unit, long Count, long Extend, long * pDelta)
|
||
|
|
{
|
||
|
|
TRACEBEGIN(TRCSUBSYSTOM, TRCSCOPEEXTERN, "CTxtRange::Left");
|
||
|
|
return E_NOTIMPL;
|
||
|
|
}
|
||
|
|
|
||
|
|
STDMETHODIMP CTxtRange::MoveRight (long Unit, long Count, long Extend, long * pDelta)
|
||
|
|
{
|
||
|
|
TRACEBEGIN(TRCSUBSYSTOM, TRCSCOPEEXTERN, "CTxtRange::Right");
|
||
|
|
return E_NOTIMPL;
|
||
|
|
}
|
||
|
|
|
||
|
|
STDMETHODIMP CTxtRange::MoveUp (long Unit, long Count, long Extend, long * pDelta)
|
||
|
|
{
|
||
|
|
TRACEBEGIN(TRCSUBSYSTOM, TRCSCOPEEXTERN, "CTxtRange::Up");
|
||
|
|
return E_NOTIMPL;
|
||
|
|
}
|
||
|
|
|
||
|
|
STDMETHODIMP CTxtRange::MoveDown (long Unit, long Count, long Extend, long * pDelta)
|
||
|
|
{
|
||
|
|
TRACEBEGIN(TRCSUBSYSTOM, TRCSCOPEEXTERN, "CTxtRange::Down");
|
||
|
|
return E_NOTIMPL;
|
||
|
|
}
|
||
|
|
|
||
|
|
STDMETHODIMP CTxtRange::HomeKey (long Unit, long Extend, long * pDelta)
|
||
|
|
{
|
||
|
|
TRACEBEGIN(TRCSUBSYSTOM, TRCSCOPEEXTERN, "CTxtRange::HomeKey");
|
||
|
|
return E_NOTIMPL;
|
||
|
|
}
|
||
|
|
|
||
|
|
STDMETHODIMP CTxtRange::EndKey (long Unit, long Extend, long * pDelta)
|
||
|
|
{
|
||
|
|
TRACEBEGIN(TRCSUBSYSTOM, TRCSCOPEEXTERN, "CTxtRange::EndKey");
|
||
|
|
return E_NOTIMPL;
|
||
|
|
}
|
||
|
|
|
||
|
|
STDMETHODIMP CTxtRange::TypeText (BSTR bstr)
|
||
|
|
{
|
||
|
|
TRACEBEGIN(TRCSUBSYSTOM, TRCSCOPEEXTERN, "CTxtRange::TypeText");
|
||
|
|
return E_NOTIMPL;
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
//--------------------- ITextRange Private Helper Methods -----------------------------
|
||
|
|
|
||
|
|
/*
|
||
|
|
* @doc INTERNAL
|
||
|
|
*
|
||
|
|
* CTxtRange::Collapser (bStart)
|
||
|
|
*
|
||
|
|
* @mfunc
|
||
|
|
* Internal routine to collapse this range into a degenerate point
|
||
|
|
* either at the the start (<p bStart> is nonzero or the end
|
||
|
|
* (<p bStart> = 0)
|
||
|
|
*/
|
||
|
|
void CTxtRange::Collapser (
|
||
|
|
long bStart) //@parm Flag specifying end to collapse at
|
||
|
|
{
|
||
|
|
TRACEBEGIN(TRCSUBSYSRANG, TRCSCOPEEXTERN, "CTxtRange::Collapser");
|
||
|
|
|
||
|
|
if(bStart) // Collapse to Start
|
||
|
|
{
|
||
|
|
if(_cch > 0)
|
||
|
|
FlipRange(); // Move active end to range Start
|
||
|
|
}
|
||
|
|
else // Collapse to End
|
||
|
|
{
|
||
|
|
if(_cch < 0)
|
||
|
|
FlipRange(); // Move active end to range End
|
||
|
|
|
||
|
|
const LONG cchText = GetAdjustedTextLength();
|
||
|
|
|
||
|
|
if(GetCp() > cchText) // IP can't follow final CR
|
||
|
|
Set(cchText, 0); // so move it before
|
||
|
|
}
|
||
|
|
if(_cch)
|
||
|
|
_fMoveBack = bStart != 0;
|
||
|
|
_cch = 0; // Collapse this range
|
||
|
|
_fSelHasEOP = FALSE; // Insertion points don't have
|
||
|
|
_fSelHasCell = FALSE; // EOPs or Cells
|
||
|
|
|
||
|
|
if(_fSel) // Notify if selection changed
|
||
|
|
GetPed()->GetCallMgr()->SetSelectionChanged();
|
||
|
|
|
||
|
|
Update_iFormat(-1); // Make sure format is up to date
|
||
|
|
}
|
||
|
|
|
||
|
|
/*
|
||
|
|
* CTxtRange::Comparer(pRange)
|
||
|
|
*
|
||
|
|
* @mfunc
|
||
|
|
* helper function for CTxtRange::InRange() and IsEqual()
|
||
|
|
*
|
||
|
|
* @rdesc
|
||
|
|
* 0 if not same story or if this range isn't contained by <p pRange>;
|
||
|
|
* -1 if ranges are equal; 1 if this range wholely contained in
|
||
|
|
* <p pRange>.
|
||
|
|
*
|
||
|
|
* @comm
|
||
|
|
* Note that if this range is degenerate and *pRange is nondegenerate,
|
||
|
|
* this range is not included in *pRange if it's located at pRange's
|
||
|
|
* End position.
|
||
|
|
*/
|
||
|
|
LONG CTxtRange::Comparer (
|
||
|
|
ITextRange * pRange) //@parm ITextRange to compare with
|
||
|
|
{
|
||
|
|
TRACEBEGIN(TRCSUBSYSTOM, TRCSCOPEINTERN, "CTxtRange::Comparer");
|
||
|
|
|
||
|
|
LONG cpMin, cpMost;
|
||
|
|
LONG Start, End;
|
||
|
|
|
||
|
|
if(InStory(pRange, NULL) != NOERROR) // If this range doesn't point at
|
||
|
|
return 0; // same story as pRange's,
|
||
|
|
// return 0
|
||
|
|
GetRange(cpMin, cpMost); // Get this range's cp's
|
||
|
|
pRange->GetStart(&Start); // Get pRange's cp's
|
||
|
|
pRange->GetEnd(&End);
|
||
|
|
if(cpMin == Start && cpMost == End) // Exact match
|
||
|
|
return -1;
|
||
|
|
return cpMin >= Start && cpMost <= End && cpMin < End;
|
||
|
|
}
|
||
|
|
|
||
|
|
/*
|
||
|
|
* CTxtRange::Expander (Unit, fExtend, pDelta, pcpMin, pcpMost)
|
||
|
|
*
|
||
|
|
* @mfunc
|
||
|
|
* Helper function that expands this range so that partial Units it
|
||
|
|
* contains are completely contained according to the out parameters
|
||
|
|
* pcpMin and pcpMost. If pcpMin is not NULL, the range is expanded to
|
||
|
|
* the beginning of the Unit. Similarly, if pcpMost is not NULL, the
|
||
|
|
* range is expanded to the end of the Unit. <p pDelta> is an out
|
||
|
|
* parameter that receives the number of chars added to the range.
|
||
|
|
*
|
||
|
|
* @rdesc
|
||
|
|
* HRESULT = (if change) ? NOERROR :
|
||
|
|
* (if Unit valid) ? S_FALSE : E_INVALIDARG
|
||
|
|
*
|
||
|
|
* @devnote
|
||
|
|
* Used by ITextRange::Expand(), StartOf(), and EndOf(). Both pcpMin and
|
||
|
|
* pcpMost are nonNULL for Expand(). pcpMin is NULL for EndOf() and
|
||
|
|
* pcpMost is NULL for StartOf().
|
||
|
|
*
|
||
|
|
* @future
|
||
|
|
* Discontiguous Units. Expander should expand only to end of Unit,
|
||
|
|
* rather than to start of next Unit.
|
||
|
|
*/
|
||
|
|
HRESULT CTxtRange::Expander (
|
||
|
|
long Unit, //@parm Unit to expand range to
|
||
|
|
BOOL fExtend, //@parm Expand this range if TRUE
|
||
|
|
LONG * pDelta, //@parm Out parm that receives chars added
|
||
|
|
LONG * pcpMin, //@parm Out parm that receives new cpMin
|
||
|
|
LONG * pcpMost) //@parm Out parm that receives new cpMost
|
||
|
|
{
|
||
|
|
TRACEBEGIN(TRCSUBSYSTOM, TRCSCOPEINTERN, "CTxtRange::Expander");
|
||
|
|
|
||
|
|
if(IsZombie())
|
||
|
|
return CO_E_RELEASED;
|
||
|
|
|
||
|
|
LONG cch = 0; // Default no chars added
|
||
|
|
LONG cchRange;
|
||
|
|
LONG cchAdjustedText = GetAdjustedTextLength();
|
||
|
|
LONG cchText = GetTextLength();
|
||
|
|
LONG cp;
|
||
|
|
LONG cpMin, cpMost;
|
||
|
|
BOOL fUnitFound = TRUE; // Most Units can be found
|
||
|
|
LONG cchCollapse;
|
||
|
|
CDisplay *pdp; // but tomObject maybe not
|
||
|
|
|
||
|
|
GetRange(cpMin, cpMost); // Save starting cp's
|
||
|
|
if(pcpMin) // Default no change
|
||
|
|
{
|
||
|
|
*pcpMin = cpMin;
|
||
|
|
AssertSz(!pcpMost || fExtend,
|
||
|
|
"CTxtRange::Expander should extend if both pcpMin and pcpMost != 0");
|
||
|
|
}
|
||
|
|
if(pcpMost)
|
||
|
|
*pcpMost = cpMost;
|
||
|
|
if(pDelta)
|
||
|
|
*pDelta = 0;
|
||
|
|
|
||
|
|
if(Unit < 0)
|
||
|
|
{
|
||
|
|
// Valid attribute Units are high bit plus any combo of CFE_xxx.
|
||
|
|
// CFE_REVISED is most significant value currently defined.
|
||
|
|
if(Unit & ~(2*CFM_REVISED - 1 + 0x80000000))
|
||
|
|
return E_NOTIMPL;
|
||
|
|
FindAttributes(pcpMin, pcpMost, Unit);
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
switch(Unit) // Calculate new cp's
|
||
|
|
{
|
||
|
|
case tomObject:
|
||
|
|
fUnitFound = FindObject(pcpMin, pcpMost);
|
||
|
|
break;
|
||
|
|
|
||
|
|
case tomCharacter:
|
||
|
|
if (pcpMost && cpMin == cpMost &&// EndOf/Expand insertion point
|
||
|
|
cpMost < cchText && // with at least 1 more char
|
||
|
|
(!cpMost || pcpMin)) // at beginning of story or
|
||
|
|
{ // Expand(), then
|
||
|
|
(*pcpMost)++; // expand by one char
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
|
||
|
|
case tomCharFormat:
|
||
|
|
_rpCF.FindRun (pcpMin, pcpMost, cpMin, _cch, cchText);
|
||
|
|
break;
|
||
|
|
|
||
|
|
case tomParaFormat:
|
||
|
|
_rpPF.FindRun (pcpMin, pcpMost, cpMin, _cch, cchText);
|
||
|
|
break;
|
||
|
|
|
||
|
|
case tomWord:
|
||
|
|
FindWord (pcpMin, pcpMost, FW_INCLUDE_TRAILING_WHITESPACE);
|
||
|
|
break;
|
||
|
|
|
||
|
|
case tomSentence:
|
||
|
|
FindSentence (pcpMin, pcpMost);
|
||
|
|
break;
|
||
|
|
|
||
|
|
case tomCell:
|
||
|
|
FindCell (pcpMin, pcpMost);
|
||
|
|
break;
|
||
|
|
|
||
|
|
case tomRow:
|
||
|
|
_rpPF.AdjustForward();
|
||
|
|
if(InTable()) // In our simple table model,
|
||
|
|
goto para; // each row is a single para
|
||
|
|
break;
|
||
|
|
|
||
|
|
case tomLine:
|
||
|
|
pdp = GetPed()->_pdp;
|
||
|
|
if(pdp) // If this story has a display
|
||
|
|
{ // use line array
|
||
|
|
CLinePtr rp(pdp);
|
||
|
|
cp = GetCp();
|
||
|
|
pdp->WaitForRecalc(cp, -1);
|
||
|
|
rp.RpSetCp(cp, FALSE);
|
||
|
|
rp.FindRun (pcpMin, pcpMost, cpMin, _cch, cchText);
|
||
|
|
break;
|
||
|
|
} // Else fall thru to tomPara
|
||
|
|
|
||
|
|
case tomParagraph:
|
||
|
|
para: FindParagraph(pcpMin, pcpMost);
|
||
|
|
break;
|
||
|
|
|
||
|
|
case tomWindow:
|
||
|
|
fUnitFound = FindVisibleRange(pcpMin, pcpMost);
|
||
|
|
break;
|
||
|
|
|
||
|
|
case tomStory:
|
||
|
|
if(pcpMin)
|
||
|
|
*pcpMin = 0;
|
||
|
|
if(pcpMost)
|
||
|
|
*pcpMost = cchText;
|
||
|
|
break;
|
||
|
|
|
||
|
|
default:
|
||
|
|
return E_NOTIMPL;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
if(!fUnitFound)
|
||
|
|
return S_FALSE;
|
||
|
|
|
||
|
|
cchCollapse = !fExtend && _cch; // Collapse counts as a char
|
||
|
|
// Note: Expand() has fExtend = 0
|
||
|
|
if(pcpMin)
|
||
|
|
{
|
||
|
|
cch = cpMin - *pcpMin; // Default positive cch for Expand
|
||
|
|
cpMin = *pcpMin;
|
||
|
|
}
|
||
|
|
|
||
|
|
if(pcpMost) // EndOf() and Expand()
|
||
|
|
{
|
||
|
|
if(!fExtend) // Will be IP if not already
|
||
|
|
{
|
||
|
|
if(cpMost > cchAdjustedText) // If we collapse (EndOf only),
|
||
|
|
cchCollapse = -cchCollapse; // it'll be before the final CR
|
||
|
|
else
|
||
|
|
*pcpMost = min(*pcpMost, cchAdjustedText);
|
||
|
|
}
|
||
|
|
cch += *pcpMost - cpMost;
|
||
|
|
cp = cpMost = *pcpMost;
|
||
|
|
}
|
||
|
|
else // StartOf()
|
||
|
|
{
|
||
|
|
cch = -cch; // Invert count
|
||
|
|
cp = cpMin; // Active end at cpMin
|
||
|
|
cchCollapse = -cchCollapse; // Backward collapses count as -1
|
||
|
|
}
|
||
|
|
|
||
|
|
cch += cchCollapse; // Collapse counts as a char
|
||
|
|
if(cch) // One or both ends changed
|
||
|
|
{
|
||
|
|
cchRange = cpMost - cpMin; // cch for EndOf() and Expand()
|
||
|
|
if(!pcpMost) // Make negative for StartOf()
|
||
|
|
cchRange = -cchRange;
|
||
|
|
if(!fExtend) // We're not expanding (EndOf()
|
||
|
|
cchRange = 0; // or StartOf() call)
|
||
|
|
if(Set(cp, cchRange)) // Set active end and signed cch
|
||
|
|
{ // Something changed
|
||
|
|
if(pDelta) // Report cch if caller cares
|
||
|
|
*pDelta = cch;
|
||
|
|
return NOERROR;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
return S_FALSE; // Report Unit found but no change
|
||
|
|
}
|
||
|
|
|
||
|
|
/*
|
||
|
|
* CTxtRange::Finder (bstr, Count, dwFlags, pDelta, Mode)
|
||
|
|
*
|
||
|
|
* @mfunc
|
||
|
|
* Helper find function that moves active end up to <p cch> characters
|
||
|
|
* subject to compare flags <p Flags> and the <p Mode>, which has the
|
||
|
|
* following possible values:
|
||
|
|
*
|
||
|
|
* 1: set this range's cpMost = cpMost of matched string
|
||
|
|
* 0: set this range's cp's equal to those of matched string
|
||
|
|
* -1: set this range's cpMin = cpMin of matched string
|
||
|
|
*
|
||
|
|
* Return *<p pDelta> = # characters past.
|
||
|
|
*
|
||
|
|
* @rdesc
|
||
|
|
* HRESULT = (if <p bstr> found) ? NOERROR : S_FALSE
|
||
|
|
*
|
||
|
|
* @devnote
|
||
|
|
* Used by ITextRange::FindText(), FindTextStart() and FindTextEnd()
|
||
|
|
*/
|
||
|
|
HRESULT CTxtRange::Finder (
|
||
|
|
BSTR bstr, //@parm String to find
|
||
|
|
long Count, //@parm Max count of chars to search
|
||
|
|
long Flags, //@parm Flags governing compares
|
||
|
|
LONG * pDelta, //@parm Out parm to receive count of chars moved
|
||
|
|
MOVES Mode) //@parm Governs setting of range wrt matched string
|
||
|
|
{
|
||
|
|
TRACEBEGIN(TRCSUBSYSTOM, TRCSCOPEINTERN, "CTxtRange::Finder");
|
||
|
|
|
||
|
|
if(!bstr)
|
||
|
|
return S_FALSE;
|
||
|
|
|
||
|
|
if(IsZombie())
|
||
|
|
return CO_E_RELEASED;
|
||
|
|
|
||
|
|
CCallMgr callmgr(GetPed());
|
||
|
|
|
||
|
|
LONG cpMin, cpMost;
|
||
|
|
LONG cch = GetRange(cpMin, cpMost); // Get this range's cp's
|
||
|
|
LONG cchBstr = SysStringLen(bstr);
|
||
|
|
LONG cchSave = _cch;
|
||
|
|
LONG cp, cpMatch, cpSave;
|
||
|
|
LONG cpStart = cpMost; // Default Start cp to range
|
||
|
|
CRchTxtPtr rtp(*this); // End
|
||
|
|
|
||
|
|
if(Mode == MOVE_IP) // FindText(): Count = 0 is
|
||
|
|
{ // treated specially: if IP,
|
||
|
|
if(!Count) // compare string at IP; else
|
||
|
|
Count = cch ? cch : cchBstr; // confine search to range
|
||
|
|
if(Count > 0) // Forward searches start from
|
||
|
|
cpStart = cpMin; // beginning of range
|
||
|
|
}
|
||
|
|
else // FindTextStart() or
|
||
|
|
{ // FindTextEnd()
|
||
|
|
if(!Count) // Compare string at IP; else
|
||
|
|
Count = cch ? -Mode*cch : cchBstr; // confine search to range
|
||
|
|
if(Mode < 0) // Find from Start
|
||
|
|
cpStart = cpMin;
|
||
|
|
}
|
||
|
|
|
||
|
|
cpSave = cpStart; // Save starting cp
|
||
|
|
cp = cpStart + Count; // cp = limiting cp. Can be on
|
||
|
|
cp = max(cp, 0); // either side of cpStart
|
||
|
|
Flags &= ~FR_DOWN; // Default search backward
|
||
|
|
if(Count >= 0) // It's forward, so set
|
||
|
|
Flags |= FR_DOWN; // downward search bit
|
||
|
|
|
||
|
|
find:
|
||
|
|
rtp.SetCp(cpStart); // Move to start of search
|
||
|
|
cpMatch = rtp.FindText(cp, Flags, bstr, cchBstr);
|
||
|
|
if (Mode == MOVE_IP && cpMatch == cpMin && // Ordinary Find matched
|
||
|
|
rtp.GetCp() == cpMost) // current range
|
||
|
|
{
|
||
|
|
Assert(cpStart == cpSave); // (Can't loop twice)
|
||
|
|
cpStart += Count > 0 ? 1 : -1; // Move over one char
|
||
|
|
goto find; // and try again
|
||
|
|
}
|
||
|
|
|
||
|
|
if(cpMatch < 0) // Match failed
|
||
|
|
{
|
||
|
|
if(pDelta) // Return match string length
|
||
|
|
*pDelta = 0; // = 0
|
||
|
|
return S_FALSE; // Signal no match
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
// Match succeeded: set new cp and cch for range, update selection (if
|
||
|
|
// this range is a selection), send notifications, and return NOERROR
|
||
|
|
|
||
|
|
cp = rtp.GetCp(); // cp = cpMost of match string
|
||
|
|
if(pDelta) // Return match string length
|
||
|
|
*pDelta = cchBstr; // if caller wants to know
|
||
|
|
|
||
|
|
cch = cp - cpMatch; // Default to select matched
|
||
|
|
// string (for MOVE_IP)
|
||
|
|
if(Mode != MOVE_IP) // MOVE_START or MOVE_END
|
||
|
|
{
|
||
|
|
if(Mode == MOVE_START) // MOVE_START moves to start
|
||
|
|
cp = cpMatch; // of matched string
|
||
|
|
cch = cp - cpSave; // Distance end moved
|
||
|
|
if(!cchSave && (Mode ^ cch) < 0) // If crossed ends of initial
|
||
|
|
cch = 0; // IP, use an IP
|
||
|
|
else if(cchSave) // Initially nondegenerate
|
||
|
|
{ // range
|
||
|
|
if((cchSave ^ Mode) < 0) // If wrong end is active,
|
||
|
|
cchSave = -cchSave; // fake a FlipRange to get
|
||
|
|
cch += cchSave; // new length
|
||
|
|
if((cch ^ cchSave) < 0) // If ends would cross,
|
||
|
|
cch = 0; // convert to insertion point
|
||
|
|
}
|
||
|
|
}
|
||
|
|
if ((cp != GetCp() || cch != _cch) // Active end and/or length of
|
||
|
|
&& Set(cp, cch)) // range changed
|
||
|
|
{ // Use the new values
|
||
|
|
Update(TRUE); // Update selection
|
||
|
|
}
|
||
|
|
return NOERROR;
|
||
|
|
}
|
||
|
|
|
||
|
|
/*
|
||
|
|
* CTxtRange::Matcher (Cset, Count, pDelta, fExtend, Match)
|
||
|
|
*
|
||
|
|
* @mfunc
|
||
|
|
* Helper function to move active end up to <p cch> characters past
|
||
|
|
* all contiguous characters that are (<p Match> ? in : not in) the cset
|
||
|
|
* *<p pvar>. If <p fExtend>, extend the range to include the characters
|
||
|
|
* past by. Return *<p pDelta> = # characters past by.
|
||
|
|
*
|
||
|
|
* @rdesc
|
||
|
|
* HRESULT = (if change) ? NOERROR :
|
||
|
|
* (if <p Cset> valid) ? S_FALSE : E_INVALIDARG
|
||
|
|
*/
|
||
|
|
HRESULT CTxtRange::Matcher (
|
||
|
|
VARIANT * Cset, //@parm Character match set
|
||
|
|
long Count, //@parm Max cch to match
|
||
|
|
long * pDelta, //@parm Out parm for cch moved
|
||
|
|
MOVES Mode, //@parm MOVE_START (-1), MOVE_IP (0), MOVE_END (1)
|
||
|
|
MATCHES Match) //@parm MATCH_WHILE spans Cset; else break on Cset
|
||
|
|
{
|
||
|
|
#ifndef PEGASUS
|
||
|
|
TRACEBEGIN(TRCSUBSYSTOM, TRCSCOPEINTERN, "CTxtRange::Matcher");
|
||
|
|
|
||
|
|
// This (and other) code assumes the following conditions:
|
||
|
|
Assert(MOVE_START == -1 && MOVE_IP == 0 && MOVE_END == 1);
|
||
|
|
Assert(MATCH_UNTIL == 0 && MATCH_WHILE == 1);
|
||
|
|
Assert(sizeof(WORD) == 2); // 16-bit WORDs
|
||
|
|
|
||
|
|
if(!Cset)
|
||
|
|
return E_INVALIDARG;
|
||
|
|
|
||
|
|
if(IsZombie())
|
||
|
|
return CO_E_RELEASED;
|
||
|
|
|
||
|
|
CCallMgr callmgr(GetPed());
|
||
|
|
LONG cch; // For cch moved
|
||
|
|
TCHAR ch; // Current char
|
||
|
|
LONG count = Count; // Count down variable
|
||
|
|
LONG cpSave; // To save initial cp
|
||
|
|
WORD ctype; // CT_TYPEx info for ch
|
||
|
|
long Delta; // Value for *pDelta
|
||
|
|
BOOL fInCset; // TRUE iff ch in Cset
|
||
|
|
UINT i, j; // Handy indices
|
||
|
|
LONG iDir = (Count > 0) ? 1 : -1; // Count increment
|
||
|
|
long lVal = Cset->lVal;
|
||
|
|
TCHAR * pch; // Used to walk BSTR Cset
|
||
|
|
CTxtPtr tp(_rpTX); // tp to walk text with
|
||
|
|
LONG vt = Cset->vt;
|
||
|
|
|
||
|
|
if(pDelta) // Default neither motion
|
||
|
|
*pDelta = 0; // nor match
|
||
|
|
|
||
|
|
if (Mode == MOVE_IP && (_cch ^ Count) < 0 || // Wrong active end:
|
||
|
|
Mode != MOVE_IP && (_cch ^ Mode) < 0)
|
||
|
|
{
|
||
|
|
tp.AdvanceCp(-_cch); // go to other end
|
||
|
|
}
|
||
|
|
cpSave = tp.GetCp(); // Save cp for checks
|
||
|
|
|
||
|
|
if(Count > 0) // If matching forward,
|
||
|
|
{ // get current char
|
||
|
|
ch = tp.GetChar();
|
||
|
|
count--; // One less char to match
|
||
|
|
}
|
||
|
|
else // If matching backward,
|
||
|
|
ch = tp.NextCharCount(count); // start at previous char
|
||
|
|
|
||
|
|
if(!ch) // At one end or other, so
|
||
|
|
return S_FALSE; // signal no match
|
||
|
|
|
||
|
|
|
||
|
|
// Process built-in and explicit character sets
|
||
|
|
if(vt & VT_BYREF) // VB passes VT_BYREF
|
||
|
|
{ // unless args are
|
||
|
|
lVal = *Cset->plVal; // enclosed in ()'s
|
||
|
|
vt &= ~ VT_BYREF;
|
||
|
|
}
|
||
|
|
|
||
|
|
if(vt == VT_I2) // Should be VT_I4, but
|
||
|
|
lVal &= 0xffff; // facilitate common cases
|
||
|
|
|
||
|
|
// Built-in char set: either Unicode range or CT_CTYPEx
|
||
|
|
if(vt == VT_I4 || vt == VT_I2)
|
||
|
|
{
|
||
|
|
i = lVal & 0xffff; // First code or CT mask
|
||
|
|
j = lVal >> 16; // Size of range
|
||
|
|
if(lVal < 0) // Unicode range Cset
|
||
|
|
{ // (sign bit is set)
|
||
|
|
j &= 0x7fff; // Kill sign bit
|
||
|
|
while (((BOOL)Match ^ (ch - i > j)) && // ch in range or not
|
||
|
|
(ch = tp.NextCharCount(count))) // Another char available
|
||
|
|
; // Note: count is passed
|
||
|
|
} // by reference
|
||
|
|
else // CT_CTYPEx Cset
|
||
|
|
{ // CT_CTYPEx is given by
|
||
|
|
if(!j) // upper WORD of lVal
|
||
|
|
j = CT_CTYPE1; // 0 defaults to CT_CTYPE1
|
||
|
|
do
|
||
|
|
{
|
||
|
|
ctype = 0; // For each char, get
|
||
|
|
// string type info
|
||
|
|
W32->GetStringTypeEx(0, j, &ch, 1, &ctype);
|
||
|
|
|
||
|
|
// Loop (up to |Count| - 1 times) as long as the characters
|
||
|
|
// encountered are in the Cset (Match = MATCH_WHILE (=1)),
|
||
|
|
// or as long as they are not (Match = MATCH_UNTIL (=0)).
|
||
|
|
|
||
|
|
fInCset = (j == CT_CTYPE2) // CT_CTYPE2 values are
|
||
|
|
? (ctype == i) // mutually exclusive;
|
||
|
|
: (ctype & i) != 0; // others can be combos
|
||
|
|
|
||
|
|
} while ((Match ^ fInCset) == 0 &&
|
||
|
|
(ch = tp.NextCharCount(count)) != 0);
|
||
|
|
} // End of built-in Csets
|
||
|
|
} // End of Cset VT_I4
|
||
|
|
|
||
|
|
// Explicit char set given by chars in Cset->bstrVal
|
||
|
|
else if (Cset->vt == VT_BSTR)
|
||
|
|
{
|
||
|
|
//REVIEW (keithcu) What is going on here?
|
||
|
|
if((DWORD_PTR)Cset->bstrVal < 0xfffff) // Don't get fooled by
|
||
|
|
return E_INVALIDARG; // invalid vt values
|
||
|
|
j = SysStringLen(Cset->bstrVal);
|
||
|
|
do
|
||
|
|
{ // Set i = 0 if ch isn't
|
||
|
|
pch = Cset->bstrVal; // in set; this stops
|
||
|
|
for(i = j; // movement
|
||
|
|
i && (ch != *pch++);
|
||
|
|
i--) ;
|
||
|
|
|
||
|
|
// If we are doing a MATCH_WHILE routine then we only
|
||
|
|
// continue while i > 0 becuase this indicates that we
|
||
|
|
// found the char at the current cp in the CSet. If
|
||
|
|
// we were doing a MATCH_UNTIL then we should quit when
|
||
|
|
// i != 0 becuase the current char was in the CSet.
|
||
|
|
} while((Match == (i ? MATCH_WHILE : MATCH_UNTIL)) &&
|
||
|
|
(ch = tp.NextCharCount(count))); // Break if no more chars
|
||
|
|
} // or ch not in set
|
||
|
|
else
|
||
|
|
return E_INVALIDARG;
|
||
|
|
|
||
|
|
/* If MoveWhile, leave tp immediately after last matched char going
|
||
|
|
* forward and at that char going backward (helps to think of tp
|
||
|
|
* pointing in between chars). If MoveUntil, leave tp at the char
|
||
|
|
* going forward and just after that char going backward.
|
||
|
|
*
|
||
|
|
* E.g.: the code
|
||
|
|
*
|
||
|
|
* r.MoveUntil (C1_DIGIT, tomForward, NULL)
|
||
|
|
* r.MoveEndWhile(C1_DIGIT, tomForward, NULL)
|
||
|
|
*
|
||
|
|
* breaks at the first digit and selects the number going forward.
|
||
|
|
* Similarly
|
||
|
|
*
|
||
|
|
* r.MoveUntil (C1_DIGIT, tomBackward, NULL)
|
||
|
|
* r.MoveStartWhile(C1_DIGIT, tomBackward, NULL)
|
||
|
|
*
|
||
|
|
* selects the number going backward.
|
||
|
|
*/
|
||
|
|
count = (Match == MATCH_WHILE && !ch) // If MoveWhile, move past
|
||
|
|
? iDir : 0; // last matched char
|
||
|
|
if(Count < 0)
|
||
|
|
count++;
|
||
|
|
tp.AdvanceCp(count);
|
||
|
|
|
||
|
|
Delta = cch = 0; // Suppress motion unless
|
||
|
|
if(Match == MATCH_WHILE || ch) // match occurred
|
||
|
|
{
|
||
|
|
Delta = cch = tp.GetCp() - cpSave; // Calculate distance moved
|
||
|
|
if(Match == MATCH_UNTIL) // For MoveUntil methods,
|
||
|
|
Delta += iDir; // match counts as a char
|
||
|
|
}
|
||
|
|
|
||
|
|
if(pDelta) // Report motion to caller
|
||
|
|
*pDelta = Delta; // if it wants to know
|
||
|
|
|
||
|
|
// Handle cases for which range is changed
|
||
|
|
if(cch || (Delta && _cch && Mode == MOVE_IP))
|
||
|
|
{
|
||
|
|
if (Mode == MOVE_IP || // If move IP or asked to
|
||
|
|
!_cch && (Mode ^ Count) < 0) // cross ends of initial
|
||
|
|
{ // IP, use an IP
|
||
|
|
cch = 0;
|
||
|
|
}
|
||
|
|
else if(_cch) // Initially nondegenerate
|
||
|
|
{ // range
|
||
|
|
if((_cch ^ Mode) < 0) // If wrong end is active,
|
||
|
|
_cch = -_cch; // fake a FlipRange (will
|
||
|
|
cch += _cch; // set cp shortly)
|
||
|
|
if((cch ^ _cch) < 0) // If ends crossed, convert
|
||
|
|
cch = 0; // to insertion point
|
||
|
|
}
|
||
|
|
if(Set(tp.GetCp(), cch)) // Set new range cp and cch
|
||
|
|
{
|
||
|
|
Update(TRUE); // Update selection
|
||
|
|
return NOERROR; // Signal match occurred
|
||
|
|
}
|
||
|
|
return S_FALSE;
|
||
|
|
}
|
||
|
|
|
||
|
|
// No change in range. Return NOERROR iff match occurred for MOVE_UNTIL
|
||
|
|
return Delta ? NOERROR : S_FALSE;
|
||
|
|
#else
|
||
|
|
return 0;
|
||
|
|
#endif
|
||
|
|
}
|
||
|
|
|
||
|
|
/*
|
||
|
|
* CTxtRange::Mover (Unit, Count, pDelta, Mode)
|
||
|
|
*
|
||
|
|
* @mfunc
|
||
|
|
* Helper function to move end(s) <p Count> <p Unit>s, which end(s)
|
||
|
|
* depending on Mode = MOVE_IP, MOVE_START, and MOVE_END. Collapsing
|
||
|
|
* the range by using MOVE_IP counts as a Unit.
|
||
|
|
*
|
||
|
|
* Extends range from End if <p Mode> = MOVE_END and from Start if
|
||
|
|
* <p Mode> = MOVE_START; else (MOVE_IP) it collapses range to Start if
|
||
|
|
* <p Count> <lt>= 0 and to End if <p Count> <gt> 0.
|
||
|
|
*
|
||
|
|
* Sets *<p pDelta> = count of Units moved
|
||
|
|
*
|
||
|
|
* Used by ITextRange::Delete(), Move(), MoveStart(), MoveEnd(),
|
||
|
|
* and SetIndex()
|
||
|
|
*
|
||
|
|
* @rdesc
|
||
|
|
* HRESULT = (if change) ? NOERROR :
|
||
|
|
* (if <p Unit> valid) ? S_FALSE : E_INVALIDARG
|
||
|
|
*/
|
||
|
|
HRESULT CTxtRange::Mover (
|
||
|
|
long Unit, //@parm Unit to use for moving active end
|
||
|
|
long Count, //@parm Count of units to move active end
|
||
|
|
long * pDelta, //@parm Out parm for count of units moved
|
||
|
|
MOVES Mode) //@parm MOVE_START (-1), MOVE_IP (0), MOVE_END (1)
|
||
|
|
{
|
||
|
|
TRACEBEGIN(TRCSUBSYSTOM, TRCSCOPEINTERN, "CTxtRange::Mover");
|
||
|
|
|
||
|
|
if(pDelta)
|
||
|
|
*pDelta = 0; // Default no units moved
|
||
|
|
|
||
|
|
if(IsZombie())
|
||
|
|
return CO_E_RELEASED;
|
||
|
|
|
||
|
|
LONG cch;
|
||
|
|
LONG cchAdj = GetAdjustedTextLength();
|
||
|
|
LONG cchMax = 0; // Default full story limits
|
||
|
|
LONG cp;
|
||
|
|
LONG cpMost = GetCpMost();
|
||
|
|
LONG cUnitCollapse = 0;
|
||
|
|
HRESULT hr = NOERROR;
|
||
|
|
CTxtRange rg(*this); // Use a copy to look around
|
||
|
|
|
||
|
|
if(pDelta)
|
||
|
|
*pDelta = 0; // Default no units moved
|
||
|
|
|
||
|
|
if(_cch && Count) // Nondegenerate range
|
||
|
|
{
|
||
|
|
if(Mode == MOVE_IP) // Insertion point: will
|
||
|
|
{ // collapse range if Unit is
|
||
|
|
if((Count ^ rg._cch) < 0) // defined. Go to correct end
|
||
|
|
rg.FlipRange();
|
||
|
|
if(Count > 0)
|
||
|
|
{
|
||
|
|
if(cpMost > cchAdj)
|
||
|
|
{
|
||
|
|
cUnitCollapse = -1; // Collapse before final CR
|
||
|
|
Count = 0; // No more motion
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{ // Extend pDelta pcpMin pcpMost
|
||
|
|
hr = rg.Expander(Unit, FALSE, NULL, NULL, &cp);
|
||
|
|
cUnitCollapse = 1; // Collapse counts as a Unit
|
||
|
|
Count--; // One less Unit to count
|
||
|
|
}
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
hr = rg.Expander(Unit, FALSE, NULL, &cp, NULL);
|
||
|
|
cUnitCollapse = -1;
|
||
|
|
Count++;
|
||
|
|
}
|
||
|
|
if(FAILED(hr))
|
||
|
|
return hr;
|
||
|
|
}
|
||
|
|
else if((Mode ^ rg._cch) < 0) // MOVE_START or MOVE_END
|
||
|
|
rg.FlipRange(); // Go to Start or End
|
||
|
|
}
|
||
|
|
|
||
|
|
if(Count > 0 && Mode != MOVE_END) // Moving IP or Start forward
|
||
|
|
{
|
||
|
|
cchMax = cchAdj - rg.GetCp(); // Can't pass final CR
|
||
|
|
if(cchMax <= 0) // Already at or past it
|
||
|
|
{ // Only count comes from
|
||
|
|
Count = cUnitCollapse; // possible collapse
|
||
|
|
cp = cchAdj; // Put active end at cchAdj
|
||
|
|
cch = (Mode == MOVE_START && cpMost > cchAdj)
|
||
|
|
? cp - cpMost : 0;
|
||
|
|
goto set;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
cch = rg.UnitCounter(Unit, Count, cchMax); // Count off Count Units
|
||
|
|
|
||
|
|
if(cch == tomForward) // Unit not implemented
|
||
|
|
return E_NOTIMPL;
|
||
|
|
|
||
|
|
if(cch == tomBackward) // Unit not available, e.g.,
|
||
|
|
return S_FALSE; // tomObject and no objects
|
||
|
|
|
||
|
|
Count += cUnitCollapse; // Add a Unit if collapse
|
||
|
|
if(!Count) // Nothing changed, so quit
|
||
|
|
return S_FALSE;
|
||
|
|
|
||
|
|
if (Mode == MOVE_IP || // MOVE_IP or
|
||
|
|
!_cch && (Mode ^ Count) < 0) // initial IP end cross
|
||
|
|
{
|
||
|
|
cch = 0; // New range is degenerate
|
||
|
|
}
|
||
|
|
else if(_cch) // MOVE_START or MOVE_END
|
||
|
|
{ // with nondegenerate range
|
||
|
|
if((_cch ^ Mode) < 0) // Make _cch correspond to end
|
||
|
|
_cch = -_cch; // that moved
|
||
|
|
cch += _cch; // Possible new range length
|
||
|
|
if((cch ^ _cch) < 0) // Nondegenerate end cross
|
||
|
|
cch = 0; // Use IP
|
||
|
|
}
|
||
|
|
cp = rg.GetCp();
|
||
|
|
|
||
|
|
set:
|
||
|
|
if(Set(cp, cch)) // Attempt to set new range
|
||
|
|
{ // Something changed
|
||
|
|
if(pDelta) // Report count of units
|
||
|
|
*pDelta = Count; // advanced
|
||
|
|
Update(TRUE); // Update selection
|
||
|
|
return NOERROR;
|
||
|
|
}
|
||
|
|
return S_FALSE;
|
||
|
|
}
|
||
|
|
|
||
|
|
/*
|
||
|
|
*
|
||
|
|
* CTxtRange::Replacer (cchNew, *pch)
|
||
|
|
*
|
||
|
|
* @mfunc
|
||
|
|
* Replace this range's using CHARFORMAT _iFormat and updating other
|
||
|
|
* text runs as needed.
|
||
|
|
*
|
||
|
|
* Same as CTxtRange::CleanseAndReplaceRange(cchNew, *pch, publdr),
|
||
|
|
* except creates its own undo builder.
|
||
|
|
*
|
||
|
|
* @rdesc
|
||
|
|
* cch of text actually pasted
|
||
|
|
*
|
||
|
|
* @devnote
|
||
|
|
* moves this text pointer to end of replaced text and
|
||
|
|
* may move text block and formatting arrays
|
||
|
|
*/
|
||
|
|
LONG CTxtRange::Replacer (
|
||
|
|
LONG cchNew, //@parm Length of replacement text
|
||
|
|
TCHAR const * pch, //@parm Replacement text
|
||
|
|
DWORD dwFlags) //@parm ReplaceRange flags
|
||
|
|
{
|
||
|
|
TRACEBEGIN(TRCSUBSYSTOM, TRCSCOPEINTERN, "CTxtRange::Replacer");
|
||
|
|
|
||
|
|
IUndoBuilder * publdr;
|
||
|
|
CGenUndoBuilder undobldr(GetPed(), UB_AUTOCOMMIT, &publdr);
|
||
|
|
|
||
|
|
undobldr.StopGroupTyping();
|
||
|
|
|
||
|
|
// Note: we don't check the limit on text here. Right now, this
|
||
|
|
// is only called by Delete and SetText so this is OK. However,
|
||
|
|
// we might want to reinvestigate this latter if this is called
|
||
|
|
// by anything else.
|
||
|
|
return CleanseAndReplaceRange(cchNew, pch, FALSE, publdr, NULL, NULL, dwFlags);
|
||
|
|
}
|
||
|
|
|
||
|
|
/*
|
||
|
|
* CTxtRange::CharFormatSetter (pCF)
|
||
|
|
*
|
||
|
|
* @mfunc
|
||
|
|
* Helper function that's the same as CTxtRange::SetCharFormat(), but
|
||
|
|
* adds undo building, and notification.
|
||
|
|
*
|
||
|
|
* @rdesc
|
||
|
|
* HRESULT = (if success) ? NOERROR : S_FALSE
|
||
|
|
* (protected) ? E_ACCESSDENIED : E_OUTOFMEMORY
|
||
|
|
*/
|
||
|
|
HRESULT CTxtRange::CharFormatSetter (
|
||
|
|
const CCharFormat *pCF, //@parm CCharFormat to fill with results
|
||
|
|
DWORD dwMask) //@parm CHARFORMAT2 mask
|
||
|
|
{
|
||
|
|
TRACEBEGIN(TRCSUBSYSTOM, TRCSCOPEINTERN, "CTxtRange::CharFormatSetter");
|
||
|
|
|
||
|
|
if(IsZombie())
|
||
|
|
return CO_E_RELEASED;
|
||
|
|
|
||
|
|
CTxtEdit *ped = GetPed();
|
||
|
|
CCallMgr callmgr(ped);
|
||
|
|
IUndoBuilder * publdr;
|
||
|
|
CGenUndoBuilder undobldr(ped, UB_AUTOCOMMIT, &publdr);
|
||
|
|
|
||
|
|
if(WriteAccessDenied())
|
||
|
|
return E_ACCESSDENIED;
|
||
|
|
|
||
|
|
undobldr.StopGroupTyping();
|
||
|
|
return SetCharFormat(pCF, FALSE, publdr, dwMask, 0);
|
||
|
|
}
|
||
|
|
|
||
|
|
/*
|
||
|
|
* CTxtRange::ParaFormatSetter (pPF, dwMask)
|
||
|
|
*
|
||
|
|
* @mfunc
|
||
|
|
* Helper function that's the same as CTxtRange::SetParaFormat(), but
|
||
|
|
* adds protection checking, undo building, and notification.
|
||
|
|
*
|
||
|
|
* @rdesc
|
||
|
|
* HRESULT = (if success) ? NOERROR : S_FALSE
|
||
|
|
* (protected) ? E_ACCESSDENIED : E_OUTOFMEMORY
|
||
|
|
*/
|
||
|
|
HRESULT CTxtRange::ParaFormatSetter (
|
||
|
|
const CParaFormat *pPF, //@parm CParaFormat to fill with results
|
||
|
|
DWORD dwMask) //@parm Mask to use
|
||
|
|
{
|
||
|
|
TRACEBEGIN(TRCSUBSYSTOM, TRCSCOPEINTERN, "CTxtRange::ParaFormatSetter");
|
||
|
|
|
||
|
|
if(IsZombie())
|
||
|
|
return CO_E_RELEASED;
|
||
|
|
|
||
|
|
CTxtEdit *ped = GetPed();
|
||
|
|
CCallMgr callmgr(ped);
|
||
|
|
IUndoBuilder * publdr;
|
||
|
|
CGenUndoBuilder undobldr(ped, UB_AUTOCOMMIT, &publdr);
|
||
|
|
|
||
|
|
if(WriteAccessDenied())
|
||
|
|
return E_ACCESSDENIED;
|
||
|
|
|
||
|
|
undobldr.StopGroupTyping();
|
||
|
|
// In RichEdit 3.0, we don't support setting tables
|
||
|
|
if(GetPF()->InTable())
|
||
|
|
dwMask &= ~PFM_TABSTOPS;
|
||
|
|
return SetParaFormat(pPF, publdr, dwMask & ~PFM_TABLE);
|
||
|
|
}
|
||
|
|
|
||
|
|
/*
|
||
|
|
* CTxtRange::WriteAccessDenied()
|
||
|
|
*
|
||
|
|
* @mfunc
|
||
|
|
* Returns TRUE iff at least part of the range is protected and the
|
||
|
|
* owner chooses to enforce it
|
||
|
|
*
|
||
|
|
* @rdesc
|
||
|
|
* TRUE iff write access to range is denied
|
||
|
|
*/
|
||
|
|
BOOL CTxtRange::WriteAccessDenied ()
|
||
|
|
{
|
||
|
|
TRACEBEGIN(TRCSUBSYSTOM, TRCSCOPEINTERN, "CTxtRange::WriteAccessDenied");
|
||
|
|
|
||
|
|
int iProt;
|
||
|
|
CTxtEdit *ped = GetPed();
|
||
|
|
|
||
|
|
if (ped && ped->TxGetReadOnly() ||
|
||
|
|
((iProt = IsProtected(-1)) == PROTECTED_YES ||
|
||
|
|
(iProt == PROTECTED_ASK && ped->IsProtectionCheckingEnabled() &&
|
||
|
|
ped->QueryUseProtection(this, 0, 0, 0))))
|
||
|
|
// N.B. the preceding if statement assumes that IsProtected returns a tri-value
|
||
|
|
{
|
||
|
|
return TRUE;
|
||
|
|
}
|
||
|
|
|
||
|
|
return FALSE;
|
||
|
|
}
|
||
|
|
|
||
|
|
/*
|
||
|
|
* CTxtRange::IsTrue (f, pB)
|
||
|
|
*
|
||
|
|
* @mfunc
|
||
|
|
* Return *<p pB> = tomTrue iff <p f> is nonzero and pB isn't NULL
|
||
|
|
*
|
||
|
|
* @rdesc
|
||
|
|
* HRESULT = (f) ? NOERROR : S_FALSE
|
||
|
|
*/
|
||
|
|
HRESULT CTxtRange::IsTrue(BOOL f, long *pB)
|
||
|
|
{
|
||
|
|
if(pB)
|
||
|
|
*pB = tomFalse;
|
||
|
|
|
||
|
|
if(IsZombie())
|
||
|
|
return CO_E_RELEASED;
|
||
|
|
|
||
|
|
if(f)
|
||
|
|
{
|
||
|
|
if(pB)
|
||
|
|
*pB = tomTrue;
|
||
|
|
return NOERROR;
|
||
|
|
}
|
||
|
|
|
||
|
|
return S_FALSE;
|
||
|
|
}
|
||
|
|
|
||
|
|
/*
|
||
|
|
* CTxtRange::GetLong (lValue, pLong)
|
||
|
|
*
|
||
|
|
* @mfunc
|
||
|
|
* Return *pLong = lValue provided pLong isn't NULL and this range
|
||
|
|
* isn't a zombie
|
||
|
|
*
|
||
|
|
* @rdesc
|
||
|
|
* HRESULT = (zombie) ? CO_E_RELEASED :
|
||
|
|
* (pLong) ? NOERROR : E_INVALIDARG
|
||
|
|
*/
|
||
|
|
HRESULT CTxtRange::GetLong (
|
||
|
|
LONG lValue, //@parm Long value to return
|
||
|
|
long *pLong) //@parm Out parm to receive long value
|
||
|
|
{
|
||
|
|
if(IsZombie())
|
||
|
|
return CO_E_RELEASED;
|
||
|
|
|
||
|
|
_TEST_INVARIANT_
|
||
|
|
|
||
|
|
if(!pLong)
|
||
|
|
return E_INVALIDARG;
|
||
|
|
|
||
|
|
*pLong = lValue;
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
return NOERROR;
|
||
|
|
}
|
||
|
|
|
||
|
|
/*
|
||
|
|
* IsSameVtables (punk1, punk2)
|
||
|
|
*
|
||
|
|
* @mfunc
|
||
|
|
* Returns true if punk1 has same vtable as punk2
|
||
|
|
*
|
||
|
|
* @rdesc
|
||
|
|
* TRUE iff punk1 has same vtable as punk2
|
||
|
|
*/
|
||
|
|
BOOL IsSameVtables(IUnknown *punk1, IUnknown *punk2)
|
||
|
|
{
|
||
|
|
return punk1 && punk2 && *(long *)punk1 == *(long *)punk2;
|
||
|
|
}
|
||
|
|
|
||
|
|
/*
|
||
|
|
* FPPTS_TO_TWIPS (x)
|
||
|
|
*
|
||
|
|
* @mfunc
|
||
|
|
* Returns 20*x, i.e., the number of twips corresponding to
|
||
|
|
* x given in floating-point points. The value is rounded.
|
||
|
|
*
|
||
|
|
* @rdesc
|
||
|
|
* x converted to twips
|
||
|
|
*/
|
||
|
|
long FPPTS_TO_TWIPS(
|
||
|
|
float x)
|
||
|
|
{
|
||
|
|
return 20*x + ((x >= 0) ? 0.5 : -0.5);
|
||
|
|
}
|