Microsoft/Windows2003-3790
Microsoft/Windows2003-3790
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
master
Windows2003-3790/windows/richedit/re30/edit.cpp
Microsoft 50969b0ea2 First commit
2020-09-30 16:53:55 +02:00

6345 lines
190 KiB
C++
Raw Permalink Blame History

/*
* @doc INTERNAL
*
* @module EDIT.C - main part of CTxtEdit |
*
* See also textserv.cpp (ITextServices and SendMessage interfaces)
* and tomDoc.cpp (ITextDocument interface)
*
* Authors: <nl>
* Original RichEdit code: David R. Fulmer <nl>
* Christian Fortini, Murray Sargent, Alex Gounares, Rick Sailor,
* Jon Matousek
*
* History: <nl>
* 12/28/95 jonmat-Added support of Magellan mouse and smooth scrolling.
*
* @devnote
* Be sure to set tabs at every four (4) columns. In fact, don't even
* think of doing anything else!
*
* Copyright (c) 1995-1998 Microsoft Corporation. All rights reserved.
*/
#include "_common.h"
#include "_edit.h"
#include "_dispprt.h"
#include "_dispml.h"
#include "_dispsl.h"
#include "_select.h"
#include "_text.h"
#include "_runptr.h"
#include "_font.h"
#include "_measure.h"
#include "_render.h"
#include "_m_undo.h"
#include "_antievt.h"
#include "_rtext.h"
#include "_uspi.h"
#include "_urlsup.h"
#ifdef LINESERVICES
#include "_ols.h"
#endif
#include "_txtbrk.h"
#include "_clasfyc.h"
#define CONTROL(_ch) (_ch - 'A' + 1)
ASSERTDATA
// This is not public because we don't really want folks using it.
// ITextServices is a private interface.
EXTERN_C const IID IID_ITextServices = { // 8d33f740-cf58-11ce-a89d-00aa006cadc5
0x8d33f740,
0xcf58,
0x11ce,
{0xa8, 0x9d, 0x00, 0xaa, 0x00, 0x6c, 0xad, 0xc5}
};
// {13E670F4-1A5A-11cf-ABEB-00AA00B65EA1}
EXTERN_C const GUID IID_ITextHost =
{ 0x13e670f4, 0x1a5a, 0x11cf, { 0xab, 0xeb, 0x0, 0xaa, 0x0, 0xb6, 0x5e, 0xa1 } };
// {13E670F5-1A5A-11cf-ABEB-00AA00B65EA1}
EXTERN_C const GUID IID_ITextHost2 =
{ 0x13e670f5, 0x1a5a, 0x11cf, { 0xab, 0xeb, 0x0, 0xaa, 0x0, 0xb6, 0x5e, 0xa1 } };
// this is used internally do tell if a data object is one of our own.
EXTERN_C const GUID IID_IRichEditDO =
{ /* 21bc3b20-e5d5-11cf-93e1-00aa00b65ea1 */
0x21bc3b20,
0xe5d5,
0x11cf,
{0x93, 0xe1, 0x00, 0xaa, 0x00, 0xb6, 0x5e, 0xa1}
};
// Static data members
DWORD CTxtEdit::_dwTickDblClick; // time of last double-click
POINT CTxtEdit::_ptDblClick; // position of last double-click
//HCURSOR CTxtEdit::_hcurCross = 0; // We don't implement outline drag move
HCURSOR CTxtEdit::_hcurArrow = 0;
HCURSOR CTxtEdit::_hcurHand = 0;
HCURSOR CTxtEdit::_hcurIBeam = 0;
HCURSOR CTxtEdit::_hcurItalic = 0;
HCURSOR CTxtEdit::_hcurSelBar = 0;
const TCHAR szCRLF[]= TEXT("\r\n");
const TCHAR szCR[] = TEXT("\r");
WORD g_wFlags = 0; // Keyboard controlled flags
/*
* GetKbdFlags(vkey, dwFlags)
*
* @func
* return bit mask (RSHIFT, LSHIFT, RCTRL, LCTRL, RALT, or LALT)
* corresponding to vkey = VK_SHIFT, VK_CONTROL, or VK_MENU and
* dwFlags
*
* @rdesc
* Bit mask corresponding to vkey and dwFlags
*/
DWORD GetKbdFlags(
WORD vkey, //@parm Virtual key code
DWORD dwFlags) //@parm lparam of WM_KEYDOWN msg
{
if(vkey == VK_SHIFT)
return (LOBYTE(HIWORD(dwFlags)) == 0x36) ? RSHIFT : LSHIFT;
if(vkey == VK_CONTROL)
return (HIWORD(dwFlags) & KF_EXTENDED) ? RCTRL : LCTRL;
Assert(vkey == VK_MENU);
return (HIWORD(dwFlags) & KF_EXTENDED) ? RALT : LALT;
}
///////////////// CTxtEdit Creation, Initialization, Destruction ///////////////////////////////////////
/*
* CTxtEdit::CTxtEdit()
*
* @mfunc
* constructor
*/
CTxtEdit::CTxtEdit(
ITextHost2 *phost,
IUnknown * punk)
{
TRACEBEGIN(TRCSUBSYSEDIT, TRCSCOPEINTERN, "CTxtEdit::CTxtEdit");
_unk.Init();
_punk = (punk) ? punk : &_unk;
_ldte.Init(this);
_phost = phost;
_cpAccelerator = -1; // Default to no accelerator
// Initialize _iCF and _iPF to something bogus
Set_iCF(-1);
Set_iPF(-1);
// Initialize local maximum text size to window default
_cchTextMost = cInitTextMax;
// This actually counts the number of active ped
W32->AddRef();
}
/*
* CTxtEdit::~CTxtEdit()
*
* @mfunc
* Destructor
*/
CTxtEdit::~CTxtEdit ()
{
TRACEBEGIN(TRCSUBSYSEDIT, TRCSCOPEINTERN, "CTxtEdit::~CTxtEdit");
Assert(!_fMButtonCapture); // Need to properly transition
// Magellan mouse if asserts!
_fSelfDestruct = TRUE; // Tell the Call Mgr not to
// call this any more
// Flush clipboard first
_ldte.FlushClipboard();
if(_pDocInfo) // Do this before closing
{ // down internal structures
CloseFile(TRUE); // Close any open file
delete _pDocInfo; // Delete document info
_pDocInfo = NULL;
}
if(_pdetecturl)
delete _pdetecturl;
if (_pbrk)
delete _pbrk;
if(_pobjmgr)
delete _pobjmgr;
// Release our reference to selection object
if(_psel)
_psel->Release();
// Delete undo and redo managers
if(_pundo)
_pundo->Destroy();
// Release message filter.
// Note that the attached message filter must have released this document
// Otherwise we will never get here.
if (_pMsgFilter)
_pMsgFilter->Release();
if(_predo)
_predo->Destroy();
ReleaseFormats(Get_iCF(), Get_iPF()); // Release default formats
delete _pdp; // Delete displays
delete _pdpPrinter;
_pdp = NULL; // Break any further attempts to
// use display
if (_fHost2)
{
// We are in a windows host - need to deal with the shutdown
// problem where the window can be destroyed before text
// services is.
if (!_fReleaseHost)
{
((ITextHost2*)_phost)->TxFreeTextServicesNotification();
}
else
{
// Had to keep host alive so tell it we are done with it.
_phost->Release();
}
}
W32->Release();
}
/*
* CTxtEdit::Init (prcClient)
*
* @mfunc
* Initializes this CTxtEdit. Called by CreateTextServices()
*
* @rdesc
* Return TRUE if successful
*/
BOOL CTxtEdit::Init (
const RECT *prcClient) //@parm Client RECT
{
TRACEBEGIN(TRCSUBSYSEDIT, TRCSCOPEINTERN, "CTxtEdit::Init");
CCharFormat CF;
DWORD dwBits = 0;
DWORD dwMask;
LONG iCF, iPF;
CParaFormat PF;
CCallMgr callmgr(this);
static BOOL fOnce = FALSE;
if (!fOnce)
{
CLock lock;
fOnce = TRUE;
_fnpPropChg[ 0] = &CTxtEdit::OnRichEditChange; // TXTBIT_RICHTEXT
_fnpPropChg[ 1] = &CTxtEdit::OnTxMultiLineChange; // TXTBIT_MULTILINE
_fnpPropChg[ 2] = &CTxtEdit::OnTxReadOnlyChange; // TXTBIT_READONLY
_fnpPropChg[ 3] = &CTxtEdit::OnShowAccelerator; // TXTBIT_SHOWACCELERATOR
_fnpPropChg[ 4] = &CTxtEdit::OnUsePassword; // TXTBIT_USEPASSWORD
_fnpPropChg[ 5] = &CTxtEdit::OnTxHideSelectionChange; // TXTBIT_HIDESELECTION
_fnpPropChg[ 6] = &CTxtEdit::OnSaveSelection; // TXTBIT_SAVESELECTION
_fnpPropChg[ 7] = &CTxtEdit::OnAutoWordSel; // TXTBIT_AUTOWORDSEL
_fnpPropChg[ 8] = &CTxtEdit::OnTxVerticalChange; // TXTBIT_VERTICAL
_fnpPropChg[ 9] = &CTxtEdit::NeedViewUpdate; // TXTBIT_SELECTIONBAR
_fnpPropChg[10] = &CTxtEdit::OnWordWrapChange; // TXTBIT_WORDWRAP
_fnpPropChg[11] = &CTxtEdit::OnAllowBeep; // TXTBIT_ALLOWBEEP
_fnpPropChg[12] = &CTxtEdit::OnDisableDrag; // TXTBIT_DISABLEDRAG
_fnpPropChg[13] = &CTxtEdit::NeedViewUpdate; // TXTBIT_VIEWINSETCHANGE
_fnpPropChg[14] = &CTxtEdit::OnTxBackStyleChange; // TXTBIT_BACKSTYLECHANGE
_fnpPropChg[15] = &CTxtEdit::OnMaxLengthChange; // TXTBIT_MAXLENGTHCHANGE
_fnpPropChg[16] = &CTxtEdit::OnScrollChange; // TXTBIT_SCROLLBARCHANGE
_fnpPropChg[17] = &CTxtEdit::OnCharFormatChange; // TXTBIT_CHARFORMATCHANGE
_fnpPropChg[18] = &CTxtEdit::OnParaFormatChange; // TXTBIT_PARAFORMATCHANGE
_fnpPropChg[19] = &CTxtEdit::NeedViewUpdate; // TXTBIT_EXTENTCHANGE
_fnpPropChg[20] = &CTxtEdit::OnClientRectChange; // TXTBIT_CLIENTRECTCHANGE
}
// Set up default CCharFormat and CParaFormat
if (TxGetDefaultCharFormat(&CF, dwMask) != NOERROR ||
TxGetDefaultParaFormat(&PF) != NOERROR ||
FAILED(GetCharFormatCache()->Cache(&CF, &iCF)) ||
FAILED(GetParaFormatCache()->Cache(&PF, &iPF)))
{
return FALSE;
}
GetTabsCache()->Release(PF._iTabs);
Set_iCF(iCF); // Save format indices
Set_iPF(iPF);
// Load mouse cursors (but only for first instance)
if(!_hcurArrow)
{
_hcurArrow = LoadCursor(0, IDC_ARROW);
if(!_hcurHand)
{
if (dwMajorVersion < 5)
_hcurHand = LoadCursor(hinstRE, MAKEINTRESOURCE(CUR_HAND));
else
_hcurHand = LoadCursor(0, IDC_HAND);
}
if(!_hcurIBeam) // Load cursor
_hcurIBeam = LoadCursor(0, IDC_IBEAM);
if(!_hcurItalic)
_hcurItalic = LoadCursor(hinstRE, MAKEINTRESOURCE(CUR_ITALIC));
if(!_hcurSelBar)
_hcurSelBar = LoadCursor(hinstRE, MAKEINTRESOURCE(CUR_SELBAR));
}
#ifdef DEBUG
// The host is going to do some checking on richtext vs. plain text.
_fRich = TRUE;
#endif // DEBUG
if(_phost->TxGetPropertyBits (TXTBITS | // Get host state flags
TXTBIT_MULTILINE | TXTBIT_SHOWACCELERATOR, // that we cache or need
&dwBits) != NOERROR) // for display setup
{
return FALSE;
} // Cache bits defined by
_dwFlags = dwBits & TXTBITS; // TXTBITS mask
if ((dwBits & TXTBIT_SHOWACCELERATOR) && // They want accelerator,
FAILED(UpdateAccelerator())) // so let's get it
{
return FALSE;
}
_fTransparent = TxGetBackStyle() == TXTBACK_TRANSPARENT;
if(dwBits & TXTBIT_MULTILINE) // Create and initialize
_pdp = new CDisplayML(this); // display
else
_pdp = new CDisplaySL(this);
Assert(_pdp);
if(!_pdp || !_pdp->Init())
return FALSE;
_fUseUndo = TRUE;
_fAutoFont = TRUE;
_fDualFont = TRUE;
_f10DeferChangeNotify = 0;
// Set whether we are in our host or not
ITextHost2 *phost2;
if(_phost->QueryInterface(IID_ITextHost2, (void **)&phost2) == NOERROR)
{
// We assume that ITextHost2 means this is our host
phost2->Release();
_fHost2 = TRUE;
}
else // Get maximum from our host
_phost->TxGetMaxLength(&_cchTextMost);
// Add EOP iff Rich Text
if(IsRich())
{
// We should _not_ be in 10 compatibility mode yet.
// If we transition into 1.0 mode, we'll add a CRLF
// at the end of the document.
SetRichDocEndEOP(0);
}
// Allow for win.ini control over use of line services
if (W32->fUseLs())
{
OnSetTypographyOptions(TO_ADVANCEDTYPOGRAPHY, TO_ADVANCEDTYPOGRAPHY);
}
if (W32->GetDigitSubstitutionMode() != DIGITS_NOTIMPL)
OrCharFlags(fDIGITSHAPE); // digit substitution presents
// Initialize the BiDi property
// It is set to true if OS is BiDi (the system default LCID is a BiDi language)
// or if the current keyboard code page is a BiDi code page
// or if system.ini says we should do it.
if (W32->OnBiDiOS() ||
W32->IsBiDiCodePage(GetKeyboardCodePage(0xFFFFFFFF)) ||
W32->fUseBiDi())
OrCharFlags(fBIDI);
_fAutoKeyboard = IsBiDi() && IsBiDiKbdInstalled();
return TRUE;
}
///////////////////////////// CTxtEdit IUnknown ////////////////////////////////
/*
* CTxtEdit::QueryInterface (riid, ppv)
*
* @mfunc
* IUnknown method
*
* @rdesc
* HRESULT = (if success) ? NOERROR : E_NOINTERFACE
*
* @devnote
* This interface is aggregated. See textserv.cpp for discussion.
*/
HRESULT CTxtEdit::QueryInterface(
REFIID riid,
void **ppv)
{
TRACEBEGIN(TRCSUBSYSEDIT, TRCSCOPEINTERN, "CTxtEdit::QueryInterface");
return _punk->QueryInterface(riid, ppv);
}
/*
* CTxtEdit::AddRef()
*
* @mfunc
* IUnknown method
*
* @rdesc
* ULONG - incremented reference count
*/
ULONG CTxtEdit::AddRef(void)
{
TRACEBEGIN(TRCSUBSYSEDIT, TRCSCOPEINTERN, "CTxtEdit::AddRef");
return _punk->AddRef();
}
/*
* CTxtEdit::Release()
*
* @mfunc
* IUnknown method
*
* @rdesc
* ULONG - decremented reference count
*/
ULONG CTxtEdit::Release(void)
{
TRACEBEGIN(TRCSUBSYSEDIT, TRCSCOPEINTERN, "CTxtEdit::Release");
return _punk->Release();
}
////////////////////////// Undo Management //////////////////////////////
/*
* CTxtEdit::CreateUndoMgr (dwLim, flags)
*
* @mfunc
* Creates an undo stack
*
* @rdesc
* Ptr to new IUndoMgr
*/
IUndoMgr *CTxtEdit::CreateUndoMgr(
DWORD dwLim, //@parm Size limit
USFlags flags)
{
TRACEBEGIN(TRCSUBSYSEDIT, TRCSCOPEINTERN, "CTxtEdit::CreateUndoMgr");
IUndoMgr *pmgr = NULL;
if(_fUseUndo)
{
pmgr = new CUndoStack(this, dwLim, flags);
if(!pmgr)
return NULL;
if(!pmgr->GetUndoLimit())
{
// The undo stack failed to initialize properly (probably
// lack of memory). Trash it and return NULL.
pmgr->Destroy();
return NULL;
}
// We may be asked to create a new undo/redo manager
// before we are completely done with initialization.
// We need to clean up memory we have already allocated.
if(flags & US_REDO)
{
if(_predo)
_predo->Destroy();
_predo = pmgr;
}
else
{
if(_pundo)
_pundo->Destroy();
_pundo = pmgr;
}
}
return pmgr;
}
/*
* CTxtEdit::HandleUndoLimit (dwLim)
*
* @mfunc
* Handles the EM_SETUNDOLIMIT message
*
* @rdesc
* Actual limit to which things were set.
*/
LRESULT CTxtEdit::HandleSetUndoLimit(
LONG Count) //@parm Requested limit size
{
TRACEBEGIN(TRCSUBSYSEDIT, TRCSCOPEINTERN, "CTxtEdit::HandleSetUndoLimit");
if (Count == tomSuspend || // This option really just
Count == tomResume) // suspends undo, i.e.,
{ // doesn't discard existing
_fUseUndo = (Count == tomResume); // antievents
return _pundo ? _pundo->GetUndoLimit() : 0;
}
if(Count < 0)
Count = DEFAULT_UNDO_SIZE;
if(!Count)
{
_fUseUndo = FALSE;
if(_pundo)
{
_pundo->Destroy();
_pundo = NULL;
}
if(_predo)
{
_predo->Destroy();
_predo = NULL;
}
}
else if(!_pundo)
{
_fUseUndo = TRUE;
// Don't worry about return value; if it's NULL, we're
// in the same boat as if the API wasn't called (so later
// on, we might try to allocate the default).
CreateUndoMgr(Count, US_UNDO);
}
else
{
Count = _pundo->SetUndoLimit(Count);
// Setting the undo limit on the undo stack will return to
// us the actual amount set. Try to set the redo stack to
// the same size. If it can't go that big, too bad.
if(_predo)
_predo->SetUndoLimit(Count);
}
return Count;
}
/*
* CTxtEdit::HandleSetTextMode(mode)
*
* @mfunc handles setting the text mode
*
* @rdesc LRESULT; 0 (NOERROR) on success, OLE failure code on failure.
*
* @devnote the text mode does not have to be fully specified; it
* is sufficient to merely specify the specific desired behavior.
*
* Note that the edit control must be completely empty for this
* routine to work.
*/
LRESULT CTxtEdit::HandleSetTextMode(
DWORD mode) //@parm the desired mode
{
LRESULT lres = 0;
// First off, we must be completely empty
if (GetAdjustedTextLength() ||
_pundo && _pundo->CanUndo() ||
_predo && _predo->CanUndo())
{
return E_UNEXPECTED;
}
// These bits are considered one at a time; thus the absence of
// any bits does _NOT_ imply any change in behavior.
// TM_RICHTEXT && TM_PLAINTEXT are mutually exclusive; they cannot
// be both set. Same goes for TM_SINGLELEVELUNDO / TM_MULTILEVELUNDO
// and TM_SINGLECODEPAGE / TM_MULTICODEPAGE
if((mode & (TM_RICHTEXT | TM_PLAINTEXT)) == (TM_RICHTEXT | TM_PLAINTEXT) ||
(mode & (TM_SINGLELEVELUNDO | TM_MULTILEVELUNDO)) ==
(TM_SINGLELEVELUNDO | TM_MULTILEVELUNDO) ||
(mode & (TM_SINGLECODEPAGE | TM_MULTICODEPAGE)) ==
(TM_SINGLECODEPAGE | TM_MULTICODEPAGE))
{
lres = E_INVALIDARG;
}
else if((mode & TM_PLAINTEXT) && IsRich())
lres = OnRichEditChange(FALSE);
else if((mode & TM_RICHTEXT) && !IsRich())
lres = OnRichEditChange(TRUE);
if(!lres)
{
if(mode & TM_SINGLELEVELUNDO)
{
if(!_pundo)
CreateUndoMgr(1, US_UNDO);
if(_pundo)
{
// We can 'Enable' single level mode as many times
// as we want, so no need to check for it before hand.
lres = ((CUndoStack *)_pundo)->EnableSingleLevelMode();
}
else
lres = E_OUTOFMEMORY;
}
else if(mode & TM_MULTILEVELUNDO)
{
// If there's no undo stack, no need to do anything,
// we're already in multi-level mode
if(_pundo && ((CUndoStack *)_pundo)->GetSingleLevelMode())
((CUndoStack *)_pundo)->DisableSingleLevelMode();
}
if(mode & TM_SINGLECODEPAGE)
_fSingleCodePage = TRUE;
else if(mode & TM_MULTICODEPAGE)
_fSingleCodePage = FALSE;
}
// We don't want this marked modified after this operation to make us
// work better in dialog boxes.
_fModified = FALSE;
return lres;
}
////////////////////////// Uniscribe Interface //////////////////////////////
/*
* GetUniscribe()
*
* @mfunc
* returns a pointer to the Uniscribe interface object
*
* @rdesc
* Ptr to Uniscribe interface
*/
extern BOOL g_fNoUniscribe;
CUniscribe* GetUniscribe()
{
if (g_pusp)
return g_pusp;
if (g_fNoUniscribe)
return NULL;
//Attempt to create the Uniscribe object, but make sure the
//OS is valid and that we can load the uniscribe DLL.
int cScripts;
//Find out if OS is valid, or if delay-load fails
if (!IsSupportedOS() || FAILED(ScriptGetProperties(NULL, &cScripts)))
{
g_fNoUniscribe = TRUE;
return NULL;
}
if (!g_pusp)
g_pusp = new CUniscribe();
AssertSz(g_pusp, "GetUniscribe(): Create Uniscribe object failed");
return g_pusp;
}
////////////////////////// Notification Manager //////////////////////////////
/*
* CTxtEdit::GetNotifyMgr()
*
* @mfunc
* returns a pointer to the notification manager (creating it if necessary)
*
* @rdesc
* Ptr to notification manager
*/
CNotifyMgr *CTxtEdit::GetNotifyMgr()
{
TRACEBEGIN(TRCSUBSYSEDIT, TRCSCOPEINTERN, "CTxtEdit::GetNotifyMgr");
return &_nm;
}
////////////////////////// Object Manager ///////////////////////////////////
/*
* CTxtEdit::GetObjectMgr()
*
* @mfunc
* returns a pointer to the object manager (creating if necessary)
*
* @rdesc
* pointer to the object manager
*/
CObjectMgr *CTxtEdit::GetObjectMgr()
{
TRACEBEGIN(TRCSUBSYSEDIT, TRCSCOPEINTERN, "CTxtEdit::GetObjectMgr");
if(!_pobjmgr)
_pobjmgr = new CObjectMgr();
return _pobjmgr;
}
////////////////////////////// Properties - Selection ////////////////////////////////
LONG CTxtEdit::GetSelMin() const
{
TRACEBEGIN(TRCSUBSYSEDIT, TRCSCOPEINTERN, "CTxtEdit::GetSelMin");
return _psel ? _psel->GetCpMin() : 0;
}
LONG CTxtEdit::GetSelMost() const
{
TRACEBEGIN(TRCSUBSYSEDIT, TRCSCOPEINTERN, "CTxtEdit::GetSelMost");
return _psel ? _psel->GetCpMost() : 0;
}
////////////////////////////// Properties - Text //////////////////////////////////////
LONG CTxtEdit::GetTextRange(
LONG cpFirst,
LONG cch,
TCHAR * pch)
{
TRACEBEGIN(TRCSUBSYSEDIT, TRCSCOPEINTERN, "CTxtEdit::GetTextRange");
#ifdef DEBUG
const LONG cchAsk = cch;
#endif
CTxtPtr tp(this, cpFirst);
LONG cchAdj = GetAdjustedTextLength();
if(--cch < 0 || cpFirst > cchAdj)
return 0;
cch = min(cch, cchAdj - cpFirst);
if(cch > 0)
{
cch = tp.GetText(cch, pch);
Assert(cch >= 0);
}
pch[cch] = TEXT('\0');
#ifdef DEBUG
if(cch != cchAsk - 1)
Tracef(TRCSEVINFO, "CTxtEdit::GetTextRange: only got %ld out of %ld", cch, cchAsk - 1);
#endif
return cch;
}
/*
* CTxtEdit::GetTextEx (pgt, pch)
*
* @mfunc
* Grabs text according to various params
*
* @rdesc
* Count of bytes gotten
*/
LONG CTxtEdit::GetTextEx(
GETTEXTEX *pgt, //@parm Info on what to get
TCHAR * pch) //@parm Where to put the text
{
LONG cb;
LONG cch;
LONG cchGet = GetAdjustedTextLength();
TCHAR * pchUse = pch;
CTxtPtr tp(this, 0);
CTempWcharBuf twcb;
if(pgt->flags & GT_SELECTION) // Get selected text
{
LONG cpMin, cpMost;
cch = GetSel()->GetRange(cpMin, cpMost);
cchGet = min(cch, cchGet - cpMin); // Don't include final EOP
tp.SetCp(cpMin);
}
if(pgt->codepage == (unsigned)-1) // Use default codepage
pgt->codepage = GetDefaultCodePage(EM_GETTEXTEX);
if(pgt->cb == (unsigned)-1) // Client says its buffer is big enuf
{
pgt->cb = cchGet + 1;
if(W32->IsFECodePage(pgt->codepage) || pgt->codepage == 1200)
pgt->cb += cchGet;
else if(pgt->codepage == CP_UTF8 && (_dwCharFlags & ~fASCII))
pgt->cb *= (_dwCharFlags & fABOVEX7FF) ? 3 : 2;
}
// Allocate a big buffer; make sure that we have
// enough room for lots of CRLFs if necessary
if(pgt->flags & GT_USECRLF)
cchGet *= 2;
if(pgt->codepage != 1200)
{
// If UNICODE, copy straight to client's buffer;
// else, copy to temp buffer and translate cases first
pchUse = twcb.GetBuf(cchGet + 1);
if (pch)
*((char *) pch) = '\0'; // In case something fails
}
else // Be sure to leave room for NULL terminator
cchGet = min(UINT(pgt->cb/2 - 1), (UINT)cchGet);
// Now grab the text.
if(pgt->flags & GT_USECRLF)
cch = tp.GetPlainText(cchGet, pchUse, tomForward, FALSE);
else
cch = tp.GetText(cchGet, pchUse);
pchUse[cch] = L'\0';
// If we're just doing UNICODE, return number of chars written
if(pgt->codepage == 1200)
return cch;
// Oops, gotta translate to ANSI.
cb = WideCharToMultiByte(pgt->codepage, 0, pchUse, cch + 1, (char *)pch,
pgt->cb, pgt->lpDefaultChar, pgt->lpUsedDefChar);
// Don't count NULL terminator for compatibility with WM_GETTEXT.
return (cb) ? cb - 1 : 0;
}
/*
* CTxtEdit::GetTextLengthEx (pgtl)
*
* @mfunc
* Calculates text length in various ways.
*
* @rdesc
* Text length calculated in various ways
*
* @comm
* This function returns an API cp that may differ from the
* corresponding internal Unicode cp.
*/
LONG CTxtEdit::GetTextLengthEx(
GETTEXTLENGTHEX *pgtl) //@parm Info describing how to calculate length
{
LONG cchUnicode = GetAdjustedTextLength();
LONG cEOP = 0;
DWORD dwFlags = pgtl->flags;
GETTEXTEX gt;
if(pgtl->codepage == (unsigned)-1)
pgtl->codepage = GetDefaultCodePage(EM_GETTEXTLENGTHEX);
// Make sure the flags are defined appropriately
if ((dwFlags & GTL_CLOSE) && (dwFlags & GTL_PRECISE) ||
(dwFlags & GTL_NUMCHARS) && (dwFlags & GTL_NUMBYTES))
{
TRACEWARNSZ("Invalid flags for EM_GETTEXTLENGTHEX");
return E_INVALIDARG;
}
// Note in the following if statement, the second part of the
// and clause will always be TRUE. At some point in the future
// fUseCRLF and Get10Mode may become independent, in which case
// the code below will automatically work without change.
// NEW: 1.0 mode gets text as is, so don't add count for CRs.
// (RichEdit 1.0 only inserts Enters as CRLFs; it doesn't "cleanse"
// other text insertion strings)
if((dwFlags & GTL_USECRLF) && !fUseCRLF() && !Get10Mode())
{
// Important facts for 1.0 mode (REMARK: this is out of date):
//
// (1) 1.0 mode implies that the text is stored with fUseCRLF true.
// fUseCRLF means that the EOP mark can either be a CR or a
// CRLF - see CTxtRange::CleanseAndReplaceRange for details.
//
// (2) 1.0 mode has an invariant that the count of text returned
// by this call should be enough to hold all the text returned by
// WM_GETTEXT.
//
// (3) The WM_GETEXT call for 1.0 mode will return a buffer in
// which all EOPs that consist of a CR are replaced by CRLF.
//
// Therefore, for 1.0 mode, we must count all EOPs that consist
// of only a CR and add addition return character to count the
// LF that will be added into any WM_GETEXT buffer.
// For 2.0 mode, the code is much easier, just count up all
// CRs and bump count of each one by 1.
CTxtPtr tp(this, 0);
LONG Results;
while(tp.FindEOP(tomForward, &Results))
{
// If EOP consists of 1 char, add 1 since is returned by a CRLF.
// If it consists of 2 chars, add 0, since it's a CRLF and is
// returned as such.
if(tp.GetCp() > cchUnicode) // Don't add correction for
break; // final CR (if any)
Results &= 3;
if(Results)
cEOP += 2 - Results;
AssertSz(IN_RANGE(1, Results, 2) || !Results && tp.GetCp() == cchUnicode,
"CTxtEdit::GetTextLengthEx: CRCRLF found in backing store");
}
cchUnicode += cEOP;
}
// If we're just looking for the number of characters or if it's an
// 8-bit codepage in RE 1.0 mode, we've already got the count.
if ((dwFlags & GTL_NUMCHARS) || !dwFlags ||
Get10Mode() && Is8BitCodePage(pgtl->codepage))
{
return cchUnicode;
}
// Hmm, they're looking for number of bytes, but don't care about
// precision, just multiply by two. If neither PRECISE or CLOSE is
// specified, default to CLOSE. Note if the codepage is UNICODE and
// asking for number of bytes, we also just multiply by 2.
if((dwFlags & GTL_CLOSE) || !(dwFlags & GTL_PRECISE) ||
pgtl->codepage == 1200)
{
return cchUnicode *2;
}
// In order to get a precise answer, we need to convert (which is slow!).
gt.cb = 0;
gt.flags = (pgtl->flags & GT_USECRLF);
gt.codepage = pgtl->codepage;
gt.lpDefaultChar = NULL;
gt.lpUsedDefChar = NULL;
return GetTextEx(&gt, NULL);
}
/*
* CTxtEdit::GetDefaultCodePage (msg)
*
* @mfunc
* Return codepage to use for converting the text in RichEdit20A text
* messages.
*
* @rdesc
* Codepage to use for converting the text in RichEdit20A text messages.
*/
LONG CTxtEdit::GetDefaultCodePage(
UINT msg)
{
LONG CodePage = GetACP();
// FUTURE: For backward compatibility in Office97, We always use ACP for all these
// languages. Need review in the future when the world all moves to Unicode.
if (W32->IsBiDiCodePage(CodePage) || CodePage == CP_THAI || CodePage == CP_VIETNAMESE ||
W32->IsFECodePage(CodePage) || _fSingleCodePage || msg == EM_GETCHARFORMAT ||
msg == EM_SETCHARFORMAT)
{
return CodePage;
}
if(Get10Mode())
return GetCodePage(GetCharFormat(-1)->_bCharSet);
return GetKeyboardCodePage();
}
////////////////////////////// Properties - Formats //////////////////////////////////
/*
* CTxtEdit::HandleStyle (pCFTarget, pCF, dwMask, dwMask2)
*
* @mfunc
* If pCF specifies a style choice, initialize pCFTarget with the
* appropriate style, apply pCF, and return NOERROR. Else return
* S_FALSE or an error
*
* @rdesc
* HRESULT = (pCF specifies a style choice) ? NOERROR : S_FALSE or error code
*/
HRESULT CTxtEdit::HandleStyle(
CCharFormat *pCFTarget, //@parm Target CF to receive CF style content
const CCharFormat *pCF, //@parm Source CF that may specify a style
DWORD dwMask, //@parm CHARFORMAT2 mask
DWORD dwMask2) //@parm Second mask
{
if(pCF->fSetStyle(dwMask, dwMask2))
{
// FUTURE: generalize to use client style if specified
*pCFTarget = *GetCharFormat(-1);
pCFTarget->ApplyDefaultStyle(pCF->_sStyle);
return pCFTarget->Apply(pCF, dwMask, dwMask2);
}
return S_FALSE;
}
/*
* CTxtEdit::HandleStyle (pPFTarget, pPF)
*
* @mfunc
* If pPF specifies a style choice, initialize pPFTarget with the
* appropriate style, apply pPF, and return NOERROR. Else return
* S_FALSE or an error
*
* @rdesc
* HRESULT = (pPF specifies a style choice) ? NOERROR : S_FALSE or error code
*/
HRESULT CTxtEdit::HandleStyle(
CParaFormat *pPFTarget, //@parm Target PF to receive PF style content
const CParaFormat *pPF, //@parm Source PF that may specify a style
DWORD dwMask) //@parm Mask to use in setting CParaFormat
{
if(pPF->fSetStyle(dwMask))
{
// FUTURE: generalize to use client style if specified
*pPFTarget = *GetParaFormat(-1);
pPFTarget->ApplyDefaultStyle(pPF->_sStyle);
return pPFTarget->Apply(pPF, dwMask);
}
return S_FALSE;
}
//////////////////////////// Mouse Commands /////////////////////////////////
HRESULT CTxtEdit::OnTxLButtonDblClk(
INT x, //@parm Mouse x coordinate
INT y, //@parm Mouse y coordinate
DWORD dwFlags) //@parm Mouse message wparam
{
TRACEBEGIN(TRCSUBSYSEDIT, TRCSCOPEINTERN, "CTxtEdit::OnTxLButtonDblClk");
BOOL fEnterParaSelMode = FALSE;
HITTEST Hit;
CTxtSelection * psel = GetSel();
const POINT pt = {x, y};
AssertSz(psel, "CTxtEdit::OnTxLButtonDblClk() - No selection object !");
if (StopMagellanScroll())
return S_OK;
_dwTickDblClick = GetTickCount();
_ptDblClick.x = x;
_ptDblClick.y = y;
TxUpdateWindow(); // Repaint window to show any exposed portions
if(!_fFocus)
{
TxSetFocus(); // Create and display caret
return S_OK;
}
// Find out what the cursor is pointing at
_pdp->CpFromPoint(pt, NULL, NULL, NULL, FALSE, &Hit);
if(Hit == HT_Nothing)
return S_OK;
if(Hit == HT_OutlineSymbol)
{
CTxtRange rg(*psel);
rg.ExpandOutline(0, FALSE);
return S_OK;
}
if(Hit == HT_LeftOfText)
fEnterParaSelMode = TRUE;
_fWantDrag = FALSE; // just to be safe
// If we are over a link, let the client have a chance to process
// the message
if(Hit == HT_Link && HandleLinkNotification(WM_LBUTTONDBLCLK, (WPARAM)dwFlags,
MAKELPARAM(x, y)))
{
return S_OK;
}
if(dwFlags & MK_CONTROL)
return S_OK;
// Mark mouse down
_fMouseDown = TRUE;
if(_pobjmgr && _pobjmgr->HandleDoubleClick(this, pt, dwFlags))
{
// The object subsystem handled everything
_fMouseDown = FALSE;
return S_OK;
}
// Update the selection
if(fEnterParaSelMode)
psel->SelectUnit(pt, tomParagraph);
else
psel->SelectWord(pt);
return S_OK;
}
HRESULT CTxtEdit::OnTxLButtonDown(
INT x, //@parm Mouse x coordinate
INT y, //@parm Mouse y coordinate
DWORD dwFlags) //@parm Mouse message wparam
{
TRACEBEGIN(TRCSUBSYSEDIT, TRCSCOPEINTERN, "CTxtEdit::OnTxLButtonDown");
BOOL fEnterLineSelMode = FALSE;
BOOL fShift = dwFlags & MK_SHIFT;
HITTEST Hit;
const POINT pt = {x, y};
COleObject *pobj;
BOOL fMustThaw = FALSE;
const BOOL fTripleClick = GetTickCount() < _dwTickDblClick + W32->GetDCT() &&
abs(x - _ptDblClick.x) <= W32->GetCxDoubleClk() &&
abs(y - _ptDblClick.y) <= W32->GetCyDoubleClk();
if (StopMagellanScroll())
return S_OK;
// If click isn't inside view, just activate, don't select
if(!_fFocus) // Sets focus if not already
{
// We may be removing an existing selection, so freeze
// display to avoid flicker
_pdp->Freeze();
fMustThaw = TRUE;
TxSetFocus(); // creates and displays caret
}
// Grab selection object
CTxtSelection * const psel = GetSel();
AssertSz(psel,"CTxtEdit::OnTxLButtonDown - No selection object !");
// Find out what cursor is pointing at
_pdp->CpFromPoint(pt, NULL, NULL, NULL, FALSE, &Hit);
if(Hit == HT_LeftOfText)
{
// Shift click in sel bar treated as normal click
if(!fShift)
{
// Control selbar click and triple selbar click
// are select all
if((dwFlags & MK_CONTROL) || fTripleClick)
{
psel->SelectAll();
goto cancel_modes;
}
fEnterLineSelMode = TRUE;
if(!GetAdjustedTextLength() && !_pdp->IsMultiLine())
{
const CParaFormat *pPF = psel->GetPF();
// Can't see selected para mark when flushed right, so
// leave selection as an insertion point
if(pPF->_bAlignment == PFA_RIGHT && !pPF->IsRtlPara())
fEnterLineSelMode = FALSE;
}
}
}
else if(Hit == HT_Nothing)
goto cancel_modes;
else if(!fShift)
psel->CancelModes();
// Let client have a chance to handle this message if we are over a link
if(Hit == HT_Link && HandleLinkNotification(WM_LBUTTONDOWN, (WPARAM)dwFlags,
MAKELPARAM(x, y)))
{
goto cancel_modes;
}
_fMouseDown = TRUE; // Flag mouse down
if(!fShift && _pobjmgr)
{
// Deactivate anybody active, etc.
ClickStatus status = _pobjmgr->HandleClick(this, pt);
if(status == CLICK_OBJSELECTED)
{
// The object subsystem will handle resizing.
// if not a resize we will signal start of drag
pobj = _pobjmgr->GetSingleSelect();
// Because HandleClick returned true, pobj better be non-null.
Assert(pobj);
if (!pobj->HandleResize(pt))
_fWantDrag = !_fDisableDrag;
goto cancel_modes;
}
else if(status == CLICK_OBJDEACTIVATED)
goto cancel_modes;
}
_fCapture = TRUE; // Capture the mouse
TxSetCapture(TRUE);
// Check for start of drag and drop
if(!fTripleClick && !fShift && psel->PointInSel(pt, NULL, Hit)
&& !_fDisableDrag)
{
// Assume we want a drag. If we don't CmdLeftUp() needs
// this to be set anyway to change the selection
_fWantDrag = TRUE;
goto cancel_modes;
}
if(fShift) // Extend selection from current
{ // active end to click
psel->InitClickForAutWordSel(pt);
psel->ExtendSelection(pt);
}
else if(fEnterLineSelMode) // Line selection mode: select line
psel->SelectUnit(pt, tomLine);
else if(fTripleClick || Hit == HT_OutlineSymbol) // paragraph selection mode
psel->SelectUnit(pt, tomParagraph);
else
{
if (Get10Mode())
_f10DeferChangeNotify = 1;
psel->SetCaret(pt);
_mousePt = pt;
}
if(fMustThaw)
_pdp->Thaw();
return S_OK;
cancel_modes:
psel->CancelModes();
if(_fWantDrag)
{
TxSetTimer(RETID_DRAGDROP, W32->GetDragDelay());
_mousePt = pt;
_bMouseFlags = (BYTE)dwFlags;
_fDragged = FALSE;
}
if(fMustThaw)
_pdp->Thaw();
return S_OK;
}
HRESULT CTxtEdit::OnTxLButtonUp(
INT x, //@parm Mouse x coordinate
INT y, //@parm Mouse y coordinate
DWORD dwFlags, //@parm Mouse message wparam
int ffOptions) //@parm Mouse options, see _edit.h for details
{
TRACEBEGIN(TRCSUBSYSEDIT, TRCSCOPEINTERN, "CTxtEdit::OnTxLButtonUp");
CheckRemoveContinuousScroll();
// Remove capture before test for mouse down since we wait till
// we get the mouse button up message to release capture since Forms
// wants it that way.
if(_fCapture && (ffOptions & LB_RELEASECAPTURE))
{
TxSetCapture(FALSE);
_fCapture = FALSE;
}
// we were delaying selection change. So send it now...
if (DelayChangeNotification() && (ffOptions & LB_FLUSHNOTIFY))
{
AssertSz(Get10Mode(), "Flag should only be set in 10 mode");
_f10DeferChangeNotify = 0;
GetCallMgr()->SetSelectionChanged();
}
if(!_fMouseDown)
{
// We noticed the mouse was no longer down earlier so we don't
// need to do anything.
return S_OK;
}
const BOOL fSetSel = !!_fWantDrag;
const POINT pt = {x, y};
// Cancel Auto Word Sel if on
CTxtSelection * const psel = GetSel();
AssertSz(psel,"CTxtEdit::OnLeftUp() - No selection object !");
psel->CancelModes(TRUE);
// Reset flags
_fMouseDown = FALSE;
_fWantDrag = FALSE;
_fDragged = FALSE;
TxKillTimer(RETID_DRAGDROP);
if(IsInOutlineView())
psel->Update(FALSE);
// Let the client handle this message if we are over a
// link area
if(HandleLinkNotification(WM_LBUTTONUP, (WPARAM)dwFlags,
MAKELPARAM(x, y)))
{
return NOERROR;
}
// If we were in drag & drop, put caret under mouse
if(fSetSel)
{
CObjectMgr* pobjmgr = GetObjectMgr();
// If we were on an object, don't deselect it by setting the caret
if(pobjmgr && !pobjmgr->GetSingleSelect())
{
psel->SetCaret(pt, TRUE);
if(!_fFocus)
TxSetFocus(); // create and display caret
}
}
return S_OK;
}
HRESULT CTxtEdit::OnTxRButtonUp(
INT x, //@parm Mouse x coordinate
INT y, //@parm Mouse y coordinate
DWORD dwFlags, //@parm Mouse message wparam
int ffOptions) //@parm option flag
{
const POINT pt = {x, y};
CTxtSelection * psel;
SELCHANGE selchg;
HMENU hmenu = NULL;
IOleObject * poo = NULL;
COleObject * pobj = NULL;
IUnknown * pUnk = NULL;
IRichEditOleCallback * precall = NULL;
TRACEBEGIN(TRCSUBSYSEDIT, TRCSCOPEINTERN, "CTxtEdit::OnTxRButtonUp");
// make sure we have the focus
if(!_fFocus)
TxSetFocus();
if(_fWantDrag)
{
_fDragged = FALSE;
_fWantDrag = FALSE;
TxKillTimer(RETID_DRAGDROP);
}
// Grab selection object
psel = GetSel();
psel->SetSelectionInfo(&selchg);
//We need a pointer to the first object, if any, in the selection.
if(_pobjmgr)
{
//If the point is in the selection we need to find out if there
//are any objects in the selection. If the point is not in a
//selection but it is on an object, we need to select the object.
if(psel->PointInSel(pt, NULL) || (ffOptions & RB_FORCEINSEL))
{
pobj = _pobjmgr->GetFirstObjectInRange(selchg.chrg.cpMin,
selchg.chrg.cpMost);
}
else
{
//Select the object
if(_pobjmgr->HandleClick(this, pt) == CLICK_OBJSELECTED)
{
pobj = _pobjmgr->GetSingleSelect();
// Because HandleClick returned true, pobj better be non-null.
Assert(pobj!=NULL);
//Refresh our information about the selection
psel = GetSel();
psel->SetSelectionInfo(&selchg);
}
}
precall = _pobjmgr->GetRECallback();
}
if(pobj)
pUnk = pobj->GetIUnknown();
if(pUnk)
pUnk->QueryInterface(IID_IOleObject, (void **)&poo);
if(precall)
precall->GetContextMenu(selchg.seltyp, poo, &selchg.chrg, &hmenu);
if(hmenu)
{
HWND hwnd, hwndParent;
POINT ptscr;
if(TxGetWindow(&hwnd) == NOERROR)
{
if(!(ffOptions & RB_NOSELCHECK) && !psel->PointInSel(pt, NULL) &&
!psel->GetCch() && !(ffOptions & RB_FORCEINSEL))
psel->SetCaret(pt);
ptscr.x = pt.x;
ptscr.y = pt.y;
ClientToScreen(hwnd, &ptscr);
hwndParent = GetParent(hwnd);
if(!hwndParent)
hwndParent = hwnd;
TrackPopupMenu(hmenu, TPM_LEFTALIGN | TPM_RIGHTBUTTON,
ptscr.x, ptscr.y, 0, hwndParent, NULL);
}
DestroyMenu(hmenu);
}
if(poo)
poo->Release();
return precall ? S_OK : S_FALSE;
}
HRESULT CTxtEdit::OnTxRButtonDown(
INT x, //@parm Mouse x coordinate
INT y, //@parm Mouse y coordinate
DWORD dwFlags) //@parm Mouse message wparam
{
TRACEBEGIN(TRCSUBSYSEDIT, TRCSCOPEINTERN, "CTxtEdit::OnTxRButtonDown");
if (StopMagellanScroll())
return S_OK;
CTxtSelection *psel = GetSel();
const POINT pt = {x, y};
psel->CancelModes();
if(psel->PointInSel(pt, NULL) && !_fDisableDrag)
{
_fWantDrag = TRUE;
TxSetTimer(RETID_DRAGDROP, W32->GetDragDelay());
_mousePt = pt;
_bMouseFlags = (BYTE)dwFlags;
_fDragged = FALSE;
return S_OK;
}
return S_FALSE;
}
HRESULT CTxtEdit::OnTxMouseMove(
INT x, //@parm Mouse x coordinate
INT y, //@parm Mouse y coordinate
DWORD dwFlags, //@parm Mouse message wparam
IUndoBuilder *publdr)
{
int dx, dy;
BOOL fLButtonDown = FALSE;
BOOL fRButtonDown = FALSE;
DWORD vkLButton, vkRButton;
TRACEBEGIN(TRCSUBSYSEDIT, TRCSCOPEINTERN, "CTxtEdit::OnTxMouseMove");
CTxtSelection * const psel = GetSel();
if(!_fFocus)
return S_OK;
if(_fWantDrag || _fCapture)
{
LONG nDragMinDist = W32->GetDragMinDist() + 3;
dx = _mousePt.x > x ? _mousePt.x - x : x - _mousePt.x;
dy = _mousePt.y > y ? _mousePt.y - y : y - _mousePt.y;
if(dx < nDragMinDist && dy < nDragMinDist)
{
_bMouseFlags = (BYTE)dwFlags;
return S_OK;
}
_fDragged = _fWantDrag;
}
_mousePt.x = x; // Remember for scrolling
_mousePt.y = y; // speed, and dir calc.
// RichEdit 1.0 allows the client to process mouse moves itself if
// we are over a link (but _not_ doing drag drop).
if(HandleLinkNotification(WM_MOUSEMOVE, 0, MAKELPARAM(x, y)))
return NOERROR;
// If we think the mouse is down and it really is then do special
// processing.
if(GetSystemMetrics(SM_SWAPBUTTON))
{
vkLButton = VK_RBUTTON;
vkRButton = VK_LBUTTON;
}
else
{
vkLButton = VK_LBUTTON;
vkRButton = VK_RBUTTON;
}
fLButtonDown = (GetAsyncKeyState(vkLButton) < 0);
if(!fLButtonDown)
fRButtonDown = (GetAsyncKeyState(vkRButton) < 0);
if(fLButtonDown || fRButtonDown)
{
if(_fWantDrag
&& !_fUsePassword
&& !IsProtected(_fReadOnly ? WM_COPY : WM_CUT, dwFlags,
MAKELONG(x,y)))
{
TxKillTimer(RETID_DRAGDROP);
_ldte.StartDrag(psel, publdr);
// the mouse button may still be down, but drag drop is over
// so we need to _think_ of it as up.
_fMouseDown = FALSE;
// similarly, OLE should have nuked the capture for us, but
// just in case something failed, release the capture.
TxSetCapture(FALSE);
_fCapture = FALSE;
}
else if(_fMouseDown)
{
POINT pt = _mousePt;
// We think mouse is down and it is
if(_ldte.fInDrag())
{
// Only do drag scrolling if a drag operation is in progress.
_pdp->DragScroll(&pt);
}
AssertSz(psel,"CTxtEdit::OnMouseMove: No selection object !");
psel->ExtendSelection(pt); // Extend the selection
CheckInstallContinuousScroll ();
}
}
else if (!(GetAsyncKeyState(VK_MBUTTON) < 0) && !mouse.IsAutoScrolling())
{
// Make sure we aren't autoscrolling via intellimouse
if(_fMButtonCapture)
OnTxMButtonUp (x, y, dwFlags);
if(_fMouseDown)
{
// Although we thought the mouse was down, at this moment it
// clearly is not. Therefore, we pretend we got a mouse up
// message and clear our state to get ourselves back in sync
// with what is really happening.
OnTxLButtonUp(x, y, dwFlags, LB_RELEASECAPTURE);
}
}
// Either a drag was started or the mouse button was not down. In either
// case, we want no longer to start a drag so we set the flag to false.
_fWantDrag = FALSE;
return S_OK;
}
/*
* OnTxMButtonDown (x, y, dwFlags)
*
* @mfunc
* The user pressed the middle mouse button, setup to do
* continuous scrolls, which may in turn initiate a timer
* for smooth scrolling.
*
* @rdesc
* HRESULT = S_OK
*/
HRESULT CTxtEdit::OnTxMButtonDown (
INT x, //@parm Mouse x coordinate
INT y, //@parm Mouse y coordinate
DWORD dwFlags) //@parm Mouse message wparam
{
TRACEBEGIN(TRCSUBSYSEDIT, TRCSCOPEINTERN, "CTxtEdit::OnTxMButtonDown");
#if !defined(NOMAGELLAN)
POINT mDownPt = {x,y};
if(!_fFocus)
TxSetFocus();
if(!StopMagellanScroll() && mouse.MagellanStartMButtonScroll(*this, mDownPt))
{
TxSetCapture(TRUE);
_fCapture = TRUE; // Capture the mouse
_fMouseDown = TRUE;
_fMButtonCapture = TRUE;
}
#endif
return S_OK;
}
/*
* CTxtEdit::OnTxMButtonUp (x, y, dwFlags)
*
* @mfunc
* Remove timers and capture assoicated with a MButtonDown
* message.
*
* @rdesc
* HRESULT = S_OK
*/
HRESULT CTxtEdit::OnTxMButtonUp (
INT x, //@parm Mouse x coordinate
INT y, //@parm Mouse y coordinate
DWORD dwFlags) //@parm Mouse message wparam
{
TRACEBEGIN(TRCSUBSYSEDIT, TRCSCOPEINTERN, "CTxtEdit::OnTxMButtonUp");
#if !defined(NOMAGELLAN)
if (mouse.ContinueMButtonScroll(x, y))
return S_OK;
StopMagellanScroll();
#else
if(_fCapture)
TxSetCapture(FALSE);
_fCapture = FALSE;
_fMouseDown = FALSE;
_fMButtonCapture = FALSE;
#endif
return S_OK;
}
/*
* CTxtEdit::StopMagellanScroll()
*
* @mfunc
* Stops the intellimouse autoscrolling and returns
* us back into a normal state
*
* BOOL = TRUE if auto scrolling was turned off : FALSE
* Autoscrolling was never turned on
*/
BOOL CTxtEdit::StopMagellanScroll ()
{
TRACEBEGIN(TRCSUBSYSEDIT, TRCSCOPEINTERN, "CTxtEdit::StopMagellanScroll");
#if !defined(NOMAGELLAN)
if (!mouse.IsAutoScrolling())
return FALSE;
mouse.MagellanEndMButtonScroll(*this);
if(_fCapture)
TxSetCapture(FALSE);
_fCapture = FALSE;
_fMouseDown = FALSE;
_fMButtonCapture = FALSE;
return TRUE;
#else
return FALSE;
#endif
}
/*
* CTxtEdit::CheckInstallContinuousScroll ()
*
* @mfunc
* There are no events that inform the app on a regular
* basis that a mouse button is down. This timer notifies
* the app that the button is still down, so that scrolling can
* continue.
*/
void CTxtEdit::CheckInstallContinuousScroll ()
{
TRACEBEGIN(TRCSUBSYSEDIT, TRCSCOPEINTERN, "CTxtEdit::CheckInstallContinuousScroll");
if(!_fContinuousScroll && TxSetTimer(RETID_AUTOSCROLL, cmsecScrollInterval))
_fContinuousScroll = TRUE;
}
/*
* CTxtEdit::CheckRemoveContinuousScroll ()
*
* @mfunc
* The middle mouse button, or drag button, is up
* remove the continuous scroll timer.
*/
void CTxtEdit::CheckRemoveContinuousScroll ()
{
TRACEBEGIN(TRCSUBSYSEDIT, TRCSCOPEINTERN, "CTxtEdit::CheckRemoveContinuousScroll");
if(_fContinuousScroll)
{
TxKillTimer(RETID_AUTOSCROLL);
_fContinuousScroll = FALSE;
}
}
/*
* OnTxTimer(idTimer)
*
* @mfunc
* Handle timers for doing background recalc and scrolling.
*
* @rdesc
* HRESULT = (idTimer valid) ? S_OK : S_FALSE
*/
HRESULT CTxtEdit::OnTxTimer(
UINT idTimer)
{
TRACEBEGIN(TRCSUBSYSEDIT, TRCSCOPEINTERN, "CTxtEdit::OnTxTimer");
switch (idTimer)
{
case RETID_BGND_RECALC:
_pdp->StepBackgroundRecalc();
break;
#if !defined(NOMAGELLAN)
case RETID_MAGELLANTRACK:
mouse.TrackUpdateMagellanMButtonDown(*this, _mousePt);
break;
#endif
case RETID_AUTOSCROLL: // Continuous scrolling.
OnTxMouseMove(_mousePt.x, _mousePt.y, // Do a select drag scroll.
0, NULL);
break;
#if !defined(NOMAGELLAN)
case RETID_SMOOTHSCROLL: // Smooth scrolling
if(_fMButtonCapture) // HACK, only 1 timer!
{ // delivered on Win95
// when things get busy.
mouse.TrackUpdateMagellanMButtonDown(*this, _mousePt);
}
if(_pdp->IsSmoothVScolling()) // Test only because of
_pdp->SmoothVScrollUpdate(); // above HACK!!
break;
#endif
case RETID_DRAGDROP:
TxKillTimer(RETID_DRAGDROP);
if (_fWantDrag && _fDragged && !_fUsePassword &&
!IsProtected(_fReadOnly ? WM_COPY : WM_CUT,
_bMouseFlags, MAKELONG(_mousePt.x,_mousePt.y)))
{
IUndoBuilder * publdr;
CGenUndoBuilder undobldr(this, UB_AUTOCOMMIT, &publdr);
_ldte.StartDrag(GetSel(), publdr);
_fWantDrag = FALSE;
_fDragged = FALSE;
TxSetCapture(FALSE);
_fCapture = FALSE;
}
break;
default:
return S_FALSE;
}
return S_OK;
}
/////////////////////////// Keyboard Commands ////////////////////////////////
/*
* CTxtEdit::OnTxKeyDown(vkey, dwFlags, publdr)
*
* @mfunc
* Handle WM_KEYDOWN message
*
* @rdesc
* HRESULT with the following values:
*
* S_OK if key was understood and consumed
* S_MSG_KEY_IGNORED if key was understood, but not consumed
* S_FALSE if key was not understood or just looked at
* and in any event not consumed
*/
HRESULT CTxtEdit::OnTxKeyDown(
WORD vkey, //@parm Virtual key code
DWORD dwFlags, //@parm lparam of WM_KEYDOWN msg
IUndoBuilder *publdr) //@parm Undobuilder to receive antievents
{
TRACEBEGIN(TRCSUBSYSEDIT, TRCSCOPEINTERN, "CTxtEdit::OnTxKeyDown");
if(IN_RANGE(VK_SHIFT, vkey, VK_MENU))
{
SetKeyboardFlag(GetKbdFlags(vkey, dwFlags));
return S_FALSE;
}
BOOL fAlt = GetKeyboardFlag(ALT, VK_MENU);
BOOL fCtrl = GetKeyboardFlag(CTRL, VK_CONTROL);
BOOL fShift = GetKeyboardFlag(SHIFT, VK_SHIFT);
BOOL fRet = FALSE; // Converted to HRESULT on return
LONG nDeadKey = 0;
if(fCtrl & fShift) // Signal NonCtrl/Shift keydown
SetKeyboardFlag(LETAFTERSHIFT); // while Ctrl&Shift are down
// Handle Hebrew caps and LRM/RLM
if (IsBiDi())
{
if (W32->IsBiDiCodePage(GetKeyboardCodePage(0xFFFFFFFF)))
{
_fHbrCaps = FALSE;
if(IsRich() && W32->UsingHebrewKeyboard())
{
WORD wCapital = GetKeyState(VK_CAPITAL);
_fHbrCaps = ((wCapital & 1) ^ fShift) &&
!(wCapital & 0x0080) &&
IN_RANGE('A', vkey, 'Z');
if(_fHbrCaps)
W32->ActivateKeyboard(ANSI_INDEX);
}
}
if(vkey == VK_BACK && fShift && W32->OnWin9x())
{
// Shift+Backspace generates a LRM | RLM on a BiDi keyboard.
// Consequently, we must eat the Backspace lest it delete text.
W32->_fLRMorRLM = 1;
return S_OK;
}
}
// If dragging or Alt key down, just look for ESCAPE. Note: if Alt key is
// down, we should never come here (would generate WM_SYSKEYDOWN message).
if(_fMouseDown)
{
if(vkey == VK_ESCAPE)
{
// Turn-off autoscroll.
if (StopMagellanScroll())
return S_OK;
POINT pt;
// Cancel drag select or drag & drop
GetCursorPos(&pt);
OnTxLButtonUp(pt.x, pt.y, 0, LB_RELEASECAPTURE | LB_FLUSHNOTIFY);
return S_OK;
}
return OnTxSpecialKeyDown(vkey, dwFlags, publdr);
}
CTxtSelection * const psel = GetSel();
AssertSz(psel,"CTxtEdit::OnKeyDown() - No selection object !");
if(fCtrl)
{
if(OnTxSpecialKeyDown(vkey, dwFlags, publdr) == S_OK)
return S_OK;
if(fAlt) // This following code doesn't handle
return S_FALSE; // use Ctrl+Alt, which happens for
// AltGr codes (no WM_SYSKEYDOWN)
// Shift must not be pressed for these.
if(!fShift)
{
switch(vkey)
{
case 'E':
case 'J':
case 'R':
case 'L':
{
CParaFormat PF;
if (vkey == 'E')
PF._bAlignment = PFA_CENTER;
else if (vkey == 'J')
PF._bAlignment = PFA_FULL_INTERWORD;
else if (vkey == 'R')
PF._bAlignment = PFA_RIGHT;
else
PF._bAlignment = PFA_LEFT;
psel->SetParaFormat(&PF, publdr, PFM_ALIGNMENT);
break;
}
case '1':
case '2':
case '5':
{
CParaFormat PF;
PF._bLineSpacingRule = tomLineSpaceMultiple;
PF._dyLineSpacing = (vkey - '0') * 20;
if (vkey == '5')
PF._dyLineSpacing = 30;
psel->SetParaFormat(&PF, publdr, PFM_LINESPACING);
break;
}
default:
break;
}
}
switch(vkey)
{
case VK_TAB:
return OnTxChar(VK_TAB, dwFlags, publdr);
case VK_CLEAR:
case VK_NUMPAD5:
case 'A': // Ctrl-A => pselect all
psel->SelectAll();
break;
//Toggle Subscript
case 187: // =
{
ITextFont *pfont;
psel->GetFont(&pfont);
if (pfont)
{
pfont->SetSubscript(tomToggle);
pfont->Release();
}
}
break;
case 'C': // Ctrl-C => copy
CtrlC: CutOrCopySelection(WM_COPY, 0, 0, NULL);
break;
case 'V': // Ctrl-V => paste
CtrlV: if(IsntProtectedOrReadOnly(WM_PASTE, 0, 0))
{
PasteDataObjectToRange(NULL, (CTxtRange *)psel, 0, NULL,
publdr, PDOR_NONE);
}
break;
case 'X': // Ctrl-X => cut
CtrlX: CutOrCopySelection(WM_CUT, 0, 0, publdr);
break;
case 'Z': // Ctrl-Z => undo
if (_pundo && !_fReadOnly && _fUseUndo)
PopAndExecuteAntiEvent(_pundo, 0);
break;
case 'Y': // Ctrl-Y => redo
if(_predo && !_fReadOnly && _fUseUndo)
PopAndExecuteAntiEvent(_predo, 0);
break;
#ifdef DEBUG
void RicheditDebugCentral(void);
case 191:
RicheditDebugCentral();
break;
#endif
#if defined(DOGFOOD)
case '1': // Shift+Ctrl+1 => start Aimm
// Activate AIMM by posting a message to RE (Shift+Ctrl+; for now)
if (fShift && _fInOurHost)
{
HWND hWnd;
TxGetWindow( &hWnd );
if (hWnd)
PostMessage(hWnd, EM_SETEDITSTYLE, SES_USEAIMM, SES_USEAIMM);
}
break;
#endif
case VK_CONTROL:
goto cont;
// English keyboard defines
#define VK_APOSTROPHE 0xDE
#define VK_GRAVE 0xC0
#define VK_SEMICOLON 0xBA
#define VK_COMMA 0xBC
case VK_APOSTROPHE:
if(fShift)
g_wFlags ^= KF_SMARTQUOTES;
else
nDeadKey = ACCENT_ACUTE;
break;
case VK_GRAVE:
nDeadKey = fShift ? ACCENT_TILDE : ACCENT_GRAVE;
break;
case VK_SEMICOLON:
nDeadKey = ACCENT_UMLAUT;
break;
case '6':
if(!fShift)
goto cont;
nDeadKey = ACCENT_CARET;
break;
case VK_COMMA:
nDeadKey = ACCENT_CEDILLA;
break;
default:
goto cont;
}
if(nDeadKey)
{
// Since deadkey choices vary a bit according to keyboard, we
// only enable them for English. French, German, Italian, and
// Spanish keyboards already have a fair amount of accent
// capability.
if(PRIMARYLANGID(GetKeyboardLayout(0)) == LANG_ENGLISH)
SetDeadKey((WORD)nDeadKey);
else goto cont;
}
return S_OK;
}
cont:
psel->SetExtend(fShift);
switch(vkey)
{
case VK_BACK:
case VK_F16:
if(_fReadOnly)
{
Beep();
fRet = TRUE;
}
else if(IsntProtectedOrReadOnly(WM_KEYDOWN, VK_BACK, dwFlags))
{
fRet = psel->Backspace(fCtrl, publdr);
}
break;
case VK_INSERT: // Ins
if(fShift) // Shift-Ins
goto CtrlV; // Alias for Ctrl-V
if(fCtrl) // Ctrl-Ins
goto CtrlC; // Alias for Ctrl-C
if(!_fReadOnly) // Ins
_fOverstrike = !_fOverstrike; // Toggle Ins/Ovr
fRet = TRUE;
break;
case VK_LEFT: // Left arrow
case VK_RIGHT: // Right arrow
fRet = (vkey == VK_LEFT) ^ (psel->GetPF()->IsRtlPara() != 0)
? psel->Left (fCtrl)
: psel->Right(fCtrl);
break;
case VK_UP: // Up arrow
fRet = psel->Up(fCtrl);
break;
case VK_DOWN: // Down arrow
fRet = psel->Down(fCtrl);
break;
case VK_HOME: // Home
fRet = psel->Home(fCtrl);
break;
case VK_END: // End
fRet = psel->End(fCtrl);
break;
case VK_PRIOR: // PgUp
// If SystemEditMode and control is single-line, do nothing
if(!_fSystemEditMode || _pdp->IsMultiLine())
fRet = psel->PageUp(fCtrl);
break;
case VK_NEXT: // PgDn
// If SystemEditMode and control is single-line, do nothing
if(!_fSystemEditMode || _pdp->IsMultiLine())
fRet = psel->PageDown(fCtrl);
break;
case VK_DELETE: // Del
if(fShift) // Shift-Del
goto CtrlX; // Alias for Ctrl-X
if(IsntProtectedOrReadOnly(WM_KEYDOWN, VK_DELETE, dwFlags))
psel->Delete(fCtrl, publdr);
fRet = TRUE;
break;
case CONTROL('J'): // Ctrl-Return gives Ctrl-J
case VK_RETURN: // (LF), treat it as return
// If we are in 1.0 mode we need to handle <CR>'s on WM_CHAR
if (!Get10Mode())
{
if(!_pdp->IsMultiLine())
{
Beep();
return S_FALSE;
}
TxSetCursor(0, NULL);
if(IsntProtectedOrReadOnly(WM_CHAR, VK_RETURN, dwFlags))
psel->InsertEOP(publdr, (fShift && IsRich() ? VT : 0));
fRet = TRUE;
}
break;
default:
return S_FALSE;
}
return fRet ? S_OK : S_MSG_KEY_IGNORED;
}
/*
* CTxtEdit::CutOrCopySelection(msg, wparam, lparam, publdr)
*
* @mfunc
* Handle WM_COPY message and its keyboard hotkey aliases
*
* @rdesc
* HRESULT
*/
HRESULT CTxtEdit::CutOrCopySelection(
UINT msg, //@parm Message (WM_CUT or WM_COPY)
WPARAM wparam, //@parm Message wparam for protection check
LPARAM lparam, //@parm Message lparam for protection check
IUndoBuilder *publdr) //@parm Undobuilder to receive antievents
{
Assert(msg == WM_CUT || msg == WM_COPY);
if(!_fUsePassword && IsntProtectedOrReadOnly(msg, wparam, lparam))
{
CTxtSelection *psel = GetSel();
psel->CheckTableSelection();
return msg == WM_COPY
? _ldte.CopyRangeToClipboard((CTxtRange *)psel)
: _ldte.CutRangeToClipboard((CTxtRange *)psel, publdr);
}
return NOERROR;
}
#define ENGLISH_UK MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_UK)
#define ENGLISH_EIRE MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_EIRE)
/*
* CTxtEdit::OnTxSpecialKeyDown(vkey, dwFlags, publdr)
*
* @mfunc
* Handle WM_KEYDOWN message for outline mode
*
* @rdesc
* HRESULT with the following values:
*
* S_OK if key was understood and consumed
* S_MSG_KEY_IGNORED if key was understood, but not consumed
* S_FALSE if key was not understood (and not consumed)
*/
HRESULT CTxtEdit::OnTxSpecialKeyDown(
WORD vkey, //@parm Virtual key code
DWORD dwFlags, //@parm lparam of WM_KEYDOWN msg
IUndoBuilder *publdr) //@parm Undobuilder to receive antievents
{
TRACEBEGIN(TRCSUBSYSEDIT, TRCSCOPEINTERN, "CTxtEdit::OnTxSpecialKeyDown");
HRESULT hr = S_FALSE; // Key not understood yet
DWORD dwKbdFlags = GetKeyboardFlags();
BOOL fUpdateFormat = TRUE;
if(!(dwKbdFlags & (CTRL | ALT))) // All hot keys here have at
return S_FALSE; // least Ctrl or Alt
CTxtSelection * const psel = GetSel();
if(dwKbdFlags & ALT && dwKbdFlags & CTRL)
{
// AltGr generates LCTRL | RALT, so don't match hot keys with
// that combination
if(dwKbdFlags & LCTRL && dwKbdFlags & RALT)
return S_FALSE;
//#if 0
// First they say they want it, then they don't. Leave it ifdef'd out
// for a bit in case they want it again
if(vkey == 'E')
{
LANGID lid = LANGIDFROMLCID(GetKeyboardLayout(0));
static const LANGID rgLangID[] =
{
ENGLISH_UK, ENGLISH_EIRE, LANG_POLISH, LANG_PORTUGUESE,
LANG_HUNGARIAN, LANG_VIETNAMESE
};
for(LONG i = ARRAY_SIZE(rgLangID); i--; )
{
// Don't insert Euro if lid matches any LIDs or PLIDs in rgLangID
if(lid == rgLangID[i] || PRIMARYLANGID(lid) == rgLangID[i])
return S_FALSE;
}
if(psel->PutChar(EURO, _fOverstrike, publdr))
{
SetKeyboardFlag(HOTEURO); // Setup flag to eat the next WM_CHAR w/ EURO
hr = S_OK;
}
}
else
//#endif
if(dwKbdFlags & SHIFT)
switch(vkey)
{
#ifdef ENABLE_OUTLINEVIEW
// FUTURE: OutlineView hot keys postponed (see below)
case 'N': // Alt-Ctrl-N => Normal View
hr = SetViewKind(VM_NORMAL);
break;
case 'O': // Alt-Ctrl-O => Outline View
hr = SetViewKind(VM_OUTLINE);
break;
#endif
case VK_F12: // Alt-Ctrl-F12 (in case Alt-X taken)
hr = psel->HexToUnicode(publdr);
break;
#if defined(DEBUG)
case VK_F11: // Alt-Ctrl-F11
if (W32->fDebugFont())
psel->DebugFont();
break;
#endif
}
return hr;
}
AssertSz(psel, "CTxtEdit::OnTxSpecialKeyDown() - No selection object !");
CTxtRange rg(*psel);
if(!IsRich() || !_pdp->IsMultiLine() || !(dwKbdFlags & SHIFT))
return S_FALSE;
if(dwKbdFlags & ALT) // Alt+Shift hot keys
{
// NB: Alt and Shift-Alt with _graphics_ characters generate a
// WM_SYSCHAR, which see
#ifdef ENABLE_OUTLINEVIEW
// FUTURE: These are Outline related hot keys. We will postpone these features
// since we have several bugs related to these hot keys
// Bug 5687, 5689, & 5691
switch(vkey)
{
case VK_LEFT: // Left arrow
case VK_RIGHT: // Right arrow
hr = rg.Promote(vkey == VK_LEFT ? 1 : -1, publdr);
psel->Update_iFormat(-1);
psel->Update(FALSE);
break;
case VK_UP: // Up arrow
case VK_DOWN: // Down arrow
hr = MoveSelection(vkey == VK_UP ? -1 : 1, publdr);
psel->Update(TRUE);
break;
}
#endif
return hr;
}
Assert(dwKbdFlags & CTRL && dwKbdFlags & SHIFT);
// Ctrl+Shift hot keys
switch(vkey)
{
#ifdef ENABLE_OUTLINEVIEW
// FUTUTRE: These are Outline related hot keys. We will postpone these features
// since we have several bugs related to these hot keys
// Bug 5687, 5689, & 5691
case 'N': // Demote to Body
hr = rg.Promote(0, publdr);
break;
#endif
//Toggle superscript
case 187: // =
{
ITextFont *pfont;
psel->GetFont(&pfont);
if (pfont)
{
pfont->SetSuperscript(tomToggle);
pfont->Release();
hr = S_OK;
fUpdateFormat = FALSE;
}
break;
}
case 'A':
{
ITextFont *pfont;
psel->GetFont(&pfont);
if (pfont)
{
pfont->SetAllCaps(tomToggle);
pfont->Release();
hr = S_OK;
fUpdateFormat = FALSE;
}
break;
}
case 'L': // Fiddle bullet style
{
CParaFormat PF;
DWORD dwMask = PFM_NUMBERING | PFM_OFFSET;
PF._wNumbering = psel->GetPF()->_wNumbering + 1;
PF._wNumbering %= tomListNumberAsUCRoman + 1;
PF._dxOffset = 0;
if(PF._wNumbering)
{
dwMask |= PFM_NUMBERINGSTYLE | PFM_NUMBERINGSTART;
PF._wNumberingStyle = PFNS_PERIOD;
PF._wNumberingStart = 1;
PF._dxOffset = 360;
}
hr = psel->SetParaFormat(&PF, publdr, dwMask);
break;
}
#define VK_RANGLE 190
#define VK_LANGLE 188
case VK_RANGLE: // '>' on US keyboards
case VK_LANGLE: // '<' on US keyboards
hr = OnSetFontSize(vkey == VK_RANGLE ? 1 : -1, publdr)
? S_OK : S_FALSE;
fUpdateFormat = (hr == S_FALSE);
break;
}
if(hr != S_FALSE)
{
if (fUpdateFormat)
psel->Update_iFormat(-1);
psel->Update(FALSE);
}
return hr;
}
/*
* CTxtEdit::OnTxChar (vkey, dwFlags, publdr)
*
* @mfunc
* Handle WM_CHAR message
*
* @rdesc
* HRESULT with the following values:
*
* S_OK if key was understood and consumed
* S_MSG_KEY_IGNORED if key was understood, but not consumed
* S_FALSE if key was not understood (and not consumed)
*/
HRESULT CTxtEdit::OnTxChar(
WORD vkey, //@parm Translated key code
DWORD dwFlags, //@parm lparam of WM_KEYDOWN msg
IUndoBuilder *publdr) //@parm Undobuilder to receive antievents
{
TRACEBEGIN(TRCSUBSYSEDIT, TRCSCOPEINTERN, "CTxtEdit::OnTxChar");
// Reset Alt key state if needed
if (!(HIWORD(dwFlags) & KF_ALTDOWN))
ResetKeyboardFlag(ALT);
DWORD dwFlagsPutChar = _fOverstrike | KBD_CHAR;
if(GetKeyboardFlags() & ALTNUMPAD)
{
DWORD Number = GetKeyPadNumber();
if(Number >= 256 || vkey >= 256)
vkey = Number;
ResetKeyboardFlag(ALTNUMPAD | ALT0);
dwFlagsPutChar &= ~KBD_CHAR; // Need font binding
}
if (_fMouseDown || vkey == VK_ESCAPE || // Ctrl-Backspace generates VK_F16
vkey == VK_BACK || vkey==VK_F16) // Eat it since we process it
{ // in WM_KEYDOWN
return S_OK;
}
CTxtSelection * const psel = GetSel();
AssertSz(psel,
"CTxtEdit::OnChar() - No selection object !");
psel->SetExtend(FALSE); // Shift doesn't mean extend for
// WM_CHAR
if(_fReadOnly && vkey != 3) // Don't allow input if read only,
{ // but allow copy (Ctrl-C)
if(vkey >= ' ')
Beep();
return S_MSG_KEY_IGNORED;
}
if(vkey >= ' ' || vkey == VK_TAB)
{
TxSetCursor(0, NULL);
if(IsntProtectedOrReadOnly(WM_CHAR, vkey, dwFlags))
{
LONG nDeadKey = GetDeadKey();
if(nDeadKey)
{
LONG ch = vkey | 0x20; // Convert to lower case
BOOL fShift = vkey != ch; // (if ASCII letter)
// a b c d e f g h i j
const static WORD chOff[] = {0xDF, 0, 0xE7, 0, 0xE7, 0, 0, 0, 0xEB, 0,
// k l m n o p q r s t u
0, 0, 0, 0xF1, 0xF1, 0, 0, 0, 0, 0, 0xF8};
SetDeadKey(0);
if(!IN_RANGE('a', ch, 'u')) // Not relevant ASCII
return S_OK; // letter
vkey = chOff[ch - 'a']; // Translate to base char
if(!vkey) // No accents available
return S_OK; // in current approach
if(ch == 'n')
{
if(nDeadKey != ACCENT_TILDE)
return S_OK;
}
else if(nDeadKey == ACCENT_CEDILLA)
{
if(ch != 'c')
return S_OK;
}
else // aeiou
{
vkey += (WORD)nDeadKey;
if (nDeadKey >= ACCENT_TILDE && // eiu with ~ or :
(vkey == 0xF0 || vkey & 8))
{
if(nDeadKey != ACCENT_UMLAUT)// Only have umlauts
return S_OK;
vkey--;
}
}
if(fShift)
vkey &= ~0x20;
}
// need to check if character is LRM | RLM character, if so
// then convert vkey
if (W32->_fLRMorRLM && IsBiDi() && IN_RANGE(0xFD, vkey, 0xFE))
{
vkey = LTRMARK + (vkey - 0xFD);
}
psel->PutChar((TCHAR)vkey, dwFlagsPutChar, publdr);
}
}
else if (Get10Mode() && (vkey == VK_RETURN || vkey == CONTROL('J')))
{
// 1.0 handled <CR> on WM_CHAR
// Just make sure we are entering text into a multiline control
DWORD dwStyle;
GetHost()->TxGetPropertyBits(TXTBIT_MULTILINE, &dwStyle);
if(dwStyle & TXTBIT_MULTILINE)
{
TxSetCursor(0, NULL);
if(IsntProtectedOrReadOnly(WM_CHAR, VK_RETURN, dwFlags))
psel->InsertEOP(publdr);
}
}
if(_fHbrCaps)
{
W32->ActivateKeyboard(HEBREW_INDEX);
_fHbrCaps = FALSE;
}
return S_OK;
}
/*
* CTxtEdit::OnTxSysChar (vkey, dwFlags, publdr)
*
* @mfunc
* Handle WM_SYSCHAR message
*
* @rdesc
* HRESULT with the following values:
*
* S_OK if key was understood and consumed
* S_MSG_KEY_IGNORED if key was understood, but not consumed
* S_FALSE if key was not understood (and not consumed)
*/
HRESULT CTxtEdit::OnTxSysChar(
WORD vkey, //@parm Translated key code
DWORD dwFlags, //@parm lparam of WM_KEYDOWN msg
IUndoBuilder *publdr) //@parm Undobuilder to receive antievents
{
if(!(HIWORD(dwFlags) & KF_ALTDOWN))
return S_FALSE;
BOOL fWholeDoc = TRUE;
HRESULT hr = S_FALSE;
int level = 0;
CTxtSelection * const psel = GetSel();
switch(vkey)
{
case VK_BACK:
return S_OK;
case 'x':
hr = psel->HexToUnicode(publdr);
break;
case 'X':
hr = psel->UnicodeToHex(publdr);
break;
case '+':
case '-':
level = vkey == VK_ADD ? 1 : -1;
fWholeDoc = FALSE;
/* Fall through */
case 'A':
case '1':
case '2':
case '3':
case '4':
case '5':
case '6':
case '7':
case '8':
case '9':
{
CTxtRange rg(*psel);
if(!level)
level = vkey == 'A' ? 9 : vkey - '0';
return rg.ExpandOutline(level, fWholeDoc);
}
}
return hr;
}
HRESULT CTxtEdit::OnTxSysKeyDown(
WORD vkey, //@parm Virtual key code
DWORD dwFlags, //@parm lparam of WM_KEYDOWN msg
IUndoBuilder *publdr) //@parm Undobuilder to receive antievents
{
TRACEBEGIN(TRCSUBSYSEDIT, TRCSCOPEINTERN, "CTxtEdit::OnTxSysKeyDown");
if(IN_RANGE(VK_SHIFT, vkey, VK_MENU))
{
SetKeyboardFlag(GetKbdFlags(vkey, dwFlags));
SetKeyPadNumber(0); // Init keypad number to 0
return S_FALSE;
}
if (StopMagellanScroll())
return S_FALSE;
HRESULT hr = OnTxSpecialKeyDown(vkey, dwFlags, publdr);
if(hr != S_FALSE)
return hr;
if(vkey == VK_BACK && (HIWORD(dwFlags) & KF_ALTDOWN))
{
if(_pundo && _pundo->CanUndo() && _fUseUndo)
{
if(PopAndExecuteAntiEvent(_pundo, 0) != NOERROR)
hr = S_MSG_KEY_IGNORED;
}
else
Beep();
}
else if(vkey == VK_F10 && // F10
!(HIWORD(dwFlags) & KF_REPEAT) && // Key previously up
(GetKeyboardFlags() & SHIFT)) // Shift is down
{
HandleKbdContextMenu();
}
return hr;
}
/////////////////////////////// Other system events //////////////////////////////
HRESULT CTxtEdit::OnContextMenu(LPARAM lparam)
{
TRACEBEGIN(TRCSUBSYSEDIT, TRCSCOPEINTERN, "CTxtEdit::OnContextMenu");
POINT pt;
pt.x = LOWORD(lparam);
pt.y = HIWORD(lparam);
if(TxScreenToClient(&pt))
return OnTxRButtonUp(pt.x, pt.y, 0, RB_NOSELCHECK);
return S_FALSE;
}
/*
* CTxtEdit::HandleKbdContextMenu ()
*
* @mfunc decides where to put the context menu on the basis of where the
* the selection is. Useful for shift-F10 and VK_APPS, where
* we aren't given a location.
*/
void CTxtEdit::HandleKbdContextMenu()
{
POINT pt;
RECT rc;
const CTxtSelection * const psel = GetSel();
int RbOption = RB_DEFAULT;
// Figure out where selection ends and put context menu near it
if(_pdp->PointFromTp(*psel, NULL, FALSE, pt, NULL, TA_TOP) < 0)
return;
// Due to various factors, the result of PointFromTp doesn't land
// in the selection in PointInSel. Therefore, we send in an override
// here if the selection is non-degenerate and to force the result
// and thus have the correct context menu appear.
LONG cpMin;
LONG cpMost;
psel->GetRange(cpMin, cpMost);
if (cpMin != cpMost)
{
RbOption = RB_FORCEINSEL;
}
// Make sure point is still within bounds of edit control
_pdp->GetViewRect(rc);
if (pt.x < rc.left)
pt.x = rc.left;
if (pt.x > rc.right - 2)
pt.x = rc.right - 2;
if (pt.y < rc.top)
pt.y = rc.top;
if (pt.y > rc.bottom - 2)
pt.y = rc.bottom - 2;
OnTxRButtonUp(pt.x, pt.y, 0, RbOption);
}
/////////////////////////////// Format Range Commands //////////////////////////////
/*
* CTxtEdit::OnFormatRange (pfr, prtcon, hdcMeasure,
* xMeasurePerInch, yMeasurePerInch)
* @mfunc
* Format the range given by pfr
*
* @comm
* This function inputs API cp's that may differ from the
* corresponding internal Unicode cp's.
*/
LRESULT CTxtEdit::OnFormatRange(
FORMATRANGE * pfr,
SPrintControl prtcon,
BOOL fSetupDC)
{
TRACEBEGIN(TRCSUBSYSEDIT, TRCSCOPEINTERN, "CTxtEdit::OnFormatRange");
LONG cpMin = 0;
LONG cpMost = 0;
if(pfr)
{
cpMin = GetCpFromAcp(pfr->chrg.cpMin);
cpMost = GetCpFromAcp(pfr->chrg.cpMost);
}
// Even if there is 0 text, we want to print the control so that it will
// fill the control with background color.
// Use Adjusted Text Length. Embedded objects using RichEdit will get the empty
// document they expect and will create a default size document.
if(!pfr || cpMin >= GetAdjustedTextLength() &&
!prtcon._fPrintFromDraw)
{ // We're done formatting, get rid of our printer's display context.
delete _pdpPrinter;
_pdpPrinter = NULL;
return GetAcpFromCp(GetAdjustedTextLength());
}
LONG cpReturn = -1;
BOOL fSetDCWorked = FALSE;
// Fix MFC Print preview in mirrored control
//
// MFC CPreviewView sends us a mirrored rendering DC. We need to disable
// this mirroring effect so our internal state remains consistent with user
// action. We also need to disable mirrored window mode in CPreviewView
// window. [wchao - 4/9/1999]
//
HDC hdcLocal = pfr->hdc;
DWORD dwLayout = GetLayout(hdcLocal);
if (dwLayout & LAYOUT_RTL)
{
HWND hwndView = WindowFromDC(hdcLocal);
if (hwndView)
{
DWORD dwExStyleView = GetWindowLong(hwndView, GWL_EXSTYLE);
if (dwExStyleView & WS_EX_LAYOUTRTL)
SetWindowLong(hwndView, GWL_EXSTYLE, dwExStyleView & ~WS_EX_LAYOUTRTL);
}
SetLayout(hdcLocal, 0);
}
// First time in with this printer, set up a new display context.
// IMPORTANT: proper completion of the printing process is required
// to dispose of this context and begin a new context.
// This is implicitly done by printing the last character, or
// sending an EM_FORMATRANGE message with pfr equal to NULL.
if(!_pdpPrinter)
{
_pdpPrinter = new CDisplayPrinter (this, hdcLocal,
pfr->rc.right - pfr->rc.left, // x width max
pfr->rc.bottom - pfr->rc.top, // y height max
prtcon);
_pdpPrinter->Init();
_pdpPrinter->SetWordWrap(TRUE);
// Future: (ricksa) This is a really yucky way to pass the draw info
// to the printer but it was quick. We want to make this better.
_pdpPrinter->ResetDrawInfo(_pdp);
// Set temporary zoom factor (if there is one).
_pdpPrinter->SetTempZoomDenominator(_pdp->GetTempZoomDenominator());
}
else
_pdpPrinter->SetPrintDimensions(&pfr->rc);
LONG dxpInch = 0, dypInch = 0;
// We set the DC everytime because it could have changed.
if(GetDeviceCaps(hdcLocal, TECHNOLOGY) != DT_METAFILE)
{
// This is not a metafile so do the normal thing
fSetDCWorked = _pdpPrinter->SetDC(hdcLocal);
}
else
{
//Forms^3 draws using screen resolution, while OLE specifies HIMETRIC
dxpInch = fInOurHost() ? 2540 : W32->GetXPerInchScreenDC();
dypInch = fInOurHost() ? 2540 : W32->GetYPerInchScreenDC();
if (!fSetupDC)
{
RECT rc;
rc.left = MulDiv(pfr->rcPage.left, dxpInch, LX_PER_INCH);
rc.right = MulDiv(pfr->rcPage.right, dxpInch, LX_PER_INCH);
rc.top = MulDiv(pfr->rcPage.top, dypInch, LY_PER_INCH);
rc.bottom = MulDiv(pfr->rcPage.bottom, dypInch, LY_PER_INCH);
SetWindowOrgEx(hdcLocal, rc.left, rc.top, NULL);
SetWindowExtEx(hdcLocal, rc.right, rc.bottom, NULL);
}
_pdpPrinter->SetMetafileDC(hdcLocal, dxpInch, dypInch);
fSetDCWorked = TRUE;
}
if(fSetDCWorked)
{
//It is illogical to have the target device be the screen and the presentation
//device be a HIMETRIC metafile.
LONG dxpInchT = -1, dypInchT = -1;
if (dxpInch && GetDeviceCaps(pfr->hdcTarget, TECHNOLOGY) == DT_RASDISPLAY)
{
dxpInchT = dxpInch;
dypInchT = dypInch;
}
// We set this every time because it could have changed.
if(_pdpPrinter->SetTargetDC(pfr->hdcTarget, dxpInchT, dypInchT))
{
// Format another, single page worth of text.
cpReturn = _pdpPrinter->FormatRange(cpMin, cpMost, prtcon._fDoPrint);
if(!prtcon._fPrintFromDraw)
{
// After formatting, we know where the bottom is. But we only
// want to set this if we are writing a page rather than
// displaying a control on the printer.
pfr->rc.bottom = INT (pfr->rc.top + _pdpPrinter->DYtoLY(_pdpPrinter->GetHeight()));
}
// Remember this in case the host wishes to do its own banding.
_pdpPrinter->SetPrintView(pfr->rc); // we need to save this for OnDisplayBand.
_pdpPrinter->SetPrintPage(pfr->rcPage);
// If we're asked to render, then render the entire page in one go.
if(prtcon._fDoPrint && (cpReturn > 0 || prtcon._fPrintFromDraw))
{
OnDisplayBand(&pfr->rc, prtcon._fPrintFromDraw);
// Note: we can no longer call OnDisplayBand without reformating.
_pdpPrinter->Clear(AF_DELETEMEM);
}
}
}
return cpReturn > 0 ? GetAcpFromCp(cpReturn) : cpReturn;
}
BOOL CTxtEdit::OnDisplayBand(
const RECT *prc,
BOOL fPrintFromDraw)
{
TRACEBEGIN(TRCSUBSYSEDIT, TRCSCOPEINTERN, "CTxtEdit::OnDisplayBand");
HDC hdcPrinter;
RECT rc, rcPrint;
// Make sure OnFormatRange was called and that it actually rendered something.
if(!_pdpPrinter || !_pdpPrinter->Count())
return FALSE;
// Review (murrays): shouldn't the following use LRtoDR()? I.e.,
// _pdpPrinter->LRtoDR(rc, *prc);
// Proportionally map to printers extents.
rc.left = (INT) _pdpPrinter->LXtoDX(prc->left);
rc.right = (INT) _pdpPrinter->LXtoDX(prc->right);
rc.top = (INT) _pdpPrinter->LYtoDY(prc->top);
rc.bottom = (INT) _pdpPrinter->LYtoDY(prc->bottom);
rcPrint = _pdpPrinter->GetPrintView();
rcPrint.left = (INT) _pdpPrinter->LXtoDX(rcPrint.left);
rcPrint.right = (INT) _pdpPrinter->LXtoDX(rcPrint.right);
rcPrint.top = (INT) _pdpPrinter->LYtoDY(rcPrint.top);
rcPrint.bottom = (INT) _pdpPrinter->LYtoDY(rcPrint.bottom);
// Get printer DC because we use it below.
hdcPrinter = _pdpPrinter->GetDC();
if(fPrintFromDraw)
{
// We need to take view inset into account
_pdpPrinter->GetViewRect(rcPrint, &rcPrint);
}
// Render this band (if there's something to render)
if(rc.top < rc.bottom)
_pdpPrinter->Render(rcPrint, rc);
return TRUE;
}
//////////////////////////////// Protected ranges //////////////////////////////////
/*
* CTxtEdit::IsProtected (msg, wparam, lparam)
*
* @mfunc
* Find out if selection is protected
*
* @rdesc
* TRUE iff 1) control is read-only or 2) selection is protected and
* parent query says to protect
*/
BOOL CTxtEdit::IsProtected(
UINT msg, //@parm Message id
WPARAM wparam, //@parm WPARAM from window's message
LPARAM lparam) //@parm LPARAM from window's message
{
TRACEBEGIN(TRCSUBSYSEDIT, TRCSCOPEINTERN, "CTxtEdit::IsProtected");
LONG iDirection = 0;
CTxtSelection *psel = GetSel();
if(!psel)
return FALSE;
// There are a few special cases to consider, namely backspacing
// into a protected range, deleting into a protected range, and type
// with overstrike into a protected range.
if(msg == WM_KEYDOWN && (wparam == VK_BACK || wparam == VK_F16))
{
// Check for format behind selection, if we are trying to
// backspace an insertion point.
iDirection = -1;
}
else if(msg == WM_KEYDOWN && wparam == VK_DELETE ||
_fOverstrike && msg == WM_CHAR)
{
iDirection = 1;
}
// HACK ALERT: we don't do fIsDBCS protection checking for EM_REPLACESEL,
// EM_SETCHARFORMAT, or EM_SETPARAFORMAT. Outlook uses these APIs
// extensively and DBCS protection checking messes them up. N.B. the
// following if statement assumes that IsProtected returns a tri-value.
int iProt = psel->IsProtected(iDirection);
if (iProt == CTxtRange::PROTECTED_YES && msg != EM_REPLACESEL &&
msg != EM_SETCHARFORMAT && msg != EM_SETPARAFORMAT ||
iProt == CTxtRange::PROTECTED_ASK && _dwEventMask & ENM_PROTECTED &&
QueryUseProtection(psel, msg, wparam, lparam))
{
return TRUE;
}
return FALSE;
}
/*
* CTxtEdit::IsntProtectedOrReadOnly (msg, wparam, lparam)
*
* @mfunc
* Find out if selection isn't protected or read only. If it is,
* ring bell. For msg = WM_COPY, only protection is checked.
*
* @rdesc
* TRUE iff 1) control isn't read-only and 2) selection either isn't
* protected or parent query says not to protect
*
* @devnote This function is useful for UI operations (like typing).
*/
BOOL CTxtEdit::IsntProtectedOrReadOnly(
UINT msg, //@parm Message
WPARAM wparam, //@parm Corresponding wparam
LPARAM lparam) //@parm Corresponding lparam
{
TRACEBEGIN(TRCSUBSYSEDIT, TRCSCOPEINTERN, "CTxtEdit::IsProtectedOrReadOnly");
if (!IsProtected(msg, wparam, lparam) &&
(msg == WM_COPY || !_fReadOnly)) // WM_COPY only cares about
{ // protection
return TRUE;
}
Beep();
return FALSE;
}
/*
* CTxtEdit::IsProtectedRange (msg, wparam, lparam, prg)
*
* @mfunc
* Find out if range prg is protected
*
* @rdesc
* TRUE iff control is read-only or range is protected and parent
* query says to protect
*/
BOOL CTxtEdit::IsProtectedRange(
UINT msg, //@parm Message id
WPARAM wparam, //@parm WPARAM from window's message
LPARAM lparam, //@parm LPARAM from window's message
CTxtRange * prg) //@parm Range to examine
{
TRACEBEGIN(TRCSUBSYSEDIT, TRCSCOPEINTERN, "CTxtEdit::IsProtectedRange");
int iProt = prg->IsProtected(0);
if (iProt == CTxtRange::PROTECTED_YES ||
(iProt == CTxtRange::PROTECTED_ASK &&
(_dwEventMask & ENM_PROTECTED) &&
QueryUseProtection(prg, msg, wparam, lparam)))
// N.B. the preceding if statement assumes that IsProtected returns a tri-value
{
return TRUE;
}
return FALSE;
}
/*
* RegisterTypeLibrary
*
* @mfunc
* Auxiliary function to ensure the type library is registered if Idispatch is used.
*/
void RegisterTypeLibrary( void )
{
HRESULT hRes = NOERROR;
WCHAR szModulePath[MAX_PATH];
ITypeLib *pTypeLib = NULL;
// Obtain the path to this module's executable file
W32->GetModuleFileName( hinstRE, szModulePath, MAX_PATH );
// Load and register the type library resource
if (LoadRegTypeLib(LIBID_tom, 1, 0, LANG_NEUTRAL, &pTypeLib) != NOERROR)
{
hRes = W32->LoadTypeLibEx(szModulePath, REGKIND_REGISTER, &pTypeLib);
}
if(SUCCEEDED(hRes) && pTypeLib)
{
pTypeLib->Release();
}
}
/////////////////////////////// Private IUnknown //////////////////////////////
HRESULT __stdcall CTxtEdit::CUnknown::QueryInterface(
REFIID riid,
void **ppvObj)
{
TRACEBEGIN(TRCSUBSYSEDIT, TRCSCOPEINTERN, "CTxtEdit::CUnknown::QueryInterface");
CTxtEdit *ped = (CTxtEdit *)GETPPARENT(this, CTxtEdit, _unk);
*ppvObj = NULL;
if(IsEqualIID(riid, IID_IUnknown) || IsEqualIID(riid, IID_ITextServices))
*ppvObj = (ITextServices *)ped;
else if(IsEqualIID(riid, IID_IDispatch))
{
*ppvObj = (IDispatch *)ped;
RegisterTypeLibrary();
}
else if(IsEqualIID(riid, IID_ITextDocument))
{
*ppvObj = (ITextDocument *)ped;
RegisterTypeLibrary();
}
else if(IsEqualIID(riid, IID_ITextDocument2))
*ppvObj = (ITextDocument2 *)ped;
else if(IsEqualIID(riid, IID_IRichEditOle))
*ppvObj = (IRichEditOle *)ped;
else if(IsEqualIID(riid, IID_IRichEditOleCallback))
{
// NB!! Returning this pointer in our QI is
// phenomenally bogus; it breaks fundamental COM
// identity rules (granted, not many understand them!).
// Anyway, RichEdit 1.0 did this, so we better.
TRACEWARNSZ("Returning IRichEditOleCallback interface, COM "
"identity rules broken!");
*ppvObj = ped->GetRECallback();
}
if(*ppvObj)
{
((IUnknown *) *ppvObj)->AddRef();
return S_OK;
}
return E_NOINTERFACE;
}
ULONG __stdcall CTxtEdit::CUnknown::AddRef()
{
TRACEBEGIN(TRCSUBSYSEDIT, TRCSCOPEINTERN, "CTxtEdit::CUnknown::AddRef");
return ++_cRefs;
}
ULONG __stdcall CTxtEdit::CUnknown::Release()
{
TRACEBEGIN(TRCSUBSYSEDIT, TRCSCOPEINTERN, "CTxtEdit::CUnknown::Release");
// the call manager will take care of deleting our instance if appropriate.
CTxtEdit *ped = GETPPARENT(this, CTxtEdit, _unk);
CCallMgr callmgr(ped);
ULONG culRefs = --_cRefs;
if(culRefs == 0)
{
// Even though we don't delete ourselves now, dump the callback
// if we have it. This make implementation a bit easier on clients.
if(ped->_pobjmgr)
ped->_pobjmgr->SetRECallback(NULL);
// Make sure our timers are gone
ped->TxKillTimer(RETID_AUTOSCROLL);
ped->TxKillTimer(RETID_DRAGDROP);
ped->TxKillTimer(RETID_BGND_RECALC);
ped->TxKillTimer(RETID_SMOOTHSCROLL);
ped->TxKillTimer(RETID_MAGELLANTRACK);
}
return culRefs;
}
/*
* ValidateTextRange(pstrg)
*
* @func
* Makes sure that an input text range structure makes sense.
*
* @rdesc
* Size of the buffer required to accept copy of data or -1 if all the
* data in the control is requested.
*
* @comm
* This is used both in this file and in the RichEditANSIWndProc
*/
LONG ValidateTextRange(
TEXTRANGE *pstrg) //@parm pointer to a text range structure
{
TRACEBEGIN(TRCSUBSYSEDIT, TRCSCOPEINTERN, "ValidateTextRange");
// Validate that the input structure makes sense. In the first
// place it must be big enough. Secondly, the values must sense.
// Remember that if the cpMost field is -1 and the cpMin field
// is 0 this means that the call wants the entire buffer.
if (IsBadReadPtr(pstrg, sizeof(TEXTRANGE)) ||
((pstrg->chrg.cpMost < 1 || pstrg->chrg.cpMin < 0 ||
pstrg->chrg.cpMost <= pstrg->chrg.cpMin) &&
!(pstrg->chrg.cpMost == -1 && !pstrg->chrg.cpMin)))
{
// This isn't valid so tell the caller we didn't copy any data
return 0;
}
// Calculate size of buffer that we need on return
return pstrg->chrg.cpMost - pstrg->chrg.cpMin;
}
//////////////////////////////////// Selection /////////////////////////////////////
CTxtSelection * CTxtEdit::GetSel()
{
TRACEBEGIN(TRCSUBSYSEDIT, TRCSCOPEINTERN, "CTxtEdit::GetSel");
if(!_psel)
{
// There is no selection object available so create it.
_psel = new CTxtSelection(_pdp);
if(_psel)
_psel->AddRef(); // Set reference count = 1
}
// It is caller's responsiblity to notice that an error occurred
// in allocation of selection object.
return _psel;
}
void CTxtEdit::DiscardSelection()
{
TRACEBEGIN(TRCSUBSYSEDIT, TRCSCOPEINTERN, "CTxtEdit::DiscardSelection");
if(_psel)
{
_psel->Release();
if(_psel)
{
// The text services reference is not the last reference to the
// selection. We could keep track of the fact that text services
// has released its reference and when text services gets a
// reference again, do the AddRef there so that if the last
// reference went away while we were still inactive, the selection
// object would go away. However, it is seriously doubtful that
// such a case will be very common. Therefore, just do the simplest
// thing and put our reference back.
_psel->AddRef();
}
}
}
void CTxtEdit::GetSelRangeForRender(
LONG *pcpSelMin,
LONG *pcpSelMost)
{
TRACEBEGIN(TRCSUBSYSEDIT, TRCSCOPEINTERN, "CTxtEdit::GetSelRangeForRender");
// If we have no selection or we are not active and the selection
// has been requested to be hidden, there is no selection so we
// just return 0's.
if(!_psel || (!_fInPlaceActive && _fHideSelection))
{
*pcpSelMin = 0;
*pcpSelMost = 0;
return;
}
// Otherwise return the state of the current selection.
*pcpSelMin = _psel->GetScrSelMin();
*pcpSelMost = _psel->GetScrSelMost();
}
LRESULT CTxtEdit::OnGetSelText(
TCHAR *psz)
{
TRACEBEGIN(TRCSUBSYSEDIT, TRCSCOPEINTERN, "CTxtEdit::OnGetSelText");
LONG cpMin = GetSelMin(); // length + 1 for the null
LONG cpMost = GetSelMost();
return GetTextRange(cpMin, cpMost - cpMin + 1, psz);
}
/*
* CTxtEdit::OnExGetSel (pcrSel)
*
* @mfunc
* Get the current selection acpMin, acpMost packaged in a CHARRANGE.
*
* @comm
* This function outputs API cp's that may differ from the
* corresponding internal Unicode cp's.
*/
void CTxtEdit::OnExGetSel(
CHARRANGE *pcrSel) //@parm Output parm to receive acpMin, acpMost
{
TRACEBEGIN(TRCSUBSYSEDIT, TRCSCOPEINTERN, "CTxtEdit::OnExGetSel");
pcrSel->cpMin = GetAcpFromCp(GetSelMin());
pcrSel->cpMost = GetAcpFromCp(GetSelMost());
}
/*
* CTxtEdit::OnGetSel (pacpMin, pacpMost)
*
* @mfunc
* Get the current selection acpMin, acpMost.
*
* @rdesc
* LRESULT = acpMost > 65535L ? -1 : MAKELRESULT(acpMin, acpMost)
*
* @comm
* This function outputs API cp's that may differ from the
* corresponding internal Unicode cp's.
*/
LRESULT CTxtEdit::OnGetSel(
LONG *pacpMin, //@parm Output parm to receive acpMin
LONG *pacpMost) //@parm Output parm to receive acpMost
{
TRACEBEGIN(TRCSUBSYSEDIT, TRCSCOPEINTERN, "CTxtEdit::OnGetSel");
CHARRANGE crSel;
OnExGetSel(&crSel);
if(pacpMin)
*pacpMin = crSel.cpMin;
if(pacpMost)
*pacpMost = crSel.cpMost;
return (crSel.cpMost > 65535l) ? (LRESULT) -1
: MAKELRESULT((WORD) crSel.cpMin, (WORD) crSel.cpMost);
}
/*
* CTxtEdit::OnSetSel (acpMin, acpMost)
*
* @mfunc
* Implements the EM_SETSEL message
*
* Algorithm:
* There are three basic cases to handle
*
* cpMin < 0, cpMost ??? -- Collapse selection to insertion point
* at text end if cpMost < 0 and else at
* selection active end
* cpMin >= 0, cpMost < 0 -- select from cpMin to text end with
* active end at text end
*
* cpMin >= 0, cpMost >= 0 -- Treat as cpMin, cpMost with active
* end at cpMost
*
* @comm
* This function inputs API cp's that may differ from the
* corresponding internal Unicode cp's.
*/
LRESULT CTxtEdit::OnSetSel(
LONG acpMin, //@parm Input acpMin
LONG acpMost) //@parm Input acpMost
{
TRACEBEGIN(TRCSUBSYSEDIT, TRCSCOPEINTERN, "CTxtEdit::OnSetSel");
// Since this is only called from the window proc, we are always active
Assert(GetSel());
CTxtSelection * const psel = GetSel();
LONG cpMin, cpMost;
if(acpMin < 0)
cpMin = cpMost = (acpMost < 0) ? tomForward : psel->GetCp();
else
{
cpMin = GetCpFromAcp(acpMin);
cpMost = (acpMost < 0) ? tomForward : GetCpFromAcp(acpMost);
}
if(Get10Mode() && cpMost < cpMin) // In 10 mode, ensure
{ // cpMost >= cpMin. In
cpMin ^= cpMost; // SetSelection, we set active
cpMost ^= cpMin; // end to cpMost, which can be
cpMin ^= cpMost; // smaller than cpMin, in spite
} // of its name.
psel->SetSelection(cpMin, cpMost);
return psel->GetCpMost();
}
/////////////////////////////// DROP FILES support //////////////////////////////////////
#ifndef NODROPFILES
LRESULT CTxtEdit::InsertFromFile (
LPCTSTR lpFile)
{
REOBJECT reobj;
LPRICHEDITOLECALLBACK const precall = GetRECallback();
HRESULT hr = NOERROR;
if(!precall)
return E_NOINTERFACE;
ZeroMemory(&reobj, sizeof(REOBJECT));
reobj.cbStruct = sizeof(REOBJECT);
// Get storage for the object from client
hr = precall->GetNewStorage(&reobj.pstg);
if(hr)
{
TRACEERRORSZ("GetNewStorage() failed.");
goto err;
}
// Create an object site for new object
hr = GetClientSite(&reobj.polesite);
if(!reobj.polesite)
{
TRACEERRORSZ("GetClientSite() failed.");
goto err;
}
hr = OleCreateLinkToFile(lpFile, IID_IOleObject, OLERENDER_DRAW,
NULL, NULL, reobj.pstg, (LPVOID*)&reobj.poleobj);
if(hr)
{
TRACEERRORSZ("Failure creating link object.");
goto err;
}
reobj.cp = REO_CP_SELECTION;
reobj.dvaspect = DVASPECT_CONTENT;
//Get object clsid
hr = reobj.poleobj->GetUserClassID(&reobj.clsid);
if(hr)
{
TRACEERRORSZ("GetUserClassID() failed.");
goto err;
}
// Let client know what we're up to
hr = precall->QueryInsertObject(&reobj.clsid, reobj.pstg,
REO_CP_SELECTION);
if(hr != NOERROR)
{
TRACEERRORSZ("QueryInsertObject() failed.");
goto err;
}
hr = reobj.poleobj->SetClientSite(reobj.polesite);
if(hr)
{
TRACEERRORSZ("SetClientSite() failed.");
goto err;
}
if(hr = InsertObject(&reobj))
{
TRACEERRORSZ("InsertObject() failed.");
}
err:
if(reobj.poleobj)
reobj.poleobj->Release();
if(reobj.polesite)
reobj.polesite->Release();
if(reobj.pstg)
reobj.pstg->Release();
return hr;
}
typedef void (WINAPI*DRAGFINISH)(HDROP);
typedef UINT (WINAPI*DRAGQUERYFILEA)(HDROP, UINT, LPSTR, UINT);
typedef UINT (WINAPI*DRAGQUERYFILEW)(HDROP, UINT, LPTSTR, UINT);
typedef BOOL (WINAPI*DRAGQUERYPOINT)(HDROP, LPPOINT);
LRESULT CTxtEdit::OnDropFiles(
HANDLE hDropFiles)
{
TRACEBEGIN(TRCSUBSYSEDIT, TRCSCOPEINTERN, "CTxtEdit::OnDropFiles");
UINT cFiles;
UINT iFile;
char szFile[MAX_PATH];
WCHAR wFile[MAX_PATH];
POINT ptDrop;
CTxtSelection * const psel = GetSel();
HMODULE hDLL = NULL;
DRAGFINISH fnDragFinish;
DRAGQUERYFILEA fnDragQueryFileA;
DRAGQUERYFILEW fnDragQueryFileW;
DRAGQUERYPOINT fnDragQueryPoint;
if (_fReadOnly)
return 0;
AssertSz((hDropFiles != NULL), "CTxtEdit::OnDropFiles invalid hDropFiles");
// dynamic load Shell32
hDLL = LoadLibrary (TEXT("Shell32.DLL"));
if(hDLL)
{
fnDragFinish = (DRAGFINISH)GetProcAddress (hDLL, "DragFinish");
fnDragQueryFileA = (DRAGQUERYFILEA)GetProcAddress (hDLL, "DragQueryFileA");
fnDragQueryFileW = (DRAGQUERYFILEW)GetProcAddress (hDLL, "DragQueryFileW");
fnDragQueryPoint = (DRAGQUERYPOINT)GetProcAddress (hDLL, "DragQueryPoint");
}
else
return 0;
if(!fnDragFinish || !fnDragQueryFileA || !fnDragQueryFileW || !fnDragQueryPoint)
{
AssertSz(FALSE, "Shell32 GetProcAddress failed");
goto EXIT0;
}
(*fnDragQueryPoint) ((HDROP)hDropFiles, &ptDrop);
if(W32->OnWin9x())
cFiles = (*fnDragQueryFileA) ((HDROP)hDropFiles, (UINT)-1, NULL, 0);
else
cFiles = (*fnDragQueryFileW) ((HDROP)hDropFiles, (UINT)-1, NULL, 0);
if(cFiles)
{
LONG cp = 0;
POINT ptl = ptDrop;
CRchTxtPtr rtp(this);
const CCharFormat *pCF;
if(_pdp->CpFromPoint(ptl, NULL, &rtp, NULL, FALSE) >= 0)
{
cp = rtp.GetCp();
pCF = rtp.GetCF();
}
else
{
LONG iCF = psel->Get_iCF();
cp = psel->GetCp();
pCF = GetCharFormat(iCF);
ReleaseFormats(iCF, -1);
}
// Notify user for dropfile
if(_dwEventMask & ENM_DROPFILES)
{
ENDROPFILES endropfiles;
endropfiles.hDrop = hDropFiles;
endropfiles.cp = Get10Mode() ? GetAcpFromCp(cp) : cp;
endropfiles.fProtected = !!(pCF->_dwEffects & CFE_PROTECTED);
if(TxNotify(EN_DROPFILES, &endropfiles))
goto EXIT; // Ignore drop file
cp = Get10Mode() ? GetCpFromAcp(endropfiles.cp) : endropfiles.cp; // Allow callback to update cp
}
psel->SetCp(cp);
}
for (iFile = 0; iFile < cFiles; iFile++)
{
if(W32->OnWin9x())
{
(*fnDragQueryFileA) ((HDROP)hDropFiles, iFile, szFile, MAX_PATH);
MultiByteToWideChar(CP_ACP, 0, szFile, -1,
wFile, MAX_PATH);
}
else
(*fnDragQueryFileW) ((HDROP)hDropFiles, iFile, wFile, MAX_PATH);
InsertFromFile (wFile);
}
EXIT:
(*fnDragFinish) ((HDROP)hDropFiles);
EXIT0:
FreeLibrary (hDLL);
return 0;
}
#else // NODROPFILES
LRESULT CTxtEdit::OnDropFiles(HANDLE hDropFiles)
{
TRACEBEGIN(TRCSUBSYSEDIT, TRCSCOPEINTERN, "CTxtEdit::OnDropFiles");
return 0;
}
#endif // NODROPFILES
/////////////////////////////// Exposable methods //////////////////////////////////////
/*
* CTxtEdit::TxCharFromPos (ppt, plres)
*
* @mfunc
* Get the acp at the point *ppt.
*
* @rdesc
* HRESULT = !fInplaceActive() ? OLE_E_INVALIDRECTS_OK :
* (CpFromPoint succeeded) ? S_OK : E_FAIL
* @comm
* This function outputs an API cp that may differ from the
* corresponding internal Unicode cp.
*/
HRESULT CTxtEdit::TxCharFromPos(
LPPOINT ppt, //@parm Point to find the acp for
LRESULT *plres) //@parm Output parm to receive the acp
{
TRACEBEGIN(TRCSUBSYSEDIT, TRCSCOPEINTERN, "CTxtEdit::TxCharFromPos");
if(!fInplaceActive())
{
// We have no valid display rectangle if this object is not active
*plres = -1;
return OLE_E_INVALIDRECT;
}
*plres = _pdp->CpFromPoint(*ppt, NULL, NULL, NULL, FALSE);
if(*plres == -1)
return E_FAIL;
*plres = GetAcpFromCp(*plres);
return S_OK;
}
/*
* CTxtEdit::TxPosFromChar (acp, ppt)
*
* @mfunc
* Get the point at acp.
*
* @rdesc
* HRESULT = !fInplaceActive() ? OLE_E_INVALIDRECTS_OK :
* (PointFromTp succeeded) ? S_OK : E_FAIL
* @comm
* This function inputs an API cp that may differ from the
* corresponding internal Unicode cp.
*/
HRESULT CTxtEdit::TxPosFromChar(
LONG acp, //@parm Input cp to get the point for
POINT * ppt) //@parm Output parm to receive the point
{
TRACEBEGIN(TRCSUBSYSEDIT, TRCSCOPEINTERN, "CTxtEdit::TxPosFromChar");
if(!fInplaceActive())
return OLE_E_INVALIDRECT;
CRchTxtPtr rtp(this, GetCpFromAcp(acp));
if(_pdp->PointFromTp(rtp, NULL, FALSE, *ppt, NULL, TA_TOP) < 0)
return E_FAIL;
return S_OK;
}
/*
* CTxtEdit::TxFindWordBreak (nFunction, acp, plres)
*
* @mfunc
* Find word break or classify character at acp.
*
* @rdesc
* HRESULT = plRet ? S_OK : E_INVALIDARG
*
* @comm
* This function inputs and exports API cp's and cch's that may differ
* from the internal Unicode cp's and cch's.
*/
HRESULT CTxtEdit::TxFindWordBreak(
INT nFunction, //@parm Word break function
LONG acp, //@parm Input cp
LRESULT *plres) //@parm cch moved to reach break
{
TRACEBEGIN(TRCSUBSYSEDIT, TRCSCOPEINTERN, "CTxtEdit::TxFindWordBreak");
CTxtPtr tp(this, GetCpFromAcp(acp)); // This validates cp
LONG cpSave = tp.GetCp(); // Save starting value
if(!plres)
return E_INVALIDARG;
*plres = tp.FindWordBreak(nFunction);
// WB_CLASSIFY and WB_ISDELIMITER return values; others return offsets
// this function returns values, so it converts when necessary
if(nFunction != WB_CLASSIFY && nFunction != WB_ISDELIMITER)
*plres = GetAcpFromCp(LONG(*plres + cpSave));
return S_OK;
}
/*
* INT CTxtEdit::TxWordBreakProc (pch, ich, cb, action)
*
* @func
* Default word break proc used in conjunction with FindWordBreak. ich
* is character offset (start position) in the buffer pch, which is cb
* bytes in length. Possible action values are:
*
* WB_CLASSIFY
* Returns char class and word break flags of char at start position.
*
* WB_ISDELIMITER
* Returns TRUE iff char at start position is a delimeter.
*
* WB_LEFT
* Finds nearest word beginning before start position using word breaks.
*
* WB_LEFTBREAK
* Finds nearest word end before start position using word breaks.
* Used by CMeasurer::Measure()
*
* WB_MOVEWORDLEFT
* Finds nearest word beginning before start position using class
* differences. This value is used during CTRL+LEFT key processing.
*
* WB_MOVEWORDRIGHT
* Finds nearest word beginning after start position using class
* differences. This value is used during CTRL+RIGHT key processing.
*
* WB_RIGHT
* Finds nearest word beginning after start position using word breaks.
* Used by CMeasurer::Measure()
*
* WB_RIGHTBREAK
* Finds nearest word end after start position using word breaks.
*
* @rdesc
* Character offset from start of buffer (pch) of the word break
*/
INT CTxtEdit::TxWordBreakProc(
TCHAR * pch, //@parm Char buffer
INT ich, //@parm Char offset of _cp in buffer
INT cb, //@parm Count of bytes in buffer
INT action, //@parm Type of breaking action
LONG cpStart, //@parm cp for first character in pch
LONG cp) //@parm cp associated to ich
{
TRACEBEGIN(TRCSUBSYSEDIT, TRCSCOPEINTERN, "CTxtEdit::TxWordBreakProc");
if (_pfnWB)
{
// Client overrode the wordbreak proc, delegate the call to it.
if (!Get10Mode())
{
Assert(!_fExWordBreakProc);
return _pfnWB(pch, ich, cb, action);
}
else
{
int ret = 0;
char sz[256];
char* pach = sz;
if (cb >= 255)
pach = new char [cb + 1];
// this indicates if we have to adjust the pach because the api's for
// EDITWORDBREAKPROCEX and EDITWORDBREAKPROC are different when looking to the left
BOOL fAdjustPtr = _fExWordBreakProc && (action == WB_LEFT || action == WB_MOVEWORDLEFT || action == WB_LEFTBREAK);
// RichEdit 1.0, create a buffer, translate ich and WCTMB
// pch into the buffer. Need codepage to use. Then get translate
// return value. Translations are like GetCachFromCch() and
// GetCchFromCach()
if (_fExWordBreakProc)
{
Assert(ich == 0 || ich == 1 || ich == CchOfCb(cb));
// We need to adjust the cp to the starting point of the buffer
if (!fAdjustPtr)
{
cpStart += ich;
pch += ich;
cb -= (2 * ich);
}
// initialize string w/ zero's so we can determine the length of the string for later
memset(pach, 0, cb + 1);
}
int nLen = CchOfCb(cb);
CRchTxtPtr rtp(this, cpStart);
BYTE bCharSet = rtp.GetCF()->_bCharSet;
if (WideCharToMultiByte(GetCodePage(bCharSet), 0, pch, nLen, pach, cb + 1, NULL, NULL))
{
// Documentation stipulates we need to point to the end of the string
if (fAdjustPtr)
pach += strlen(pach);
if (_fExWordBreakProc)
ret = ((EDITWORDBREAKPROCEX)_pfnWB)(pach, nLen, bCharSet, action);
else
{
ret = ((EDITWORDBREAKPROCA)_pfnWB)(pach, rtp.GetCachFromCch(ich), nLen, action);
// need to reset cp position because GetCachFromCch potentially moves the cp
if (ich)
rtp.SetCp(cpStart);
}
// For WB_ISDELIMITER and WB_CLASSIFY don't need to convert back
// to ich because return value represents a BOOL
if (action != WB_ISDELIMITER && action != WB_CLASSIFY)
ret = rtp.GetCchFromCach(ret);
}
// Delete any allocated memory
if (pach != sz)
delete [] pach;
return ret;
}
}
LONG cchBuff = CchOfCb(cb);
LONG cch = cchBuff - ich;
TCHAR ch;
WORD cType3[MAX_CLASSIFY_CHARS];
INT kinsokuClassifications[MAX_CLASSIFY_CHARS];
WORD * pcType3;
INT * pKinsoku1, *pKinsoku2;
WORD * pwRes;
WORD startType3 = 0;
WORD wb = 0;
WORD wClassifyData[MAX_CLASSIFY_CHARS]; // For batch classifying
Assert(cchBuff < MAX_CLASSIFY_CHARS);
Assert(ich >= 0 && ich < cchBuff);
// Single character actions
if ( action == WB_CLASSIFY )
{
// 1.0 COMPATABILITY - 1.0 returned 0 for apostrohpe's
TCHAR ch = pch[ich];
if (Get10Mode() && ( ch == 0x0027 /*APOSTRPHE*/ ||
ch == 0xFF07 /*FULLWIDTH APOSTROPHE*/))
{
return 0;
}
return ClassifyChar(ch);
}
if ( action == WB_ISDELIMITER )
return !!(ClassifyChar(pch[ich]) & WBF_BREAKLINE);
// Batch classify buffer for whitespace and kinsoku classes
BatchClassify(pch, cchBuff, cType3, kinsokuClassifications, wClassifyData);
if (_pbrk && cp > -1)
{
cp -= ich;
for (LONG cbrk = cchBuff-1; cbrk >= 0; --cbrk)
{
if (cp + cbrk >= 0 && _pbrk->CanBreakCp(BRK_WORD, cp + cbrk))
{
// Mimic class open/close in Kinsoku classification.
kinsokuClassifications[cbrk] = brkclsOpen;
if (cbrk > 0)
{
kinsokuClassifications[cbrk-1] = brkclsClose;
wClassifyData[cbrk-1] |= WBF_WORDBREAKAFTER;
}
}
}
}
// Setup pointers
pKinsoku2 = kinsokuClassifications + ich; // Ptr to current kinsoku
pKinsoku1 = pKinsoku2 - 1; // Ptr to previous kinsoku
if(!(action & 1)) // WB_(MOVE)LEFTxxx
{
ich--;
Assert(ich >= 0);
}
pwRes = &wClassifyData[ich];
pcType3 = &cType3[ich]; // for ideographics
switch(action)
{
case WB_LEFT:
for(; ich >= 0 && *pwRes & WBF_BREAKLINE; // Skip preceding line
ich--, pwRes--) // break chars
; // Empty loop. Then fall
// thru to WB_LEFTBREAK
case WB_LEFTBREAK:
for(; ich >= 0 && !CanBreak(*pKinsoku1, *pKinsoku2);
ich--, pwRes--, pKinsoku1--, pKinsoku2--)
; // Empty loop
if(action == WB_LEFTBREAK) // Skip preceding line
{ // break chars
for(; ich >= 0 && *pwRes & WBF_BREAKLINE;
ich--, pwRes--)
; // Empty loop
}
return ich + 1;
case WB_MOVEWORDLEFT:
for(; ich >= 0 && (*pwRes & WBF_CLASS) == 2;// Skip preceding blank
ich--, pwRes--, pcType3--) // chars
;
if(ich >= 0) // Save starting wRes and
{ // startType3
wb = *pwRes--; // Really type1
startType3 = *pcType3--; // type3
ich--;
}
// Skip to beginning of current word
while(ich >= 0 && (*pwRes & WBF_CLASS) != 3 &&
!(*pwRes & WBF_WORDBREAKAFTER) &&
(IsSameClass(*pwRes, wb, *pcType3, startType3) ||
!wb && ich && ((ch = pch[ich]) == '\'' || ch == RQUOTE)))
{
ich--, pwRes--, pcType3--;
}
return ich + 1;
case WB_RIGHTBREAK:
for(; cch > 0 && *pwRes & WBF_BREAKLINE; // Skip any leading line
cch--, pwRes++) // break chars
; // Empty loop
// Fall thru to WB_RIGHT
case WB_RIGHT:
// Skip to end of current word
for(; cch > 0 && !CanBreak(*pKinsoku1, *pKinsoku2);
cch--, pKinsoku1++, pKinsoku2++, pwRes++)
;
if(action != WB_RIGHTBREAK) // Skip trailing line
{ // break chars
for(; cch > 0 && *pwRes & WBF_BREAKLINE;
cch--, pwRes++)
;
}
return cchBuff - cch;
case WB_MOVEWORDRIGHT:
if(cch <= 0) // Nothing to do
return ich;
wb = *pwRes; // Save start wRes
startType3 = *pcType3; // and startType3
// Skip to end of word
if (startType3 & C3_IDEOGRAPH || // If ideographic or
(*pwRes & WBF_CLASS) == 3) // tab/cell, just
{
cch--, pwRes++; // skip one char
}
else while(cch > 0 &&
!(*pwRes & WBF_WORDBREAKAFTER) &&
(IsSameClass(*pwRes, wb, *pcType3, startType3) || !wb &&
((ch = pch[cchBuff - cch]) == '\'' || ch == RQUOTE)))
{
cch--, pwRes++, pcType3++;
}
for(; cch > 0 &&
((*pwRes & WBF_CLASS) == 2 // Skip trailing blank
|| (*pwRes & WBF_WORDBREAKAFTER)); // Skip Thai break after
cch--, pwRes++) // chars
;
return cchBuff - cch;
}
TRACEERRSZSC("CTxtEdit::TxWordBreakProc: unknown action", action);
return ich;
}
/*
* CTxtEdit::TxFindText (flags, cpMin, cpMost, pch, pcpRet)
*
* @mfunc
* Find text in direction specified by flags starting at cpMin if
* forward search (flags & FR_DOWN nonzero) and cpMost if backward
* search.
*
* @rdesc
* HRESULT (success) ? NOERROR : S_FALSE
*
* @comm
* Caller is responsible for setting cpMin to the appropriate end of
* the selection depending on which way the search is proceding.
*/
HRESULT CTxtEdit::TxFindText(
DWORD flags, //@parm Specify FR_DOWN, FR_MATCHCASE, FR_WHOLEWORD
LONG cpStart, //@parm Find start cp
LONG cpLimit, //@parm Find limit cp
const WCHAR*pch, //@parm Null terminated string to search for
LONG * pcpMin, //@parm Out parm to receive start of matched string
LONG * pcpMost) //@parm Out parm to receive end of matched string
{
TRACEBEGIN(TRCSUBSYSEDIT, TRCSCOPEINTERN, "CTxtEdit::TxFindText");
if(Get10Mode()) // RichEdit 1.0 only searches
{
flags |= FR_DOWN; // forward
if (cpLimit < -1)
cpLimit = -1;
}
DWORD cchText = GetTextLength();
LONG cchToFind;
const BOOL fSetCur = (cchText >= 4096);
HCURSOR hcur = NULL; // Init to keep compiler happy
Assert(pcpMin && pcpMost);
// Validate parameters
if(!pch || !(cchToFind = wcslen(pch)) || cpStart < 0 || cpLimit < -1)
return E_INVALIDARG; // Nothing to search for
CTxtPtr tp(this, cpStart);
if(fSetCur) // In case this takes a while...
hcur = TxSetCursor(LoadCursor(0, IDC_WAIT), NULL);
*pcpMin = tp.FindText(cpLimit, flags, pch, cchToFind);
*pcpMost = tp.GetCp();
if(fSetCur)
TxSetCursor(hcur, NULL);
return *pcpMin >= 0 ? NOERROR : S_FALSE;;
}
/*
* CTxtEdit::TxGetLineCount (plres)
*
* @mfunc
* Get the line count.
*
* @rdesc
* HRESULT = !fInplaceActive() ? OLE_E_INVALIDRECTS_OK :
* (WaitForRecalc succeeded) ? S_OK : E_FAIL
*/
HRESULT CTxtEdit::TxGetLineCount(
LRESULT *plres) //@parm Output parm to receive line count
{
TRACEBEGIN(TRCSUBSYSEDIT, TRCSCOPEINTERN, "CTxtEdit::TxGetLineCount");
AssertSz(plres, "CTxtEdit::TxGetLineCount invalid pcli");
if(!fInplaceActive())
return OLE_E_INVALIDRECT;
if(!_pdp->WaitForRecalc(GetTextLength(), -1))
return E_FAIL;
*plres = _pdp->LineCount();
Assert(*plres > 0);
return S_OK;
}
/*
* CTxtEdit::TxLineFromCp (acp, plres)
*
* @mfunc
* Get the line containing acp.
*
* @rdesc
* HRESULT = !fInplaceActive() ? OLE_E_INVALIDRECTS_OK :
* (LineFromCp succeeded) ? S_OK : E_FAIL
* @comm
* This function inputs an API cp that may differ from the
* corresponding internal Unicode cp.
*/
HRESULT CTxtEdit::TxLineFromCp(
LONG acp, //@parm Input cp
LRESULT *plres) //@parm Ouput parm to receive line number
{
TRACEBEGIN(TRCSUBSYSEDIT, TRCSCOPEINTERN, "CTxtEdit::TxLineFromCp");
BOOL fAtEnd = FALSE;
LONG cp = 0;
AssertSz(plres, "CTxtEdit::TxLineFromCp invalid plres");
if(!fInplaceActive())
{
AssertSz(*plres == 0,
"CTxtEdit::TxLineFromCp error return lres not correct");
return OLE_E_INVALIDRECT;
}
if(acp < 0) // Validate cp
{
if(_psel)
{
cp = _psel->GetCpMin();
fAtEnd = !_psel->GetCch() && _psel->CaretNotAtBOL();
}
}
else
{
LONG cchText = GetTextLength();
cp = GetCpFromAcp(acp);
cp = min(cp, cchText);
}
*plres = _pdp->LineFromCp(cp, fAtEnd);
HRESULT hr = *plres < 0 ? E_FAIL : S_OK;
// Old messages expect 0 as a result of this call if there is an error.
if(*plres == -1)
*plres = 0;
return hr;
}
/*
* CTxtEdit::TxLineLength (acp, plres)
*
* @mfunc
* Get the line containing acp.
*
* @rdesc
* HRESULT = !fInplaceActive() ? OLE_E_INVALIDRECTS_OK :
* (GetSel() succeeded) ? S_OK : E_FAIL
* @comm
* This function inputs an API cp and outputs an API cch that
* may differ from the corresponding internal Unicode cp and cch.
*/
HRESULT CTxtEdit::TxLineLength(
LONG acp, //@parm Input cp
LRESULT *plres) //@parm Output parm to receive line length
{
TRACEBEGIN(TRCSUBSYSEDIT, TRCSCOPEINTERN, "CTxtEdit::TxLineLength");
LONG cch = 0;
LONG cp;
AssertSz(plres,
"CTxtEdit::TxLineLength Invalid plres parameter");
if(!fInplaceActive())
return OLE_E_INVALIDRECT;
if(acp < 0)
{
if(!_psel)
return E_FAIL;
cch = _psel->LineLength(&cp);
}
else
{
cp = GetCpFromAcp(acp);
if(cp <= GetAdjustedTextLength())
{
CLinePtr rp(_pdp);
rp.RpSetCp(cp, FALSE);
cp -= rp.GetIch(); // Goto start of line
cch = rp.GetAdjustedLineLength();
}
}
if(fCpMap()) // Can be time consuming, so
{ // don't do it unless asked
CRchTxtPtr rtp(this, cp); // for
cch = rtp.GetCachFromCch(cch);
}
*plres = cch;
return S_OK;
}
/*
* CTxtEdit::TxLineIndex (acp, plres)
*
* @mfunc
* Get the line containing acp.
*
* @rdesc
* HRESULT = !fInplaceActive() ? OLE_E_INVALIDRECTS_OK :
* (LineCount() && WaitForRecalcIli succeeded) ? S_OK : E_FAIL
* @comm
* This function outputs an API cp that may differ from the
* corresponding internal Unicode cp.
*/
HRESULT CTxtEdit::TxLineIndex(
LONG ili, //@parm Line # to find acp for
LRESULT *plres) //@parm Output parm to receive acp
{
TRACEBEGIN(TRCSUBSYSEDIT, TRCSCOPEINTERN, "CTxtEdit::TxLineIndex");
HRESULT hr;
AssertSz(plres, "CTxtEdit::TxLineIndex invalid plres");
*plres = -1;
if(!fInplaceActive())
return OLE_E_INVALIDRECT;
if(ili == -1)
{
// Fetch line from the current cp.
LRESULT lres; // For 64-bit compatibility
hr = TxLineFromCp(-1, &lres);
if(hr != NOERROR)
return hr;
ili = (LONG)lres;
}
// ili is a zero-based *index*, whereas count returns the total # of lines.
// Therefore, we use >= for our comparisions.
if(ili >= _pdp->LineCount() && !_pdp->WaitForRecalcIli(ili))
return E_FAIL;
*plres = GetAcpFromCp(_pdp->CpFromLine(ili, NULL));
return S_OK;
}
/////////////////////////////////// Miscellaneous messages ////////////////////////////////////
/*
* CTxtEdit::OnFindText (msg, flags, pftex)
*
* @mfunc
* Find text.
*
* @rdesc
* LRESULT = succeeded ? acpmin : -1
*
* @comm
* This function inputs and exports API cp's that may differ
* from the internal Unicode cp's.
*/
LRESULT CTxtEdit::OnFindText(
UINT msg,
DWORD flags,
FINDTEXTEX *pftex)
{
TRACEBEGIN(TRCSUBSYSEDIT, TRCSCOPEINTERN, "CTxtEdit::OnFindText");
LONG cpMin, cpMost;
if(TxFindText(flags,
GetCpFromAcp(pftex->chrg.cpMin),
GetCpFromAcp(pftex->chrg.cpMost),
pftex->lpstrText, &cpMin, &cpMost) != S_OK)
{
if(msg == EM_FINDTEXTEX || msg == EM_FINDTEXTEXW)
{
pftex->chrgText.cpMin = -1;
pftex->chrgText.cpMost = -1;
}
return -1;
}
LONG acpMin = GetAcpFromCp(cpMin);
if(msg == EM_FINDTEXTEX || msg == EM_FINDTEXTEXW) // We send a message
{ // back to change
pftex->chrgText.cpMin = acpMin; // selection to this
pftex->chrgText.cpMost = GetAcpFromCp(cpMost);
}
return (LRESULT)acpMin;
}
LRESULT CTxtEdit::OnGetWordBreakProc()
{
TRACEBEGIN(TRCSUBSYSEDIT, TRCSCOPEINTERN, "CTxtEdit::OnGetWordBreakProc");
return (LRESULT) _pfnWB;
}
// For plain-text instances, OnGetCharFormat(), OnGetParaFormat(),
// OnSetCharFormat(), and OnSetParaFormat() apply to whole story
LRESULT CTxtEdit::OnGetCharFormat(
CHARFORMAT2 *pCF2,
DWORD dwFlags)
{
TRACEBEGIN(TRCSUBSYSEDIT, TRCSCOPEINTERN, "CTxtEdit::OnGetCharFormat");
UINT cb = pCF2->cbSize;
UINT CodePage = 1200;
if(!IsValidCharFormatW(pCF2))
{
if(!IsValidCharFormatA((CHARFORMATA *)pCF2))
return 0;
CodePage = GetDefaultCodePage(EM_GETCHARFORMAT);
}
if(cb == sizeof(CHARFORMATW) || cb == sizeof(CHARFORMATA))
dwFlags |= CFM2_CHARFORMAT; // Tell callees that only
// CHARFORMAT parms needed
CCharFormat CF;
DWORD dwMask = CFM_ALL2;
if(dwFlags & SCF_SELECTION)
dwMask = GetSel()->GetCharFormat(&CF, dwFlags);
else
CF = *GetCharFormat(-1);
if(dwFlags & CFM2_CHARFORMAT) // Maintain CHARFORMAT
{ // compatibility
CF._dwEffects &= CFM_EFFECTS;
dwMask &= CFM_ALL;
}
CF.Get(pCF2, CodePage);
pCF2->dwMask = dwMask;
return (LRESULT)dwMask;
}
LRESULT CTxtEdit::OnGetParaFormat(
PARAFORMAT2 *pPF2,
DWORD dwFlags)
{
TRACEBEGIN(TRCSUBSYSEDIT, TRCSCOPEINTERN, "CTxtEdit::OnGetParaFormat");
if(!IsValidParaFormat(pPF2))
return 0;
if(pPF2->cbSize == sizeof(PARAFORMAT)) // Tell callees that only
dwFlags |= PFM_PARAFORMAT; // PARAFORMAT parms needed
CParaFormat PF;
DWORD dwMask = GetSel()->GetParaFormat(&PF, dwFlags);
if(dwFlags & PFM_PARAFORMAT)
dwMask &= PFM_ALL;
PF.Get(pPF2);
pPF2->dwMask = dwMask;
return (LRESULT)dwMask;
}
/*
* CTxtEdit::OnSetFontSize(yPoint, publdr)
*
* @mfunc
* Set new font height by adding yPoint to current height
* and rounding according to the table in cfpf.cpp
*
* @rdesc
* LRESULT nonzero if success
*/
LRESULT CTxtEdit::OnSetFontSize(
LONG yPoint,
IUndoBuilder *publdr) //@parm Undobuilder to receive antievents
{
// TODO: ? Return nonzero if we set a new font size for some text.
CCharFormat CF;
CF._yHeight = (SHORT)yPoint;
return OnSetCharFormat(SCF_SELECTION, &CF, publdr, CFM_SIZE,
CFM2_CHARFORMAT | CFM2_USABLEFONT);
}
/*
* CTxtEdit::OnSetFont(hfont)
*
* @mfunc
* Set new default font from hfont
*
* @rdesc
* LRESULT nonzero if success
*/
LRESULT CTxtEdit::OnSetFont(
HFONT hfont) //@parm Handle of font to use for default
{
TRACEBEGIN(TRCSUBSYSEDIT, TRCSCOPEINTERN, "CTxtEdit::OnSetFont");
CCharFormat CF;
if(FAILED(CF.InitDefault(hfont)))
return 0;
DWORD dwMask2 = CFM2_CHARFORMAT;
WPARAM wparam = SCF_ALL;
if(!GetAdjustedTextLength())
{
dwMask2 = CFM2_CHARFORMAT | CFM2_NOCHARSETCHECK;
wparam = 0;
}
return !FAILED(OnSetCharFormat(wparam, &CF, NULL, CFM_ALL, dwMask2));
}
/*
* CTxtEdit::OnSetCharFormat(wparam, pCF, publdr, dwMask, dwMask2)
*
* @mfunc
* Set new default CCharFormat
*
* @rdesc
* LRESULT nonzero if success
*/
LRESULT CTxtEdit::OnSetCharFormat(
WPARAM wparam, //@parm Selection flag
CCharFormat * pCF, //@parm CCharFormat to apply
IUndoBuilder *publdr, //@parm Undobuilder to receive antievents
DWORD dwMask, //@parm CHARFORMAT2 mask
DWORD dwMask2) //@parm Second mask
{
TRACEBEGIN(TRCSUBSYSEDIT, TRCSCOPEINTERN, "CTxtEdit::OnSetCharFormat");
// This says that if there's a selection that's protected and the
// parent window wants protection notifications and doesn't want
// changes with a protected selection, then return 0. This is more
// stringent than RE 2.0, but it's more like 1.0.
if (_psel && _psel->IsProtected(0) == CTxtRange::PROTECTED_ASK &&
_dwEventMask & ENM_PROTECTED)
{
CHARFORMAT CF0; // Selection is protected, client
// wants protect notifications
CF0.cbSize = sizeof(CHARFORMAT);// and protected mask is on
CF0.dwEffects = pCF->_dwEffects;// Concoct CHARFORMAT for query
CF0.dwMask = dwMask; // Maybe need more fields...
if(QueryUseProtection(_psel, EM_SETCHARFORMAT, wparam, (LPARAM)&CF0))
return 0; // No deal
}
BOOL fRet = TRUE;
AssertSz(!_fSelChangeCharFormat || IsRich(),
"Inconsistent _fSelChangeCharFormat flag");
if ((wparam & SCF_ALL) ||
!_fSelChangeCharFormat && _story.GetCFRuns() && !(wparam & SCF_SELECTION))
{
CTxtRange rg(this, 0, -GetTextLength());
if(publdr)
publdr->StopGroupTyping();
if ((dwMask & (CFM_CHARSET | CFM_FACE)) == (CFM_CHARSET | CFM_FACE))
{
if(GetAdjustedTextLength())
{
dwMask2 |= CFM2_MATCHFONT;
if (_fAutoFontSizeAdjust)
{
dwMask2 |= CFM2_ADJUSTFONTSIZE;
if (fUseUIFont())
dwMask2 |= CFM2_UIFONT;
}
}
else
dwMask2 |= CFM2_NOCHARSETCHECK;
}
fRet = (rg.SetCharFormat(pCF, 0, publdr, dwMask, dwMask2) == NOERROR);
// If we have an insertion point, apply format to it as well
if (_psel && !_psel->GetCch() &&
_psel->SetCharFormat(pCF, wparam, publdr, dwMask, dwMask2) != NOERROR)
{
fRet = FALSE;
}
}
else if(wparam & SCF_SELECTION)
{
// Change selection character format unless protected
if(!_psel || !IsRich())
return 0;
return _psel->SetCharFormat(pCF, wparam, publdr, dwMask, dwMask2)
== NOERROR;
}
// Change default character format
CCharFormat CF; // Local CF to party on
LONG iCF; // Possible new CF index
const CCharFormat *pCF1; // Ptr to current default CF
ICharFormatCache *pICFCache = GetCharFormatCache();
if(FAILED(pICFCache->Deref(Get_iCF(), &pCF1))) // Get ptr to current
{ // default CCharFormat
fRet = FALSE;
goto Update;
}
CF = *pCF1; // Copy current default CF
CF.Apply(pCF, dwMask, dwMask2); // Modify copy
if(FAILED(pICFCache->Cache(&CF, &iCF))) // Cache modified copy
{
fRet = FALSE;
goto Update;
}
#ifdef LINESERVICES
if (g_pols)
g_pols->DestroyLine(NULL);
#endif
pICFCache->Release(Get_iCF()); // Release _iCF regardless
Set_iCF(iCF); // of whether _iCF = iCF,
// i.e., only 1 ref count
if(_psel && !_psel->GetCch() && _psel->Get_iFormat() == -1)
_psel->UpdateCaret(FALSE);
if ((dwMask & (CFM_CHARSET | CFM_FACE)) == CFM_FACE &&
!GetFontName(pCF->_iFont)[0] && GetFontName(CF._iFont)[0] &&
IsBiDiCharSet(CF._bCharSet))
{
// Client requested font/charset be chosen for it according to thread
// locale. If BiDi, then also set RTL para default
CParaFormat PF;
PF._wEffects = PFE_RTLPARA;
OnSetParaFormat(SPF_SETDEFAULT, &PF, publdr, PFM_RTLPARA | PFM_PARAFORMAT);
}
Update:
// FUTURE (alexgo): this may be unnecessary if the display handles
// updating more automatically.
_pdp->UpdateView();
return fRet;
}
/*
* CTxtEdit::OnSetParaFormat(wparam, pPF, publdr, dwMask)
*
* @mfunc
* Set new default CParaFormat
*
* @rdesc
* LRESULT nonzero if success
*/
LRESULT CTxtEdit::OnSetParaFormat(
WPARAM wparam, //@parm wparam passed thru to IsProtected()
CParaFormat *pPF, //@parm CParaFormat to use
IUndoBuilder *publdr, //@parm Undobuilder to receive antievents
DWORD dwMask) //@parm Mask to use
{
TRACEBEGIN(TRCSUBSYSEDIT, TRCSCOPEINTERN, "CTxtEdit::OnSetParaFormat");
// If we're using context direction in the control, then we disallow
// the paragraph direction property and the alignment property (unless
// it's for center alignment).
if(IsStrongContext(_nContextDir) || IsStrongContext(_nContextAlign))
{
Assert(!IsRich());
if(dwMask & (PFM_RTLPARA | PFM_ALIGNMENT))
{
if (IsStrongContext(_nContextAlign) &&
(pPF->_bAlignment == PFA_LEFT || pPF->_bAlignment == PFA_RIGHT))
{
dwMask &= ~PFM_ALIGNMENT;
}
if(IsStrongContext(_nContextDir))
dwMask &= ~PFM_RTLPARA;
}
}
BOOL fMatchKbdToPara = FALSE;
if(dwMask & PFM_RTLPARA)
{
// In plain text allow DIR changes to change DIR and ALIGNMENT
if(!IsRich())
{
// Clear all para masks, except for DIR and ALIGN
dwMask &= (PFM_RTLPARA | PFM_ALIGNMENT);
wparam |= SPF_SETDEFAULT;
}
if(_psel && _fFocus)
fMatchKbdToPara = TRUE;
}
if(!(wparam & SPF_SETDEFAULT))
{
// If DEFAULT flag is specified, don't change selection
if(!_psel || IsProtected(EM_SETPARAFORMAT, wparam, (LPARAM)pPF))
return 0;
LRESULT lres = NOERROR == (pPF->fSetStyle(dwMask)
? _psel->SetParaStyle(pPF, publdr, dwMask)
: _psel->SetParaFormat(pPF, publdr, dwMask));
// This is a bit funky, but basically, if the text is empty
// then we also need to set the default paragraph format
// (done in the code below). Thus, if we hit a failure or
// if the document is not empty, go ahead and return.
// Otherwise, fall through to the default case.
if(!lres || GetAdjustedTextLength())
{
if(fMatchKbdToPara)
_psel->MatchKeyboardToPara();
return lres;
}
}
// No text in document or (wparam & SPF_SETDEFAULT): set default format
LONG iPF; // Possible new PF index
CParaFormat PF = *GetParaFormat(-1); // Local PF to party on
IParaFormatCache *pPFCache = GetParaFormatCache();
PF.Apply(pPF, dwMask); // Modify copy
if(FAILED(pPFCache->Cache(&PF, &iPF))) // Cache modified copy
return 0;
pPFCache->Release(Get_iPF()); // Release _iPF regardless of
Set_iPF(iPF); // Update default format index
if(PF.IsRtlPara())
OrCharFlags(fBIDI, publdr); // BiDi in backing store
if(!IsRich() && dwMask & PFM_RTLPARA) // Changing plain-text default PF
{
ItemizeDoc(publdr); // causing re-itemize the whole doc.
// (#6503) We cant undo the -1 format change in plaintext and that causes
// many problems when we undo ReplaceRange event happening before the paragraph
// switches. We better abandon the whole stack for now. (wchao)
// -FUTURE- We should create an antievent for -1 PF change.
ClearUndo(publdr);
}
_pdp->UpdateView();
if (_psel)
_psel->UpdateCaret(!Get10Mode() || _psel->IsCaretInView());
if(fMatchKbdToPara)
_psel->MatchKeyboardToPara();
return TRUE;
}
//////////////////////////////// System notifications ////////////////////////////////
LRESULT CTxtEdit::OnSetFocus()
{
TRACEBEGIN(TRCSUBSYSEDIT, TRCSCOPEINTERN, "CTxtEdit::OnSetFocus");
_fFocus = TRUE;
// Update our idea of the current keyboard layout
W32->RefreshKeyboardLayout();
InitKeyboardFlags();
if(!_psel)
return 0;
// _fMouseDown may sometimes be true.
// This can happen when somebody steals our focus when we were doing
// something with the mouse down--like processing a click. Thus, we'll
// never get the MouseUpMessage.
if(_fMouseDown)
{
TRACEWARNSZ("Getting the focus, yet we think the mouse is down");
}
_fMouseDown = FALSE;
// BUG FIX #5369
// Special case where we don't have a selection (or a caret). We need
// to display something on focus so display a caret
_psel->UpdateCaret(_fScrollCaretOnFocus, _psel->GetCch() == 0);
_fScrollCaretOnFocus = FALSE;
_psel->ShowSelection(TRUE);
// if there is an in-place active object, we need to set the focus to
// it. (in addition to the work that we do; this maintains compatibility
// with RichEdit 1.0).
if(_pobjmgr)
{
COleObject *pobj = _pobjmgr->GetInPlaceActiveObject();
if(pobj)
{
IOleInPlaceObject *pipobj;
if(pobj->GetIUnknown()->QueryInterface(IID_IOleInPlaceObject,
(void **)&pipobj) == NOERROR)
{
HWND hwnd;
pipobj->GetWindow(&hwnd);
if(hwnd)
SetFocus(hwnd);
pipobj->Release();
}
}
}
TxNotify(EN_SETFOCUS, NULL);
return 0;
}
LRESULT CTxtEdit::OnKillFocus()
{
TRACEBEGIN(TRCSUBSYSEDIT, TRCSCOPEINTERN, "CTxtEdit::OnKillFocus");
StopMagellanScroll();
if(_pundo)
_pundo->StopGroupTyping();
if(_psel)
{
// Scroll back to beginning if necessary
if (_fScrollCPOnKillFocus)
{
bool fHideSelectionLocal = _fHideSelection;
// cannot hide Selection so cp=0 will be scroll into view.
_fHideSelection = 0;
OnSetSel(0, 0);
_fHideSelection = fHideSelectionLocal;
}
_psel->DeleteCaretBitmap(TRUE); // Delete caret bitmap if one exists
if(_fHideSelection)
_psel->ShowSelection(FALSE);
}
_fFocus = FALSE;
DestroyCaret();
TxNotify(EN_KILLFOCUS, NULL);
_fScrollCaretOnFocus = FALSE; // Just to be safe, clear this
return 0;
}
#if defined(DEBUG)
void CTxtEdit::OnDumpPed()
{
#ifndef NOPEDDUMP
TRACEBEGIN(TRCSUBSYSEDIT, TRCSCOPEINTERN, "CTxtEdit::OnDumpPed");
char sz[256];
CTxtSelection * const psel = GetSel();
SELCHANGE selchg;
psel->SetSelectionInfo(&selchg);
wsprintfA(sz,
"cchText = %ld cchTextMost = %ld\r\n"
"cpSelActive = %ld cchSel = %ld\r\n"
"wSelType = %x # lines = %ld\r\n"
"SysDefLCID = %lx UserDefLCID = %lx",
GetTextLength(), TxGetMaxLength(),
psel->GetCp(), psel->GetCch(),
selchg.seltyp, _pdp->LineCount(),
GetSystemDefaultLCID(), GetUserDefaultLCID()
);
Tracef(TRCSEVINFO, "%s", sz);
MessageBoxA(0, sz, "ED", MB_OK);
#endif // NOPEDDUMP
}
#endif // DEBUG
///////////////////////////// Scrolling Commands //////////////////////////////////////
HRESULT CTxtEdit::TxHScroll(
WORD wCode,
int xPos)
{
TRACEBEGIN(TRCSUBSYSEDIT, TRCSCOPEINTERN, "CTxtEdit::TxHScroll");
if(!fInplaceActive())
return OLE_E_INVALIDRECT;
_pdp->HScroll(wCode, xPos);
return S_OK;
}
LRESULT CTxtEdit::TxVScroll(
WORD wCode,
int yPos)
{
TRACEBEGIN(TRCSUBSYSEDIT, TRCSCOPEINTERN, "CTxtEdit::TxVScroll");
return _pdp->VScroll(wCode, yPos);
}
HRESULT CTxtEdit::TxLineScroll(
LONG cli,
LONG cch)
{
TRACEBEGIN(TRCSUBSYSEDIT, TRCSCOPEINTERN, "CTxtEdit::TxLineScroll");
// Currently cch does nothing in the following call, so we ignore
// its translation from cach to cch (need to instantiate an rtp
// for the current line
_pdp->LineScroll(cli, cch);
return S_OK;
}
void CTxtEdit::OnScrollCaret()
{
TRACEBEGIN(TRCSUBSYSEDIT, TRCSCOPEINTERN, "CTxtEdit::OnScrollCaret");
if(_psel)
{
_psel->SetForceScrollCaret(TRUE);
_psel->UpdateCaret(TRUE);
_psel->SetForceScrollCaret(FALSE);
}
}
///////////////////////////////// Editing messages /////////////////////////////////
void CTxtEdit::OnClear(
IUndoBuilder *publdr)
{
TRACEBEGIN(TRCSUBSYSEDIT, TRCSCOPEINTERN, "CTxtEdit::OnClear");
if(!_psel || TxGetReadOnly())
{
Beep();
return;
}
if(_psel->GetCch() && !IsProtected(WM_CLEAR, 0, 0))
{
_psel->StopGroupTyping();
_psel->ReplaceRange(0, NULL, publdr, SELRR_REMEMBERRANGE);
}
}
void CTxtEdit::Beep()
{
if(_fAllowBeep)
MessageBeep(0);
}
/////////////////////////////////// Miscellaneous ///////////////////////////////////////////
/*
* CTxtEdit::ItemizeDoc(publdr, cchRange)
*
* @mfunc
* Helper routine to itemize the cchRange size of document content
* called by various clients outside CTxtRange.
*/
void CTxtEdit::ItemizeDoc(
IUndoBuilder * publdr,
LONG cchRange)
{
// If cchRange = -1, itemize the whole doc
if (cchRange == -1)
cchRange = GetTextLength();
// We wouldnt itemize if the doc only contains a single EOP
// because we dont want Check_rpPF being called when the -1
// PF format hasnt been properly established.
// This is kind of hack, should be removed in the future.
//
if(cchRange && GetAdjustedTextLength())
{ // Only itemize if more than
CTxtRange rg(this, 0, -cchRange); // final EOP
rg.ItemizeRuns(publdr);
}
#if 0
// =FUTURE=
// Once we open SPF_SETDEFAULT to public. We shall incorporate this code.
// Basically, one can change the default paragraph reading order at runtime. All
// PF runs referencing to -1 PF format then need to be reassigned a new paragraph
// level value and reitemized.(6-10-99, wchao)
//
if(cchRange > 0)
{
CTxtRange rg(this, 0, -cchRange);
// -1 PF format may have changed.
// We shall make sure that the level of each PF run match the reading order
// before start itemization.
//
if (rg.Check_rpPF())
{
LONG cchLeft = cchRange;
LONG cchAdvance = 0;
LONG cch;
while (cchLeft > 0)
{
rg._rpPF.GetRun(0)->_level._value = rg.IsParaRTL() ? 1 : 0;
cch = rg._rpPF.GetCchLeft();
if (!rg._rpPF.NextRun())
break; // no more run
cchAdvance += cch;
cchLeft -= cch;
}
Assert (cchAdvance + cchLeft == cchRange);
rg._rpPF.AdvanceCp(-cchAdvance); // fly back to cp = 0
}
// Now we rerun itemization
rg.ItemizeRuns(publdr);
}
#endif
}
/*
* CTxtEdit::OrCharFlags(dwFlags, publdr)
*
* @mfunc
* Or in new char flags and activate LineServices and Uniscribe
* if complex script chars occur.
*/
void CTxtEdit::OrCharFlags(
DWORD dwFlags,
IUndoBuilder* publdr)
{
// REVIEW: Should we send a notification for LS turn on?
// Convert dwFlags to new on flags
dwFlags &= dwFlags ^ _dwCharFlags;
if(dwFlags)
{
_dwCharFlags |= dwFlags; // Update flags
dwFlags &= fCOMPLEX_SCRIPT;
if(dwFlags && (_dwCharFlags & fCOMPLEX_SCRIPT) == dwFlags)
{
// REVIEW: Need to check if Uniscribe and LineServices are available...
OnSetTypographyOptions(TO_ADVANCEDTYPOGRAPHY, TO_ADVANCEDTYPOGRAPHY);
ItemizeDoc();
// FUTURE: (#6838) We cant undo operations before the first itemization.
ClearUndo(publdr);
_fAutoKeyboard = IsBiDi();
}
UINT brk = 0;
if (dwFlags & fNEEDWORDBREAK)
brk += BRK_WORD;
if (dwFlags & fNEEDCHARBREAK)
brk += BRK_CLUSTER;
if (brk)
{
CUniscribe* pusp = Getusp();
if (!_pbrk && pusp && pusp->IsValid())
{
// First time detecting the script that needs word/cluster-breaker
// (such as Thai, Indic, Lao etc.)
_pbrk = new CTxtBreaker(this);
Assert(_pbrk);
}
if (_pbrk && _pbrk->AddBreaker(brk))
{
// Sync up the breaking array(s)
_pbrk->Refresh();
}
}
}
}
/*
* CTxtEdit::OnSetTypographyOptions(wparam, lparam)
*
* @mfunc
* If CTxtEdit isn't a password or accelerator control and wparam
* differs from _bTypography, update the latter and the view.
*
* @rdesc
* HRESULT = S_OK
*/
HRESULT CTxtEdit::OnSetTypographyOptions(
WPARAM wparam, //@parm Typography flags
LPARAM lparam) //@parm Typography mask
{
// Currently only TO_SIMPLELINEBREAK and TO_ADVANCEDTYPOGRAPHY are defined
if(wparam & ~(TO_SIMPLELINEBREAK | TO_ADVANCEDTYPOGRAPHY))
return E_INVALIDARG;
DWORD dwTypography = _bTypography & ~lparam; // Kill current flag values
dwTypography |= wparam & lparam; // Or in new values
if(_cpAccelerator == -1 && _bTypography != (BYTE)dwTypography)
{
_bTypography = (BYTE)dwTypography;
_pdp->InvalidateRecalc();
TxInvalidateRect(NULL, FALSE);
}
return S_OK;
}
void CTxtEdit::TxGetViewInset(
LPRECT prc,
CDisplay *pdp) const
{
TRACEBEGIN(TRCSUBSYSEDIT, TRCSCOPEINTERN, "CTxtEdit::TxGetViewInset");
// Get inset, which is in HIMETRIC
RECT rcHiMetricViewInset;
if(SUCCEEDED(_phost->TxGetViewInset(&rcHiMetricViewInset)))
{
LONG vileft = rcHiMetricViewInset.left;
LONG vitop = rcHiMetricViewInset.top;
LONG viright = rcHiMetricViewInset.right;
LONG vibottom = rcHiMetricViewInset.bottom;
if(!pdp) // If no display is specified,
pdp = _pdp; // use main display
AssertSz(pdp->IsValid(), "CTxtEdit::TxGetViewInset Device not valid");
// Convert HIMETRIC to pixels
prc->left = vileft ? pdp->HimetricXtoDX( vileft ) : 0;
prc->top = vitop ? pdp->HimetricYtoDY(rcHiMetricViewInset.top) : 0;
prc->right = viright ? pdp->HimetricXtoDX(rcHiMetricViewInset.right) : 0;
prc->bottom = vibottom ? pdp->HimetricYtoDY(rcHiMetricViewInset.bottom) : 0;
}
else
{
// The call to the host failed. While this is highly improbable, we do
// want to something reasonably sensible. Therefore, we will just pretend
// there is no inset and continue.
ZeroMemory(prc, sizeof(RECT));
}
}
#if 0
// Interchange horizontal and vertical commands
WORD wConvScroll(WORD wparam)
{
TRACEBEGIN(TRCSUBSYSEDIT, TRCSCOPEINTERN, "wConvScroll");
switch(wparam)
{
case SB_BOTTOM:
return SB_TOP;
case SB_LINEDOWN:
return SB_LINEUP;
case SB_LINEUP:
return SB_LINEDOWN;
case SB_PAGEDOWN:
return SB_PAGEUP;
case SB_PAGEUP:
return SB_PAGEDOWN;
case SB_TOP:
return SB_BOTTOM;
default:
return wparam;
}
}
#endif
//
// helper functions. FUTURE (alexgo) maybe we should get rid of
// some of these
//
/* FUTURE (murrays): Unless they are called a lot, the TxGetBit routines
might be done more compactly as:
BOOL CTxtEdit::TxGetBit(
DWORD dwMask)
{
DWORD dwBits = 0;
_phost->TxGetPropertyBits(dwMask, &dwBits);
return dwBits != 0;
}
e.g., instead of TxGetSelectionBar(), we use TxGetBit(TXTBIT_SELECTIONBAR).
If they are called a lot (like TxGetSelectionBar()), the bits should probably
be cached, since that saves a bunch of cache misses incurred in going over to
the host.
*/
BOOL CTxtEdit::IsLeftScrollbar() const
{
if(!_fHost2)
return FALSE;
DWORD dwStyle, dwExStyle;
_phost->TxGetWindowStyles(&dwStyle, &dwExStyle);
return dwExStyle & WS_EX_LEFTSCROLLBAR;
}
TXTBACKSTYLE CTxtEdit::TxGetBackStyle() const
{
TRACEBEGIN(TRCSUBSYSEDIT, TRCSCOPEINTERN, "CTxtEdit::TxGetBackStyle");
TXTBACKSTYLE style = TXTBACK_OPAQUE;
_phost->TxGetBackStyle(&style);
return style;
}
BOOL CTxtEdit::TxGetAutoSize() const
{
TRACEBEGIN(TRCSUBSYSEDIT, TRCSCOPEINTERN, "CTxtEdit::TxGetAutoSize");
return (_dwEventMask & ENM_REQUESTRESIZE);
}
BOOL CTxtEdit::TxGetAutoWordSel() const
{
TRACEBEGIN(TRCSUBSYSEDIT, TRCSCOPEINTERN, "CTxtEdit::TxGetAutoWordSel");
DWORD dwBits = 0;
_phost->TxGetPropertyBits(TXTBIT_AUTOWORDSEL, &dwBits);
return dwBits != 0;
}
DWORD CTxtEdit::TxGetMaxLength() const
{
TRACEBEGIN(TRCSUBSYSEDIT, TRCSCOPEINTERN, "CTxtEdit::TxGetMaxLength");
// Keep this a DWORD in case client uses a cpMost of 0xFFFFFFFF, which is
// admittedly a little large, at least for 32-bit address spaces!
// tomForward would be a more reasonable max length, altho it's also
// probably larger than possible in a 32-bit address space.
return _cchTextMost;
}
/*
* CTxtEdit::TxSetMaxToMaxText(LONG cExtra)
*
* @mfunc
* Set new maximum text length based on length of text and possibly extra chars
* to accomodate.
*
*/
void CTxtEdit::TxSetMaxToMaxText(LONG cExtra)
{
TRACEBEGIN(TRCSUBSYSEDIT, TRCSCOPEINTERN, "CTxtEdit::TxSetMaxToMaxText");
// See if we need to update the text max
LONG cchRealLen = GetAdjustedTextLength() + cExtra;
if(_fInOurHost && _cchTextMost < (DWORD)cchRealLen)
_cchTextMost = cchRealLen;
}
TCHAR CTxtEdit::TxGetPasswordChar() const
{
TRACEBEGIN(TRCSUBSYSEDIT, TRCSCOPEINTERN, "CTxtEdit::TxGetPasswordChar");
if(_fUsePassword)
{
TCHAR ch = L'*';
_phost->TxGetPasswordChar(&ch);
// We don't allow these characters as password chars
if(ch < 32 || ch == WCH_EMBEDDING)
return L'*';
return ch;
}
return 0;
}
DWORD CTxtEdit::TxGetScrollBars() const
{
TRACEBEGIN(TRCSUBSYSEDIT, TRCSCOPEINTERN, "CTxtEdit::TxGetScrollBars");
DWORD dwScroll;
_phost->TxGetScrollBars(&dwScroll);
return dwScroll;
}
LONG CTxtEdit::TxGetSelectionBarWidth() const
{
TRACEBEGIN(TRCSUBSYSEDIT, TRCSCOPEINTERN, "CTxtEdit::TxGetSelectionBarWidth");
LONG lSelBarWidth;
_phost->TxGetSelectionBarWidth(&lSelBarWidth);
return lSelBarWidth;
}
BOOL CTxtEdit::TxGetWordWrap() const
{
TRACEBEGIN(TRCSUBSYSEDIT, TRCSCOPEINTERN, "CTxtEdit::TxGetWordWrap");
DWORD dwBits = 0;
_phost->TxGetPropertyBits(TXTBIT_WORDWRAP, &dwBits);
return dwBits != 0;
}
BOOL CTxtEdit::TxGetSaveSelection() const
{
TRACEBEGIN(TRCSUBSYSEDIT, TRCSCOPEINTERN, "CTxtEdit::TxGetSaveSelection");
DWORD dwBits = 0;
_phost->TxGetPropertyBits(TXTBIT_SAVESELECTION, &dwBits);
return dwBits != 0;
}
/*
* CTxtEdit::ClearUndo()
*
* @mfunc Clear all undo buffers
*/
void CTxtEdit::ClearUndo(
IUndoBuilder *publdr) //@parm the current undo context (may be NULL)
{
TRACEBEGIN(TRCSUBSYSEDIT, TRCSCOPEINTERN, "CTxtEdit::ClearUndo");
if(_pundo)
_pundo->ClearAll();
if(_predo)
_predo->ClearAll();
if(publdr)
publdr->Discard();
}
/////////////////////////////// ITextHost2 Extensions //////////////////////////////
/*
* CTxtEdit::TxIsDoubleClickPending ()
*
* @mfunc calls host via ITextHost2 to find out if double click is pending.
*
* @rdesc TRUE/FALSE
*/
BOOL CTxtEdit::TxIsDoubleClickPending()
{
return _fHost2 ? _phost->TxIsDoubleClickPending() : FALSE;
}
/*
* CTxtEdit::TxGetWindow(phwnd)
*
* @mfunc calls host via ITextHost2 to get current window for this edit
* instance. This is very helpful for OLE object support
*
* @rdesc HRESULT
*/
HRESULT CTxtEdit::TxGetWindow(
HWND *phwnd)
{
return _fHost2 ? _phost->TxGetWindow(phwnd) : E_NOINTERFACE;
}
/*
* CTxtEdit::TxSetForegroundWindow ()
*
* @mfunc calls host via ITextHost2 to make our window the foreground
* window. Used to support drag/drop.
*
* @rdesc HRESULT
*/
HRESULT CTxtEdit::TxSetForegroundWindow()
{
return _fHost2 ? _phost->TxSetForegroundWindow() : E_NOINTERFACE;
}
/*
* CTxtEdit::TxGetPalette()
*
* @mfunc calls host via ITextHost2 to get current palette
*
* @rdesc HPALETTE
*/
HPALETTE CTxtEdit::TxGetPalette()
{
return _fHost2 ? _phost->TxGetPalette() : NULL;
}
/*
* CTxtEdit::TxGetFEFlags(pFEFlags)
*
* @mfunc calls host via ITextHost2 to get current FE settings
*
* @rdesc HRESULT
*/
HRESULT CTxtEdit::TxGetFEFlags(
LONG *pFEFlags)
{
*pFEFlags = 0; // In case no ITextHost2 methods
HRESULT hResult = _fHost2 ? _phost->TxGetFEFlags(pFEFlags) : E_NOINTERFACE;
if (hResult == NOERROR && Get10Mode())
*pFEFlags |= tomRE10Mode;
return hResult;
}
//
// Event Notification methods
//
/*
* CTxtEdit::TxNotify(iNotify, pv)
*
* @mfunc This function checks bit masks and sends notifications to the
* host.
*
* @devnote Callers should check to see if a special purpose notification
* method has already been provided.
*
* @rdesc S_OK, S_FALSE, or some error
*/
HRESULT CTxtEdit::TxNotify(
DWORD iNotify, //@parm Notification to send
void *pv) //@parm Data associated with notification
{
// First, disallow notifications that we handle elsewhere
Assert(iNotify != EN_SELCHANGE); //see SetSelectionChanged
Assert(iNotify != EN_ERRSPACE); //see SetOutOfMemory
Assert(iNotify != EN_CHANGE); //see SetChangedEvent
Assert(iNotify != EN_HSCROLL); //see SendScrollEvent
Assert(iNotify != EN_VSCROLL); //see SendScrollEvent
Assert(iNotify != EN_MAXTEXT); //see SetMaxText
Assert(iNotify != EN_MSGFILTER); //this is handled specially
// in TxSendMessage
// Switch on the event to check masks.
DWORD dwMask;
switch(iNotify)
{
case EN_DROPFILES:
dwMask = ENM_DROPFILES;
goto Notify;
case EN_PROTECTED:
dwMask = ENM_PROTECTED;
goto Notify;
case EN_REQUESTRESIZE:
dwMask = ENM_REQUESTRESIZE;
goto Notify;
case EN_PARAGRAPHEXPANDED:
dwMask = ENM_PARAGRAPHEXPANDED;
goto Notify;
case EN_IMECHANGE:
if (!Get10Mode())
return S_FALSE;
dwMask = ENM_IMECHANGE;
goto Notify;
case EN_UPDATE:
if (!Get10Mode())
break;
dwMask = ENM_UPDATE;
//FALL THROUGH CASE
Notify:
if(!(_dwEventMask & dwMask))
return NOERROR;
}
return _phost->TxNotify(iNotify, pv);
}
/*
* CTxtEdit::SendScrollEvent(iNotify)
*
* @mfunc Sends scroll event if appropriate
*
* @comm Scroll events must be sent before any view updates have
* been requested and only if ENM_SCROLL is set.
*/
void CTxtEdit::SendScrollEvent(
DWORD iNotify) //@parm Notification to send
{
Assert(iNotify == EN_HSCROLL || iNotify == EN_VSCROLL);
// FUTURE (alexgo/ricksa). The display code can't really
// handle this assert yet. Basically, we're trying to
// say that scrollbar notifications have to happen
// _before_ the window is updated. When we do the
// display rewrite, try to handle this better.
// Assert(_fUpdateRequested == FALSE);
if(_dwEventMask & ENM_SCROLL)
_phost->TxNotify(iNotify, NULL);
}
/*
* CTxtEdit::HandleLinkNotification (msg, wparam, lparam, pfInLink)
*
* @mfunc Handles sending EN_LINK notifications.
*
* @rdesc TRUE if the EN_LINK message was sent and
* processed successfully. Typically, that means the
* caller should stop whatever processing it was doing.
*/
BOOL CTxtEdit::HandleLinkNotification(
UINT msg, //@parm msg prompting the link notification
WPARAM wparam, //@parm wparam of the message
LPARAM lparam, //@parm lparam of the message
BOOL * pfInLink) //@parm if non-NULL, indicate if over a link
{
if(pfInLink)
*pfInLink = FALSE;
if(!(_dwEventMask & ENM_LINK) || !_fInPlaceActive)
return FALSE;
HITTEST Hit;
POINT pt = {LOWORD(lparam), HIWORD(lparam)};
if(msg == WM_SETCURSOR)
{
GetCursorPos(&pt);
if(!_phost->TxScreenToClient(&pt))
return FALSE;
}
LONG cp = _pdp->CpFromPoint(pt, NULL, NULL, NULL, FALSE, &Hit);
if(Hit != HT_Link) // Not a hyperlink
return FALSE;
LONG cpMin, cpMost; // It's a hyperlink
ENLINK enlink;
CTxtRange rg(this, cp, 0);
ZeroMemory(&enlink, sizeof(enlink));
if (fInOurHost())
{
GetWindow((LONG *) &enlink.nmhdr.hwndFrom);
enlink.nmhdr.idFrom = GetWindowLong(enlink.nmhdr.hwndFrom, GWL_ID);
}
enlink.nmhdr.code = EN_LINK;
if(pfInLink)
*pfInLink = TRUE;
rg.Expander(tomLink, TRUE, NULL, &cpMin, &cpMost);
// Fill in ENLINK data structure for our EN_LINK
// callback asking client what we should do
enlink.msg = msg;
enlink.wParam = wparam;
enlink.lParam = lparam;
enlink.chrg.cpMin = GetAcpFromCp(cpMin);
enlink.chrg.cpMost = GetAcpFromCp(cpMost);
return _phost->TxNotify(EN_LINK, &enlink) == S_FALSE;
}
/*
* CTxtEdit::QueryUseProtection(prg, msg, wparam, lparam)
*
* @mfunc sends EN_PROTECTED to the host, asking if we should continue
* to honor the protection on a given range of characters
*
* @rdesc TRUE if protection should be honored, FALSE otherwise
*/
BOOL CTxtEdit::QueryUseProtection(
CTxtRange *prg, //@parm range to check for
UINT msg, //@parm msg used
WPARAM wparam, //@parm wparam of the msg
LPARAM lparam) //@parm lparam of the msg
{
LONG cpMin, cpMost;
ENPROTECTED enp;
BOOL fRet = FALSE;
CCallMgr * pcallmgr = GetCallMgr();
Assert(_dwEventMask & ENM_PROTECTED);
if( pcallmgr->GetInProtected() ||
_fSuppressNotify) // Don't ask host if we don't want to send notification
return FALSE;
pcallmgr->SetInProtected(TRUE);
ZeroMemory(&enp, sizeof(ENPROTECTED));
prg->GetRange(cpMin, cpMost);
enp.msg = msg;
enp.wParam = wparam;
enp.lParam = lparam;
enp.chrg.cpMin = GetAcpFromCp(cpMin);
enp.chrg.cpMost = GetAcpFromCp(cpMost);
if(_phost->TxNotify(EN_PROTECTED, &enp) == S_FALSE)
fRet = TRUE;
pcallmgr->SetInProtected(FALSE);
return fRet;
}
#ifdef DEBUG
//This is a debug api used to dump the document runs.
//If a pointer to the ped is passed, it is saved and
//used. If NULL is passed, the previously saved ped
//pointer is used. This allows the "context" to be
//setup by a function that has access to the ped and
//DumpDoc can be called lower down in a function that
//does not have access to the ped.
extern "C" {
void DumpStory(void *ped)
{
static CTxtEdit *pedSave = (CTxtEdit *)ped;
if(pedSave)
{
CTxtStory * pStory = pedSave->GetTxtStory();
if(pStory)
pStory->DbgDumpStory();
CObjectMgr * pobjmgr = pedSave->GetObjectMgr();
if(pobjmgr)
pobjmgr->DbgDump();
}
}
}
#endif
/*
* CTxtEdit::TxGetDefaultCharFormat (pCF)
*
* @mfunc helper function to retrieve character formats from the
* host. Does relevant argument checking
*
* @rdesc HRESULT
*/
HRESULT CTxtEdit::TxGetDefaultCharFormat(
CCharFormat *pCF, //@parm Character format to fill in
DWORD & dwMask) //@parm Mask supplied by host or default
{
HRESULT hr = pCF->InitDefault(0);
dwMask = CFM_ALL2;
const CHARFORMAT2 *pCF2 = NULL;
if (_phost->TxGetCharFormat((const CHARFORMAT **)&pCF2) != NOERROR ||
!IsValidCharFormatW(pCF2))
{
return hr;
}
dwMask = pCF2->dwMask;
DWORD dwMask2 = 0;
if(pCF2->cbSize == sizeof(CHARFORMAT))
{
// Suppress CHARFORMAT2 specifications (except for Forms^3 disabled)
dwMask &= fInOurHost() ? CFM_ALL : (CFM_ALL | CFM_DISABLED);
dwMask2 = CFM2_CHARFORMAT;
}
CCharFormat CF; // Transfer external CHARFORMAT(2)
CF.Set(pCF2, 1200); // parms to internal CCharFormat
return pCF->Apply(&CF, dwMask, dwMask2);
}
/*
* CTxtEdit::TxGetDefaultParaFormat (pPF)
*
* @mfunc helper function to retrieve paragraph formats. Does
* the relevant argument checking.
*
* @rdesc HRESULT
*/
HRESULT CTxtEdit::TxGetDefaultParaFormat(
CParaFormat *pPF) //@parm Paragraph format to fill in
{
HRESULT hr = pPF->InitDefault(0);
const PARAFORMAT2 *pPF2 = NULL;
if (_phost->TxGetParaFormat((const PARAFORMAT **)&pPF2) != NOERROR ||
!IsValidParaFormat(pPF2))
{
return hr;
}
DWORD dwMask = pPF2->dwMask;
if(pPF2->cbSize == sizeof(PARAFORMAT)) // Suppress all but PARAFORMAT
{ // specifications
dwMask &= PFM_ALL;
dwMask |= PFM_PARAFORMAT; // Tell Apply() that PARAFORMAT
} // was used
CParaFormat PF; // Transfer external PARAFORMAT(2)
PF.Set(pPF2); // parms to internal CParaFormat
return pPF->Apply(&PF, dwMask); // Apply parms identified by dwMask
}
/*
* CTxtEdit::SetContextDirection(fUseKbd)
*
* @mfunc
* Determine the paragraph direction and/or alignment based on the context
* rules (direction/alignment follows first strong character in the
* control) and apply this direction and/or alignment to the default
* format.
*
* @comment
* Context direction only works for plain text controls. Note that
* this routine only switches the default CParaFormat to RTL para if it
* finds an RTL char. IsBiDi() will automatically be TRUE for this case,
* since each char is checked before entering the backing store.
*/
void CTxtEdit::SetContextDirection(
BOOL fUseKbd) //@parm Use keyboard to set context when CTX_NEUTRAL
{
// It turns out that Forms^3 can send EM_SETBIDIOPTIONS even for non BiDi controls.
// AssertSz(IsBiDi(), "CTxtEdit::SetContextDirection called for nonBiDi control");
if(IsRich() || !IsBiDi() || _nContextDir == CTX_NONE && _nContextAlign == CTX_NONE)
return;
LONG cch = GetTextLength();
CTxtPtr tp(this, 0);
TCHAR ch = tp.GetChar();
WORD ctx = CTX_NEUTRAL;
BOOL fChanged = FALSE;
// Find first strongly directional character
while (cch && !IsStrongDirectional(MECharClass(ch)))
{
ch = tp.NextChar();
cch--;
}
// Set new context based on first strong character
if(cch)
ctx = IsRTL(MECharClass(ch)) ? CTX_RTL : CTX_LTR;
// Has context direction or alignment changed?
if (_nContextDir != CTX_NONE && _nContextDir != ctx ||
_nContextAlign != CTX_NONE && _nContextAlign != ctx)
{
// Start with current default CParaFormat
CParaFormat PF = *GetParaFormat(-1);
// If direction has changed...
if(_nContextDir != CTX_NONE && _nContextDir != ctx)
{
if(ctx == CTX_LTR || ctx == CTX_RTL || fUseKbd)
{
if (ctx == CTX_RTL ||
ctx == CTX_NEUTRAL && W32->IsBiDiLcid(LOWORD(GetKeyboardLayout(0))))
{
PF._wEffects |= PFE_RTLPARA;
}
else
{
Assert(ctx == CTX_LTR || ctx == CTX_NEUTRAL);
PF._wEffects &= ~PFE_RTLPARA;
}
fChanged = TRUE;
}
_nContextDir = ctx;
}
// If the alignment has changed...
if(_nContextAlign != CTX_NONE && _nContextAlign != ctx)
{
if(PF._bAlignment != PFA_CENTER)
{
if(ctx == CTX_LTR || ctx == CTX_RTL || fUseKbd)
{
if (ctx == CTX_RTL ||
ctx == CTX_NEUTRAL && W32->IsBiDiLcid(LOWORD(GetKeyboardLayout(0))))
{
PF._bAlignment = PFA_RIGHT;
}
else
{
Assert(ctx == CTX_LTR || ctx == CTX_NEUTRAL);
PF._bAlignment = PFA_LEFT;
}
}
}
_nContextAlign = ctx;
}
// Modify default CParaFormat
IParaFormatCache *pPFCache = GetParaFormatCache();
LONG iPF;
if(SUCCEEDED(pPFCache->Cache(&PF, &iPF)))
{
pPFCache->Release(Get_iPF()); // Release _iPF regardless of
Set_iPF(iPF); // Update default format index
if (fChanged)
ItemizeDoc(NULL);
// Refresh display
Assert(_pdp);
if(!_pdp->IsPrinter())
{
_pdp->InvalidateRecalc();
TxInvalidateRect(NULL, FALSE);
}
}
}
// Reset the first strong cp.
_cpFirstStrong = tp.GetCp();
Assert(_nContextDir != CTX_NONE || _nContextAlign != CTX_NONE);
}
/*
* CTxtEdit::GetAdjustedTextLength ()
*
* @mfunc
* retrieve text length adjusted for the default end-of-document marker
*
* @rdesc
* Text length without final EOP
*
* @devnote
* For Word and RichEdit compatibility, we insert a CR or CRLF at the
* end of every new rich-text control. This routine calculates the
* length of the document _without_ this final EOD marker.
*
* For 1.0 compatibility, we insert a CRLF. However, TOM (and Word)
* requires that we use a CR, from 2.0 on, we do that instead.
*/
LONG CTxtEdit::GetAdjustedTextLength()
{
LONG cchAdjText = GetTextLength();
Assert(!Get10Mode() || IsRich()); // No RE10 plain-text controls
if(IsRich())
cchAdjText -= fUseCRLF() ? 2 : 1; // Subtract cch of final EOP
return cchAdjText;
}
/*
* CTxtEdit::Set10Mode()
*
* @mfunc
* Turns on the 1.0 compatibility mode bit. If the control is
* rich text, it already has a default 'CR' at the end, which
* needs to turn into a CRLF for compatibility with RichEdit 1.0.
*
* @devnote
* This function should only be called _immediately_ after
* creation of text services and before all other work. There
* are Asserts to help ensure this. Remark (murrays): why not
* allow the change provided the control is empty except for the
* final CR?
*
* FUTURE: we might want to split _f10Mode into three flags:
* 1) _fMapCps // API cp's are MBCS and need conversion to Unicode
* 2) _fCRLF // Use CRLFs for EOPs instead of CRs
* 3) _f10Mode // All other RE 1.0 compatibility things
*
* Category 3 includes 1) automatically using FR_DOWN in searches,
* 2) ignoring direction in CDataTransferObj::EnumFormatEtc(),
* 3) not resetting _fModified when switching to a new doc,
*/
void CTxtEdit::Set10Mode()
{
CCallMgr callmgr(this);
_f10Mode = TRUE;
// Make sure nothing important has happened to the control.
// If these values are non-NULL, then somebody is probably trying
// to put us into 1.0 mode after we've already done work as
// a 2.0 control.
Assert(GetTextLength() == cchCR);
Assert(_psel == NULL);
Assert(_fModified == NULL);
SetRichDocEndEOP(cchCR);
if(!_pundo)
CreateUndoMgr(1, US_UNDO);
if(_pundo)
((CUndoStack *)_pundo)->EnableSingleLevelMode();
// Turn off dual font
_fDualFont = FALSE;
// Turn on auto sizing for NTFE systems
if (OnWinNTFE())
_fAutoFontSizeAdjust = TRUE;
}
/*
* CTxtEdit::SetRichDocEndEOP(cchToReplace)
*
* @mfunc Place automatic EOP at end of a rich text document.
*/
void CTxtEdit::SetRichDocEndEOP(
LONG cchToReplace)
{
CRchTxtPtr rtp(this, 0);
// Assume this is a 2.0 Doc
LONG cchEOP = cchCR;
const WCHAR *pszEOP = szCR;
if(_f10Mode)
{
// Reset update values for a 1.0 doc
cchEOP = cchCRLF;
pszEOP = szCRLF;
}
rtp.ReplaceRange(cchToReplace, cchEOP, pszEOP, NULL, -1);
_fModified = FALSE;
_fSaved = TRUE;
GetCallMgr()->ClearChangeEvent();
}
/*
* CTxtEdit::PopAndExecuteAntiEvent(pundomgr, void *pAE)
*
* @mfunc Freeze display and execute anti-event
*
* @rdesc HRESULT from IUndoMgr::PopAndExecuteAntiEvent
*/
HRESULT CTxtEdit::PopAndExecuteAntiEvent(
IUndoMgr *pundomgr, //@parm Undo manager to direct call to
void *pAE) //@parm AntiEvent for undo manager
{
HRESULT hr;
// Let stack based classes clean up before restoring selection
{
CFreezeDisplay fd(_pdp);
CSelPhaseAdjuster selpa(this);
hr = pundomgr->PopAndExecuteAntiEvent(pAE);
}
if(_psel)
{
// Once undo/redo has been executed, flush insertion point formatting
_psel->Update_iFormat(-1);
_psel->Update(TRUE);
}
return hr;
}
/*
* CTxtEdit::PasteDataObjectToRange(pdo, prg, cf, rps, publdr, dwFlags)
*
* @mfunc Freeze display and paste object
*
* @rdesc HRESULT from IDataTransferEngine::PasteDataObjectToRange
*/
HRESULT CTxtEdit::PasteDataObjectToRange(
IDataObject * pdo,
CTxtRange * prg,
CLIPFORMAT cf,
REPASTESPECIAL *rps,
IUndoBuilder * publdr,
DWORD dwFlags)
{
HRESULT hr = _ldte.PasteDataObjectToRange(pdo, prg, cf, rps, publdr,
dwFlags);
if(_psel)
_psel->Update(TRUE); // now update the caret
return hr;
}
/*
* GetECDefaultHeightAndWidth (pts, hdc, lZoomNumerator, lZoomDenominator,
* yPixelsPerInch, pxAveWidth, pxOverhang, pxUnderhang)
*
* @mfunc Helper for host to get ave char width and height for default
* character set for the control.
*
* @rdesc Height of default character set
*
* @devnote:
* This really only s/b called by the window's host.
*/
LONG GetECDefaultHeightAndWidth(
ITextServices *pts, //@parm ITextServices to conver to CTxtEdit.
HDC hdc, //@parm DC to use for retrieving the font.
LONG lZoomNumerator, //@parm Zoom numerator
LONG lZoomDenominator, //@parm Zoom denominator
LONG yPixelsPerInch, //@parm Pixels per inch for hdc
LONG *pxAveWidth, //@parm Optional ave width of character
LONG *pxOverhang, //@parm Optional overhang
LONG *pxUnderhang) //@parm Optional underhang
{
CLock lock; // Uses global (shared) FontCache
// Convert the text-edit ptr
CTxtEdit *ped = (CTxtEdit *) pts;
// Get the CCcs that has all the information we need
yPixelsPerInch = MulDiv(yPixelsPerInch, lZoomNumerator, lZoomDenominator);
CCcs *pccs = fc().GetCcs(ped->GetCharFormat(-1), yPixelsPerInch);
if(!pccs)
return 0;
if(pxAveWidth)
*pxAveWidth = pccs->_xAveCharWidth;
if(pxOverhang)
*pxOverhang = pccs->_xOverhang; // Return overhang
if(pxUnderhang)
*pxUnderhang = pccs->_xUnderhang; // Return underhang
SHORT yAdjustFE = pccs->AdjustFEHeight(!ped->fUseUIFont() && ped->_pdp->IsMultiLine());
LONG yHeight = pccs->_yHeight + (yAdjustFE << 1);
pccs->Release(); // Release the CCcs
return yHeight;
}
/*
* CTxtEdit::TxScrollWindowEx (dx, dy, lprcScroll, lprcClip, hrgnUpdate,
* lprcUpdate, fuScroll)
* @mfunc
* Request Text Host to scroll the content of the specified client area
*
* @comm
* This method is only valid when the control is in-place active;
* calls while inactive may fail.
*/
void CTxtEdit::TxScrollWindowEx (
INT dx, //@parm Amount of horizontal scrolling
INT dy, //@parm Amount of vertical scrolling
LPCRECT lprcScroll, //@parm Scroll rectangle
LPCRECT lprcClip, //@parm Clip rectangle
HRGN hrgnUpdate, //@parm Handle of update region
LPRECT lprcUpdate, //@parm Update rectangle
UINT fuScroll) //@parm Scrolling flags
{
TRACEBEGIN(TRCSUBSYSEDIT, TRCSCOPEEXTERN, "CTxtEdit::TxScrollWindowEx");
if(_fInPlaceActive)
{
#if !defined(NOMAGELLAN)
CMagellanBMPStateWrap bmpOff(*this, NULL);
#endif
_phost->TxScrollWindowEx(dx, dy, lprcScroll, lprcClip,
hrgnUpdate, lprcUpdate, fuScroll);
// Tell all objects that they may need to update their position
// RECTs if scrolling occurred.
if(_pobjmgr)
{
RECT rcClient;
if(!lprcScroll)
{
TxGetClientRect(&rcClient);
lprcScroll = &rcClient;
}
_pobjmgr->ScrollObjects(dx, dy, lprcScroll);
}
}
}
/*
* CTxtEdit::GetAcpFromCp (cp)
*
* @mfunc
* Get API cp (acp) from Unicode cp in this text instance. The API cp
* may be Unicode, in which case it equals cp, or MBCS, in which case
* it's greater than cp if any Unicode characters preceding cp convert
* to double-byte characters. An MBCS cp is the BYTE index of a character
* relative to the start of the story, while a Unicode cp is the character
* index. The values are the same if all charsets are represented by
* SBCS charsets, e.g., ASCII. If all characters are represented by
* double-byte characters, then acp = 2*cp.
*
* @rdesc
* MBCS Acp from Unicode cp in this text instance
*
* @devnote
* This could be made more efficient by having the selection maintain
* the acp that corresponds to its _rpTX._cp, provided RE 1.0 mode is
* active. Alternatively CTxtEdit could have a _prg that tracks this
* value, but at a higher cost (17 DWORDs instead of 1 per instance).
*
* FUTURE: we might want to have a conversion-mode state instead of just
* _f10Mode, since some people might want to know use MBCS cp's even in
* RE 3.0. If so, use the corresponding new state flag instead of
* Get10Mode() in the following.
*/
LONG CTxtEdit::GetAcpFromCp(
LONG cp, //@parm Unicode cp to convert to MBCS cp
BOOL fPrecise) //@parm fPrecise flag to get byte count for MBCS
{
if(!(IsFE() && (fCpMap() || fPrecise))) // RE 2.0 and higher use char-count
return cp; // cp's, while RE 1.0 uses byte
// counts
// bPrecise is for Ansi Apps that want byte counts
// (e.g. Outlook Subject line)
CRchTxtPtr rtp(this); // Start at cp = 0
return rtp.GetCachFromCch(cp);
}
LONG CTxtEdit::GetCpFromAcp(
LONG acp, //@parm MBCS cp to convert to Unicode cp
BOOL fPrecise) //@parm fPrecise flag to get Unicode cp for MBCS
{
if( acp == -1 || !(IsFE() && (fCpMap() || fPrecise)))
return acp;
CRchTxtPtr rtp(this); // Start at cp = 0
return rtp.GetCchFromCach(acp);
}
/*
* CTxtEdit::GetViewKind (plres)
*
* @mfunc
* get view mode
*
* @rdesc
* HRESULT = (plres) ? NOERROR : E_INVALIDARG
*
* @devnote
* This could be a TOM property method (along with SetViewMode())
*/
HRESULT CTxtEdit::GetViewKind(
LRESULT *plres) //@parm Out parm to receive view mode
{
TRACEBEGIN(TRCSUBSYSEDIT, TRCSCOPEINTERN, "CTxtEdit::GetViewKind");
if(!plres)
return E_INVALIDARG;
*plres = IsInOutlineView() ? VM_OUTLINE : VM_NORMAL;
return NOERROR;
}
/*
* CTxtEdit::SetViewKind (Value)
*
* @mfunc
* Turn outline mode on or off
*
* @rdesc
* HRESULT = IsRich() ? NOERROR : S_FALSE
*
* @devnote
* This could be a TOM property method (along with GetViewMode())
*/
HRESULT CTxtEdit::SetViewKind(
long Value) //@parm Turn outline mode on/off for Value nonzero/zero
{
TRACEBEGIN(TRCSUBSYSEDIT, TRCSCOPEINTERN, "CTxtEdit::SetViewKind");
if(!IsRich() || !_pdp->IsMultiLine())
return S_FALSE;
Value = (Value == VM_OUTLINE); // Convert to 1/0
if(_fOutlineView != Value)
{
HCURSOR hcur = TxSetCursor(LoadCursor(0, IDC_WAIT), NULL);
CTxtSelection *psel = GetSel();
_fOutlineView = (WORD)Value;
if(!GetAdjustedTextLength()) // No text in control: in outline
{ // view, use Heading 1; in normal
CParaFormat PF; // view, use Normal style
PF._sStyle = (SHORT)(IsInOutlineView()
? STYLE_HEADING_1 : STYLE_NORMAL);
psel->SetParaStyle(&PF, NULL, PFM_STYLE);
}
else
{
// There is text. Make sure there is paragraph formatting.
_psel->Check_rpPF();
}
psel->CheckIfSelHasEOP(-1, 0);
_pdp->UpdateView();
psel->Update(TRUE);
TxSetCursor(hcur, NULL);
}
return NOERROR;
}
/*
* CTxtEdit::GetViewScale (pValue)
*
* @mfunc
* get view zoom scale in percent
*
* @rdesc
* HRESULT = (pValue) ? NOERROR : E_INVALIDARG
*
* @devnote
* This could be a TOM property method (along with SetViewScale())
*/
HRESULT CTxtEdit::GetViewScale(
long *pValue) //@parm Get % zoom factor
{
TRACEBEGIN(TRCSUBSYSEDIT, TRCSCOPEINTERN, "CTxtEdit::GetViewScale");
if(!pValue)
return E_INVALIDARG;
*pValue = 100;
if(GetZoomNumerator() && GetZoomDenominator())
*pValue = (100*GetZoomNumerator())/GetZoomDenominator();
return NOERROR;
}
/*
* CTxtEdit::SetViewScale (Value)
*
* @mfunc
* Set zoom numerator equal to the scale percentage Value and
* zoom denominator equal to 100
*
* @rdesc
* NOERROR
*
* @devnote
* This could be a TOM property method (along with GetViewScale())
*/
HRESULT CTxtEdit::SetViewScale(
long Value) //@parm Set view scale factor
{
TRACEBEGIN(TRCSUBSYSEDIT, TRCSCOPEINTERN, "CTxtEdit::SetViewScale");
if((unsigned)Value > 2000)
return E_INVALIDARG;
SetZoomNumerator(Value);
SetZoomDenominator(100);
return NOERROR;
}
/*
* CTxtEdit::UpdateOutline()
*
* @mfunc
* Update selection and screen after ExpandOutline() operation
*
* @comm
* This method is only valid when the control is in-place active;
* calls while inactive may fail.
*/
HRESULT CTxtEdit::UpdateOutline()
{
Assert(IsInOutlineView());
GetSel()->Update(FALSE);
TxInvalidateRect(NULL, TRUE);
return NOERROR;
}
/*
* CTxtEdit::MoveSelection(lparam, publdr)
*
* @mfunc
* Move selected text up/down by the number of paragraphs given by
* LOWORD(lparam).
*
* @rdesc
* TRUE iff movement occurred
*/
HRESULT CTxtEdit::MoveSelection (
LPARAM lparam, //@parm # paragraphs to move by
IUndoBuilder *publdr) //@parm undo builder to receive antievents
{
TRACEBEGIN(TRCSUBSYSSEL, TRCSCOPEINTERN, "CTxtRange::MoveSelection");
CFreezeDisplay fd(_pdp);
CTxtSelection * psel = GetSel();
LONG cch;
LONG cchSel = psel->GetCch();
LONG cpMin, cpMost;
LONG cpSel = psel->GetCp();
IDataObject * pdo = NULL;
CTxtRange rg(*psel);
LONG cpNext = 0;
LONG cpCur = 0;
BOOL fDeleteCR = FALSE;
if(publdr)
publdr->StopGroupTyping();
rg.Expander(tomParagraph, TRUE, NULL, &cpMin, &cpMost);
CPFRunPtr rp(rg);
cch = rp.FindExpanded(); // Include subordinate paras
if(cch < 0)
cch = tomForward;
rg.SetExtend(TRUE);
rg.Advance(cch);
cpMost = rg.GetCpMost();
if(lparam > 0 && cpMost == GetTextLength())
{
Beep(); // Already at end
return S_FALSE;
}
HRESULT hr = _ldte.RangeToDataObject(&rg, SF_RTF, &pdo);
if(hr != NOERROR)
goto error;
if(lparam > 0)
psel->EndOf(tomParagraph, FALSE, NULL);
else
psel->StartOf(tomParagraph, FALSE, NULL);
cpCur = psel->GetCp();
hr = psel->Move(tomParagraph, lparam, NULL);
if(psel->GetCp() == cpCur)
{
psel->Set(cpSel, cchSel);
Beep();
goto error;
}
// Since psel->Move() calls psel->Update(), the selection is forced
// to be in noncollapsed text. Going backward, this might leave the
// selection just before the EOP of a paragraph, instead of being at the
// start of the paragraph where it should be. Going forward it may have
// tried to reach the EOD, but was adjusted backward. This case gets
// a bit awkward...
if(psel->GetCp() < cpCur) // Going backward: be sure
psel->StartOf(tomParagraph, FALSE, NULL);// end up at start of para
else if(!psel->_rpTX.IsAfterEOP()) // Going forward and sel
{ // adjusted backward
psel->SetExtend(FALSE);
psel->Advance(tomForward); // Go to final CR, insert a CR
CTxtRange rgDel(*psel); // use psel because UI
rgDel.ReplaceRange(1, szCR, publdr, SELRR_REMEMBERRANGE);
psel->Advance(1);
fDeleteCR = TRUE; // Remember to delete it
}
cpCur = psel->GetCp();
hr = _ldte.PasteDataObjectToRange(pdo, psel, 0, NULL,
publdr, PDOR_NONE);
if(hr != NOERROR)
goto error;
if(fDeleteCR) // Delete CR (final CR becomes
{ // CR for this para). Don't
CTxtRange rgDel(*psel); // use psel because UI
Assert(rgDel._rpTX.IsAfterEOP()); // restricts it's ability to
rgDel.Delete(tomCharacter, -1, &cch); // delete
}
cpNext = psel->GetCp();
psel->Set(cpCur, 0);
psel->CheckOutlineLevel(publdr);
psel->Set(cpNext, 0);
psel->CheckOutlineLevel(publdr);
// Now set selection anti-events. If selection preceded paste point,
// subtract its length from redo position, since selection will get
// deleted if we are doing a DRAGMOVE within this instance.
cch = cpMost - cpMin; // cch of rg
if(cpSel < cpCur)
cpNext -= cch;
psel->Set(psel->GetCp() + fDeleteCR, cch); // Include final CR
// rg.ReplaceRange won't delete final CR, so remember if it's included
fDeleteCR = rg.GetCpMost() == GetTextLength();
rg.ReplaceRange(0, NULL, publdr, SELRR_REMEMBERRANGE);
if(fDeleteCR) // Needed to delete final CR
rg.DeleteTerminatingEOP(publdr); // Delete one immediately
// before it instead
rg.CheckOutlineLevel(publdr);
if(publdr)
{
HandleSelectionAEInfo(this, publdr, cpSel, cchSel, cpNext, cch,
SELAE_FORCEREPLACE);
}
hr = NOERROR;
error:
if(pdo)
pdo->Release();
return hr;
}
/*
* CTxtEdit::SetReleaseHost
*
* @mfunc Handles notification that edit control must keep its
* reference to the host alive.
*
* @rdesc None.
*/
void CTxtEdit::SetReleaseHost()
{
_phost->AddRef();
_fReleaseHost = TRUE;
}
#if !defined(NOMAGELLAN)
/*
* CTxtEdit::HandleMouseWheel(wparam, lparam)
*
* @mfunc Handles scrolling as a result of rotating a mouse roller wheel.
*
* @rdesc LRESULT
*/
LRESULT CTxtEdit::HandleMouseWheel(
WPARAM wparam,
LPARAM lparam)
{
// This bit of global state is OK
static LONG gcWheelDelta = 0;
short zdelta = (short)HIWORD(wparam);
BOOL fScrollByPages = FALSE;
// Cancel middle mouse scrolling if it's going.
OnTxMButtonUp(0, 0, 0);
// Handle zoom or data zoom
if((wparam & MK_CONTROL) == MK_CONTROL)
{
// bug fix 5760
// prevent zooming if control is NOT rich or
// is a single line control
if (!_pdp->IsMultiLine())
return 0;
LONG lViewScale;
GetViewScale(&lViewScale);
lViewScale += (zdelta/WHEEL_DELTA) * 10; // 10% per click
if(lViewScale <= 500 && lViewScale >= 10) // Word's limits
{
SetViewScale(lViewScale);
_pdp->UpdateView();
}
return 0;
}
if(wparam & (MK_SHIFT | MK_CONTROL))
return 0;
gcWheelDelta += zdelta;
if(abs(gcWheelDelta) >= WHEEL_DELTA)
{
LONG cLineScroll = W32->GetRollerLineScrollCount();
if(cLineScroll != -1)
cLineScroll *= abs(gcWheelDelta)/WHEEL_DELTA;
gcWheelDelta %= WHEEL_DELTA;
// -1 means scroll by pages; so simply call page up/down.
if(cLineScroll == -1)
{
fScrollByPages = TRUE;
if(_pdp)
_pdp->VScroll(zdelta < 0 ? SB_PAGEDOWN : SB_PAGEUP, 0);
}
else
{
mouse.MagellanRollScroll(_pdp, zdelta, cLineScroll,
SMOOTH_ROLL_NUM, SMOOTH_ROLL_DENOM, TRUE);
}
// notify through the messagefilter that we scrolled
if(_dwEventMask & ENM_SCROLLEVENTS)
{
MSGFILTER msgfltr;
ZeroMemory(&msgfltr, sizeof(MSGFILTER));
msgfltr.msg = WM_VSCROLL;
msgfltr.wParam = fScrollByPages ?
(zdelta < 0 ? SB_PAGEDOWN: SB_PAGEUP):
(zdelta < 0 ? SB_LINEDOWN: SB_LINEUP);
// We don't check the result of this call --
// it's not a message we received and we're not going to
// process it any further
_phost->TxNotify(EN_MSGFILTER, &msgfltr);
}
return TRUE;
}
return 0;
}
#endif
Reference in New Issue View Git Blame Copy Permalink