3886 lines
110 KiB
C++
3886 lines
110 KiB
C++
/*
|
||
* @doc EXTERNAL
|
||
*
|
||
* @module TEXTSERV.CPP -- Text Services Implementation |
|
||
*
|
||
* Original Author: <nl>
|
||
* Rick Sailor
|
||
*
|
||
* History: <nl>
|
||
* 8/1/95 ricksa Created and documented
|
||
* 10/95 murrays Further doc and simplifications
|
||
*
|
||
* Documentation is generated straight from the code. The following
|
||
* date/time stamp indicates the version of code from which the
|
||
* the documentation was generated.
|
||
*
|
||
* $Header: /richedit/src/textserv.cpp 53 11/15/95 2:39p Ricksa $
|
||
*
|
||
* Copyright (c) 1995-2001, 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 "_urlsup.h"
|
||
#include "_magelln.h"
|
||
#ifndef NOLINESERVICES
|
||
#include "_ols.h"
|
||
#endif
|
||
#include "_clasfyc.h"
|
||
|
||
#include "_tomfmt.h"
|
||
|
||
#ifndef OBJID_NATIVEOM
|
||
#define OBJID_NATIVEOM 0xFFFFFFF0
|
||
#endif
|
||
|
||
#ifndef NOPRIVATEMESSAGE
|
||
#include "_MSREMSG.H"
|
||
#include "_dxfrobj.h"
|
||
#endif
|
||
|
||
#ifndef NOACCESSIBILITY
|
||
#include "oleacc.h"
|
||
#endif
|
||
|
||
// By turning on the PROFILE_TS compiler directive, you tell IceCap2.0
|
||
// to turn on profiling for only ITextServices API's. Typically only
|
||
// used during profiling work.
|
||
//#define PROFILE_TS
|
||
#ifdef PROFILE_TS
|
||
#include <icapexp.h>
|
||
|
||
class CapProfile
|
||
{
|
||
public:
|
||
CapProfile() { StartCAP(); }
|
||
~CapProfile() { StopCAP(); }
|
||
};
|
||
|
||
#define START_PROFILING CapProfile capprf;
|
||
#else
|
||
#define START_PROFILING
|
||
#endif //PROFILE_TS
|
||
|
||
ASSERTDATA
|
||
|
||
// Macros to get mouse coordinates out of a message
|
||
// need to cast to SHORT first for sign extension
|
||
#define MOUSEX ((INT)(SHORT)LOWORD(lparam))
|
||
#define MOUSEY ((INT)(SHORT)HIWORD(lparam))
|
||
|
||
LONG ValidateTextRange(TEXTRANGE *pstrg);
|
||
|
||
BOOL g_OLSBusy = 0;
|
||
|
||
|
||
// Helper function in edit.cpp
|
||
LONG GetECDefaultHeightAndWidth(
|
||
ITextServices *pts,
|
||
HDC hdc,
|
||
LONG lZoomNumerator,
|
||
LONG lZoomDenominator,
|
||
LONG yPixelsPerInch,
|
||
LONG *pxAveWidth,
|
||
LONG *pxOverhang,
|
||
LONG *pxUnderhang);
|
||
|
||
// if there's an active object being dragged around, on WM_PAINT we always
|
||
// try to reposition it to there it should be. A not-so-well-behaved object
|
||
// my generate another WM_PAINT message in response to that, even if it actually
|
||
// did not move. So we limit our number of attempts to reposition it and reset
|
||
// this counter every time a mouse moves.
|
||
// The corresponding field is declared as :2, so don't try to bump it up
|
||
// without allocating more bits!!
|
||
#define MAX_ACTIVE_OBJ_POS_TRIES (3)
|
||
|
||
// Interchange horizontal and vertical commands
|
||
WORD InterchangeScrollCode(WORD wCode)
|
||
{
|
||
switch(wCode)
|
||
{
|
||
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 wCode;
|
||
}
|
||
}
|
||
|
||
|
||
///////////////////////////// Helper Functions ///////////////////////////////////
|
||
/*
|
||
* BOOL CTxtEdit::LoadMsgFilter(msg, wparam, lparam)
|
||
*
|
||
* @func
|
||
* Check if we should load the IME message filter
|
||
*
|
||
* @rdesc
|
||
* TRUE - Load it
|
||
* FALSE - Don't load
|
||
*/
|
||
BOOL CTxtEdit::LoadMsgFilter(
|
||
UINT msg, //@parm Message ID
|
||
WPARAM wparam, //@parm Message wparam
|
||
LPARAM lparam) //@parm Message lparam
|
||
{
|
||
//TRACEBEGIN(TRCSUBSYSTS, TRCSCOPEINTERN, "CTxtEdit::LoadMsgFilter");
|
||
|
||
// For the first ever message, we want to check if
|
||
// our client has created AIMM object for current thread
|
||
#ifndef NOFEPROCESSING
|
||
if (!_fCheckAIMM)
|
||
{
|
||
DWORD dwThreadId;
|
||
DWORD dwLoadActiveInput = 0;
|
||
|
||
_fCheckAIMM = 1;
|
||
|
||
#ifndef NOPRIVATEMESSAGE
|
||
if (!_f10Mode) // Don't check if 1.0 mode
|
||
{
|
||
if (FindAtomA("_CTF_PROCESS_ATOM_")) // Is process using Cicero?
|
||
dwLoadActiveInput = SES_USECTF;
|
||
|
||
if (FindAtomA("_AIMM12_PROCESS_ATOM_")) // Is process using Aimm 1.2?
|
||
dwLoadActiveInput = SES_USEAIMM12; // Yes, this will override SES_USECTF.
|
||
else if (dwThreadId = GetCurrentThreadId())
|
||
{
|
||
char szBuf[20];
|
||
sprintf(szBuf, "AIMM:%08x", dwThreadId);
|
||
if (FindAtomA(szBuf)) // Is thread using Aimm 1.1?
|
||
dwLoadActiveInput = SES_USEAIMM11; // Yes, load Aimm 1.1
|
||
}
|
||
|
||
if (!dwLoadActiveInput) // Process is not using anything...
|
||
{
|
||
if (W32->fUseCTF()) // Ini file say use Cicero
|
||
dwLoadActiveInput = SES_USECTF;
|
||
else if (W32->fUseAimm()) // Ini file say use Aimm 1.2
|
||
dwLoadActiveInput = SES_USEAIMM12;
|
||
}
|
||
|
||
if (dwLoadActiveInput)
|
||
{
|
||
HWND hWnd = NULL;
|
||
|
||
TxGetWindow( &hWnd );
|
||
|
||
if (hWnd)
|
||
{
|
||
if (_fInOurHost)
|
||
PostMessage(hWnd, EM_SETUIM, dwLoadActiveInput, dwLoadActiveInput);
|
||
else
|
||
{
|
||
LRESULT lResult;
|
||
TxSendMessage(EM_SETUIM, dwLoadActiveInput, dwLoadActiveInput, &lResult);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
#endif
|
||
}
|
||
|
||
switch (msg)
|
||
{
|
||
case WM_KEYDOWN:
|
||
case WM_SYSKEYDOWN:
|
||
if ( (WORD) wparam == VK_PROCESSKEY )
|
||
return TRUE;
|
||
break;
|
||
|
||
case WM_INPUTLANGCHANGE:
|
||
if (IsFELCID((WORD)(lparam)))
|
||
return TRUE;
|
||
break;
|
||
|
||
case EM_SETEDITSTYLE:
|
||
if ((lparam & (SES_USEAIMM | SES_NOIME | SES_USECTF | SES_CTFALLOWEMBED | SES_CTFALLOWSMARTTAG | SES_CTFALLOWPROOFING)) ||
|
||
(wparam & (SES_USEAIMM | SES_NOIME | SES_USECTF | SES_CTFALLOWEMBED | SES_CTFALLOWSMARTTAG | SES_CTFALLOWPROOFING)))
|
||
return TRUE;
|
||
break;
|
||
|
||
case EM_RECONVERSION:
|
||
case WM_IME_NOTIFY:
|
||
case WM_IME_REQUEST:
|
||
case WM_IME_STARTCOMPOSITION:
|
||
case EM_GETIMEOPTIONS:
|
||
case EM_SETIMEOPTIONS:
|
||
case EM_SETIMECOLOR:
|
||
case EM_GETIMECOLOR:
|
||
case WM_IME_CHAR:
|
||
#ifndef NOPRIVATEMESSAGE
|
||
case EM_SETUIM:
|
||
#endif
|
||
case EM_SETIMEMODEBIAS:
|
||
case EM_GETIMEMODEBIAS:
|
||
case EM_GETCTFMODEBIAS:
|
||
case EM_SETCTFMODEBIAS:
|
||
case EM_GETCTFOPENSTATUS:
|
||
case EM_SETCTFOPENSTATUS:
|
||
case EM_GETIMECOMPTEXT:
|
||
case EM_ISIME:
|
||
case EM_GETIMEPROPERTY:
|
||
return TRUE;
|
||
|
||
case EM_SETLANGOPTIONS:
|
||
if (lparam & (IMF_IMEALWAYSSENDNOTIFY | IMF_IMECANCELCOMPLETE))
|
||
return TRUE;
|
||
break;
|
||
|
||
default:
|
||
if (msg)
|
||
{
|
||
if (msg == MSIMEReconvertMsg || msg == MSIMEDocFeedMsg
|
||
|| msg == MSIMEQueryPositionMsg)
|
||
return TRUE;
|
||
}
|
||
break;
|
||
|
||
}
|
||
#endif
|
||
|
||
return FALSE;
|
||
}
|
||
|
||
/*
|
||
* CTxtEdit::FormatAndPrint (hdcDraw, hicTargetDev, ptd, lprcBounds,
|
||
* lprcWBounds)
|
||
* @mfunc
|
||
* Format and Print data in control
|
||
*
|
||
* @rdesc
|
||
* S_OK - everything worked
|
||
* E_FAIL - unexpected failure occurred
|
||
*/
|
||
HRESULT CTxtEdit::FormatAndPrint(
|
||
HDC hdcDraw, //@parm HDC to draw on
|
||
HDC hicTargetDev, //@parm Input information context if any
|
||
DVTARGETDEVICE *ptd, //@parm Device target information
|
||
RECT *lprcBounds, //@parm Rectangle to measure
|
||
RECT *lprcWBounds) //@parm Metafile information
|
||
{
|
||
TRACEBEGIN(TRCSUBSYSTS, TRCSCOPEINTERN, "CTxtEdit::FormatAndPrint");
|
||
|
||
// Put client rectangle in format structure
|
||
FORMATRANGE fr;
|
||
fr.rc = *lprcBounds;
|
||
|
||
// Get number of device units per inch
|
||
LONG xPerInch;
|
||
LONG yPerInch;
|
||
|
||
if (NULL == lprcWBounds)
|
||
{
|
||
xPerInch = GetDeviceCaps(hdcDraw, LOGPIXELSX);
|
||
yPerInch = GetDeviceCaps(hdcDraw, LOGPIXELSY);
|
||
}
|
||
else
|
||
{
|
||
//Forms ^3 draws using screen resolution, while OLE specifies HIMETRIC
|
||
xPerInch = fInOurHost() ? 2540 : W32->GetXPerInchScreenDC();
|
||
yPerInch = fInOurHost() ? 2540 : W32->GetYPerInchScreenDC();
|
||
|
||
SetWindowOrgEx(hdcDraw, lprcWBounds->left, lprcWBounds->top, NULL);
|
||
SetWindowExtEx(hdcDraw, lprcWBounds->right, lprcWBounds->bottom, NULL);
|
||
}
|
||
|
||
|
||
// Convert rectangle into TWIPS
|
||
fr.rc.left = MulDiv(fr.rc.left, LX_PER_INCH, xPerInch);
|
||
fr.rc.top = MulDiv(fr.rc.top, LY_PER_INCH, yPerInch);
|
||
fr.rc.right = MulDiv(fr.rc.right, LX_PER_INCH, xPerInch);
|
||
fr.rc.bottom = MulDiv(fr.rc.bottom, LY_PER_INCH, yPerInch);
|
||
|
||
// Use message based printing code to do our printing for us
|
||
fr.hdc = hdcDraw;
|
||
fr.hdcTarget = hicTargetDev;
|
||
fr.rcPage = fr.rc;
|
||
fr.chrg.cpMin = _pdp->GetFirstVisibleCp();
|
||
fr.chrg.cpMost = -1;
|
||
|
||
// Assume this is all going to work
|
||
HRESULT hr = S_OK;
|
||
|
||
SPrintControl prtcon;
|
||
prtcon._fDoPrint = TRUE;
|
||
prtcon._fPrintFromDraw = TRUE;
|
||
|
||
// Print control
|
||
if(OnFormatRange(&fr, prtcon, TRUE) == -1)
|
||
{
|
||
// For some reason the control could not be printed
|
||
hr = E_FAIL;
|
||
}
|
||
|
||
return hr;
|
||
}
|
||
|
||
/*
|
||
* CTxtEdit::SetText (pstr, flags, CodePage, publdr, plres)
|
||
*
|
||
* @mfunc Sets the text in the document, clearing out any existing text
|
||
*
|
||
* @rdesc HRESULT
|
||
*/
|
||
HRESULT CTxtEdit::SetText(
|
||
LPCWSTR pstr, //@parm Text to set
|
||
DWORD flags, //@parm 0 or more ST_xxx's
|
||
LONG CodePage, //@parm CodePage
|
||
IUndoBuilder *publdr, //@parm Optional place to put undo events
|
||
LRESULT * plres) //@parm Optional place to return cch added
|
||
{
|
||
CCallMgr callmgr(this);
|
||
BOOL fSel = flags & ST_SELECTION;
|
||
BOOL fSetTextMax = TRUE;
|
||
CTxtRange rg(this, 0, -GetTextLength()); // Select whole story
|
||
CTxtRange * prg = &rg;
|
||
LRESULT lres = 0;
|
||
CFreezeDisplay fd(_pdp);
|
||
CCharFormat CF;
|
||
BOOL fSetCF = FALSE;
|
||
BOOL fInputString = FALSE; // Initialize to no input string
|
||
|
||
// NOTE: WM_SETTEXT is the only message using flags == ST_CHECKPROTECTION.
|
||
// This is sent in via ANSIWndProc(). Do we need another flag to indicate
|
||
// WM_SETTEXT or is this check good enough? This only affect 1.0 mode.
|
||
BOOL f10WM_SETTEXT = flags & ST_10WM_SETTEXT;
|
||
|
||
if(plres)
|
||
*plres = 0;
|
||
|
||
if(fSel) // Set selected text
|
||
{
|
||
if(!_psel)
|
||
{
|
||
Beep();
|
||
return E_FAIL;
|
||
}
|
||
// Bug fix: 6498 - we need to know if scroll position is at bottom
|
||
// before inserting text
|
||
if (Get10Mode())
|
||
{
|
||
LONG nMin, nMax, nPos, nPage;
|
||
BOOL nEnable;
|
||
TxGetVScroll(&nMin, &nMax, &nPos, &nPage, &nEnable);
|
||
if (nEnable)
|
||
_psel->SetAutoVScroll((nMax - nPage - 3) <= nPos);
|
||
}
|
||
prg = _psel;
|
||
}
|
||
else
|
||
{
|
||
_qwCharFlags &= FRTL | FDIGITSHAPE; // No chars, so kill char flags
|
||
if (!IsRich())
|
||
{
|
||
// Deleting all text from Plain text, we want to
|
||
// go back to the -1 format
|
||
prg->Set_iCF(-1);
|
||
prg->SetUseiFormat(TRUE);
|
||
}
|
||
else
|
||
_qwCharFlags |= FBELOWX40; // For final EOP
|
||
}
|
||
|
||
if (flags & ST_CHECKPROTECTION &&
|
||
IsProtectedRange(WM_SETTEXT, 0, (LPARAM)pstr, prg))
|
||
{
|
||
return E_ACCESSDENIED;
|
||
}
|
||
|
||
// 1.0 COMPATABILITY
|
||
// 1.0 didn't scroll to selection if text is inserted via EM_REPLACESEL
|
||
// and fHideSelection is FALSE;
|
||
BOOL fUpdateCaret = !(Get10Mode() && (flags & ST_10REPLACESEL) &&
|
||
fHideSelection() && !_psel->GetAutoVScroll());
|
||
|
||
if(!(flags & ST_KEEPUNDO))
|
||
{
|
||
if(IsRich() && !fSel)
|
||
{
|
||
if (f10WM_SETTEXT)
|
||
{
|
||
// If pstr is empty string, retain format at end of current text.
|
||
// If pstr is not empty string, retain format at cp = 1.
|
||
// Note: prg->_rpCF is already at SetRun(0,0)
|
||
CFormatRunPtr rp(prg->_rpCF);
|
||
|
||
if (!pstr || *(LPBYTE)pstr == '\0')
|
||
{
|
||
LONG cchAdjusted = GetAdjustedTextLength() - 1;
|
||
|
||
if (cchAdjusted > 0)
|
||
rp.Move(cchAdjusted);
|
||
}
|
||
|
||
CF = *(GetCharFormat(rp.GetFormat()));
|
||
fSetCF = TRUE;
|
||
|
||
prg->SetText(NULL); // delete all the text first
|
||
}
|
||
|
||
// SetText causing all formatting to return to the default. We use
|
||
// the notification system to remove the formatting. This is
|
||
// particularly important for the final EOP which cannot be deleted.
|
||
|
||
// Notify every interested party that they should dump their formatting
|
||
_nm.NotifyPreReplaceRange(NULL, CONVERT_TO_PLAIN, 0, 0, 0, 0);
|
||
|
||
// Tell document to dump its format runs
|
||
_story.DeleteFormatRuns();
|
||
|
||
if (fSetCF)
|
||
prg->SetCharFormat(&CF, 0, NULL, CFM_ALL, 0);
|
||
}
|
||
|
||
publdr = NULL;
|
||
if(_pundo)
|
||
_pundo->ClearAll();
|
||
|
||
if(_predo)
|
||
_predo->ClearAll();
|
||
|
||
// If we are re-entered, there may be anti-events higher up the
|
||
// chain. Grab the undo builder and clear things away if necessary.
|
||
CGenUndoBuilder undobldr(this, 0);
|
||
undobldr.Discard();
|
||
}
|
||
if(publdr)
|
||
publdr->StopGroupTyping();
|
||
|
||
// Need to reinit zoomin variables if entire text is being replaced
|
||
if (!fSel)
|
||
InitDocInfo();
|
||
|
||
else if(_psel->GetCch()) // If insert into selection, need to
|
||
{ // insert an EOP if selection ends
|
||
CPFRunPtr rp(*_psel); // at a table row delimiter
|
||
if(_psel->GetCch() < 0)
|
||
rp.Move(-_psel->GetCch());
|
||
if(rp.IsTableRowDelimiter())
|
||
_psel->InsertEOP(publdr, 0);
|
||
}
|
||
|
||
LONG lStreamFormat = IsRich() && IsRTF((LPSTR)pstr, 10) ? SF_RTF : 0;
|
||
|
||
if(pstr && *(LPSTR)pstr && (CodePage != 1200 || lStreamFormat || *pstr < 128 && fSel && !*(pstr+1)))
|
||
{
|
||
LONG cch = strlen((LPSTR)pstr); // REMARK: little endian dependence
|
||
DWORD ch = *(LPBYTE)pstr; // for CodePage = 1200 cases
|
||
|
||
fInputString = TRUE;
|
||
if(ch < 128 && fSel && cch == 1)
|
||
{
|
||
lres = 1;
|
||
fSetTextMax = FALSE;
|
||
TxSetMaxToMaxText(1);
|
||
if(ch == CR)
|
||
InsertEOP(0, FALSE, publdr);
|
||
else
|
||
_psel->PutChar(ch, 0, publdr);
|
||
}
|
||
else if(cch == 2 && ch == CR && *((LPSTR)pstr + 1) == LF)
|
||
{
|
||
lres = 2;
|
||
fSetTextMax = FALSE;
|
||
TxSetMaxToMaxText(2);
|
||
InsertEOP(0, FALSE, publdr);
|
||
}
|
||
else
|
||
{
|
||
READHGLOBAL rhg = {(LPSTR)pstr, cch};
|
||
EDITSTREAM es = {(DWORD_PTR)&rhg, S_OK, ReadHGlobal};
|
||
HCURSOR hcur = NULL;
|
||
|
||
// Want wait cursor to display sooner
|
||
bool fSetCursor = rhg.cbLeft > NUMPASTECHARSWAITCURSOR;
|
||
if(fSetCursor)
|
||
hcur = TxSetCursor(LoadCursor(NULL, IDC_WAIT));
|
||
|
||
if (CodePage <= 0)
|
||
{
|
||
if (Get10Mode())
|
||
{
|
||
LONG iFormat = _psel->GetiFormat();
|
||
const CCharFormat *pCF = GetCharFormat(iFormat);
|
||
|
||
CodePage = CodePageFromCharRep(pCF->_iCharRep);
|
||
}
|
||
else
|
||
CodePage = (CodePage == 0) ? GetACP() : GetDefaultCodePage(EM_SETTEXTEX);
|
||
}
|
||
|
||
if(!lStreamFormat)
|
||
lStreamFormat = SF_TEXT;
|
||
|
||
lStreamFormat |= SF_USECODEPAGE | (CodePage << 16);
|
||
|
||
if(fSel)
|
||
lStreamFormat |= SFF_SELECTION;
|
||
|
||
lres = _ldte.LoadFromEs(prg, lStreamFormat, &es, FALSE, publdr);
|
||
if(fSetCursor)
|
||
TxSetCursor(hcur);
|
||
|
||
if(es.dwError != NOERROR)
|
||
return (HRESULT)es.dwError;
|
||
}
|
||
}
|
||
else
|
||
{
|
||
// 9052: Don't delete all if 4 (ST_NEWCHARS) is passed in EM_SETTEXTEX
|
||
DWORD dwFlags = (flags & 4)
|
||
? RR_ITMZ_UNICODEBIDI | RR_NEW_CHARS
|
||
: RR_ITMZ_UNICODEBIDI;
|
||
|
||
if (CodePage != 1200 && pstr && !*(LPSTR)pstr)
|
||
pstr = NULL;
|
||
|
||
if(pstr && *pstr)
|
||
fInputString = TRUE;
|
||
lres = prg->CleanseAndReplaceRange(-1, pstr, FALSE, publdr, NULL, NULL, dwFlags);
|
||
}
|
||
|
||
if(!lres && fInputString)
|
||
{
|
||
// There was an input string but for some reason there was no update.
|
||
return E_FAIL;
|
||
}
|
||
|
||
if (_fOutlineView)
|
||
{
|
||
// Outline view must have formatting.
|
||
_psel->Check_rpPF();
|
||
}
|
||
|
||
|
||
if(_psel)
|
||
{
|
||
if(fSel)
|
||
_psel->Update(fUpdateCaret);
|
||
else
|
||
{
|
||
// Setting the text means a new document so if there is a selection
|
||
// turn it into an insertion point at the beginning of the document.
|
||
_psel->ClearPrevSel();
|
||
_psel->Set(0, 0);
|
||
|
||
// Since the text is being completely replaced and all formatting
|
||
// is being lost, let's go back to the default format for the
|
||
// selection.
|
||
if (!f10WM_SETTEXT)
|
||
_psel->Set_iCF(-1);
|
||
else if (fSetCF)
|
||
_psel->SetCharFormat(&CF, 0, NULL, CFM_ALL, 0);
|
||
|
||
if(_fFocus || _psel->IsParaRTL())
|
||
{
|
||
// Update caret to reflect new postion
|
||
_psel->UpdateCaret(fUpdateCaret);
|
||
}
|
||
}
|
||
}
|
||
|
||
// If we've replaced the entire document, the control isn't
|
||
// really "modified" anymore. This is necessary to match
|
||
// the Windows MLE behavior. However, since RichEdit 1.0
|
||
// did _not_ do this (they left fModified to be TRUE), we
|
||
// only do this for RichEdit 2.0 and later.
|
||
|
||
if(!Get10Mode() && !publdr && !fSel)
|
||
_fModified = FALSE;
|
||
|
||
_fSaved = FALSE; // ITextDocument isn't Saved
|
||
|
||
// Adjust text limit if necessary
|
||
if (fSetTextMax)
|
||
TxSetMaxToMaxText();
|
||
|
||
if(plres)
|
||
*plres = fSel ? lres : 1;
|
||
|
||
return S_OK;
|
||
}
|
||
|
||
/////////////////////////// ITextServices Methods ////////////////////////////////
|
||
|
||
// External IME Message Filter Interface factory
|
||
#ifndef NOFEPROCESSING
|
||
void CreateIMEMessageFilter(ITextMsgFilter **ppNewFilter);
|
||
#endif
|
||
|
||
/*
|
||
* @doc EXTERNAL
|
||
*
|
||
* CTxtEdit::TxSendMessage (msg, wparam, lparam, plresult)
|
||
*
|
||
* @mfunc
|
||
* Used by window host to forward messages sent to its window to the
|
||
* text services.
|
||
*
|
||
* @rdesc
|
||
* NOERROR Message was processed, and some action taken <nl>
|
||
* S_FALSE Message was not processed. Typically indicates that caller
|
||
* should process message, maybe by calling DefWindowProc <nl>
|
||
* S_MSG_KEYIGNORED Message processed, but no action was taken <nl>
|
||
* E_OUTOFMEMORY <nl>
|
||
*
|
||
* @comm
|
||
* Note that two return values are passed back from this function.
|
||
* <p plresult> is the return value that should be passed back from a
|
||
* window proc. However, in some cases, the returned LRESULT does not
|
||
* contain enough information. For example, to implement cursoring
|
||
* around controls, it's useful to know if a keystroke (such as right
|
||
* arrow) was processed, but ignored (e.g. the caret is already at the
|
||
* rightmost position in the the text). In these cases, extra
|
||
* information may be returned via the returned HRESULT.
|
||
*
|
||
* WM_CHAR and WM_KEYDOWN should return S_MSG_KEYIGNORED when a key or
|
||
* char has been recognized but had no effect given the current state,
|
||
* e.g., a VK_RIGHT key when the insertion point is already at the end of
|
||
* the document). This is used by Forms3 to pass the key up the visual
|
||
* hierarchy, so that for example, focus moves to the next control in the
|
||
* TAB order.
|
||
*
|
||
* This includes the following cases:
|
||
*
|
||
* 1. Any key trying to move the insertion point beyond the end of the
|
||
* document; or before the begining of the document.
|
||
*
|
||
* 2. Any key trying to move the insertion point beyond the last line or
|
||
* before the first line.
|
||
*
|
||
* 3. Any insertion of character (WM_CHAR) that would move the insertion
|
||
* point past the maximum length of the control.
|
||
*/
|
||
HRESULT CTxtEdit::TxSendMessage (
|
||
UINT msg, //@parm Message id
|
||
WPARAM wparam, //@parm WPARAM from window's message
|
||
LPARAM lparam, //@parm LPARAM from window's message
|
||
LRESULT *plresult) //@parm Where to put message's return LRESULT
|
||
{
|
||
TRACEBEGINPARAM(TRCSUBSYSTS, TRCSCOPEEXTERN, "CTxtEdit::TxSendMessage", msg);
|
||
|
||
CObjectMgr *pobjmgr;
|
||
HRESULT hr = NOERROR;
|
||
LRESULT lres = 0;
|
||
CCallMgr callmgr(this);
|
||
|
||
if ( CW32System::_MSMouseRoller == msg ) // map Magellan msg.
|
||
{
|
||
// map this message to WM_MOUSEWHEEL
|
||
// In these cases the driver doesn't set the key state properly so
|
||
// we have to do it ourselves
|
||
short zdelta = (short)(long)wparam;
|
||
short kstate = 0;
|
||
if (GetKeyboardFlag(CTRL, VK_CONTROL))
|
||
kstate |= MK_CONTROL;
|
||
if (GetKeyboardFlag(SHIFT, VK_SHIFT))
|
||
kstate |= MK_SHIFT;
|
||
|
||
wparam = MAKELONG(kstate, zdelta);
|
||
msg = WM_MOUSEWHEEL;
|
||
}
|
||
|
||
#ifndef NOFEPROCESSING
|
||
if (_pMsgFilter)
|
||
{
|
||
PassMsg:
|
||
hr = _pMsgFilter->HandleMessage(&msg, &wparam, &lparam, &lres);
|
||
if (hr == S_OK) // Message has been handled.
|
||
{
|
||
if(plresult)
|
||
*plresult = lres;
|
||
|
||
return S_OK;
|
||
}
|
||
hr = S_OK; // Reset
|
||
}
|
||
else if (LoadMsgFilter(msg, wparam, lparam))
|
||
{
|
||
HWND hwnd = NULL;
|
||
if (_fInOurHost)
|
||
{
|
||
// If not in Forms^3 we can get the window from our host.
|
||
// For Forms^3 we will use NULL for the desktop Window and pray
|
||
TxGetWindow( &hwnd );
|
||
}
|
||
ITextMsgFilter *pNewFilter = NULL;
|
||
|
||
CreateIMEMessageFilter(&pNewFilter);
|
||
|
||
if (pNewFilter)
|
||
{
|
||
pNewFilter->AttachDocument( hwnd, (ITextDocument2 *) this, (ITextServices *) this );
|
||
AttachMsgFilter(pNewFilter);
|
||
goto PassMsg;
|
||
}
|
||
}
|
||
#endif
|
||
|
||
START_PROFILING
|
||
|
||
IUndoBuilder * publdr;
|
||
CGenUndoBuilder undobldr(this, UB_AUTOCOMMIT, &publdr);
|
||
|
||
switch(msg)
|
||
{
|
||
case EM_CANPASTE:
|
||
// we don't check for protection here, as RichEdit 1.0
|
||
// doesn't
|
||
lres = _ldte.CanPaste(NULL, (CLIPFORMAT) wparam, RECO_PASTE);
|
||
break;
|
||
|
||
case EM_CANUNDO:
|
||
if(_pundo)
|
||
lres = _pundo->CanUndo();
|
||
break;
|
||
|
||
case EM_CANREDO:
|
||
if(_predo)
|
||
lres = _predo->CanUndo();
|
||
break;
|
||
|
||
case EM_GETUNDONAME:
|
||
if(_pundo)
|
||
lres = _pundo->GetNameIDFromAE((void*)wparam);
|
||
break;
|
||
|
||
case EM_GETREDONAME:
|
||
if(_predo)
|
||
lres = _predo->GetNameIDFromAE((void*)wparam);
|
||
break;
|
||
|
||
case EM_STOPGROUPTYPING:
|
||
if(_pundo)
|
||
{
|
||
// we'll only stop group typing iff wparam
|
||
// is zero (meaning stop regardless) _or_ if
|
||
// wparam matches the merge anti event.
|
||
//
|
||
// This feature allows clients to say that only
|
||
// a specific anti-event should close out it's
|
||
// "fuzzy" state. Note that currently, only the
|
||
// merge anti-event has this fuzzy state.
|
||
|
||
if(!wparam || (IAntiEvent *)wparam == _pundo->GetMergeAntiEvent())
|
||
_pundo->StopGroupTyping();
|
||
}
|
||
break;
|
||
|
||
case WM_UNICHAR: // Unambiguous Unicode character
|
||
if(wparam == NOTACHAR)
|
||
{
|
||
lres = TRUE; // Tell caller we understand msg
|
||
break;
|
||
} // Else fall thru to WM_CHAR
|
||
|
||
case WM_CHAR:
|
||
if(GetKeyboardFlags() & (ALTNUMPAD | HOTEURO))
|
||
{
|
||
if (GetKeyboardFlags() & ALTNUMPAD)
|
||
{
|
||
if (GetKeyboardFlags() & ALT0 &&
|
||
GetCharFormat(-1)->_iCharRep == MAC_INDEX &&
|
||
GetKeyboardCharRep(0) == ANSI_INDEX)
|
||
{
|
||
WCHAR ch;
|
||
UnicodeFromMbcs(&ch, 1, (char *)&wparam, 1, 10000);
|
||
wparam = ch;
|
||
SetKeyPadNumber(ch);
|
||
ResetKeyboardFlag(ALTNUMPAD | ALT0);
|
||
}
|
||
#ifndef NOANSIWINDOWS
|
||
else
|
||
{
|
||
CW32System::WM_CHAR_INFO wmci;
|
||
wmci._fAccumulate = FALSE;
|
||
W32->AnsiFilter(msg, wparam, lparam, (void *)&wmci);
|
||
}
|
||
#endif
|
||
}
|
||
else // (GetKeyboardFlags() & HOTEURO) case
|
||
{
|
||
// We have handled the Euro, just eat this WM_CHAR
|
||
ResetKeyboardFlag(HOTEURO);
|
||
break;
|
||
}
|
||
} // Fall thru to WM_IME_CHAR
|
||
|
||
case WM_IME_CHAR: // 2 byte character, usually FE.
|
||
lres = hr = OnTxChar((DWORD)wparam, (DWORD)lparam, publdr);
|
||
ResetKeyboardFlag(HOTEURO);
|
||
break;
|
||
|
||
case WM_USER + 39: // For backward compat with NT 3.51
|
||
case EM_CHARFROMPOS:
|
||
hr = TxCharFromPos((LPPOINT)lparam, &lres);
|
||
break;
|
||
|
||
#ifdef WM_INPUTLANGCHANGE
|
||
case WM_INPUTLANGCHANGE:
|
||
if (_fSingleCodePage)
|
||
{
|
||
// See if the charset for the specified keyboard is supported by
|
||
// the single code page we support. If we don't have a _pDocInfo,
|
||
// assume the code page is the system code page. We will always
|
||
// support the ANSI charset, as all code pages contain at least
|
||
// a large portion of this charset (the ASCII block).
|
||
wparam = (!wparam || wparam == GetCharSet(_pDocInfo ?
|
||
_pDocInfo->_wCpg : GetSystemDefaultCodePage()));
|
||
}
|
||
goto update_kbd;
|
||
|
||
case WM_INPUTLANGCHANGEREQUEST:
|
||
// If the SingleCodePage option is set, then we must have a
|
||
// "good" code page to go to; if not, just eat this message.
|
||
//
|
||
// This will prevent folks from typing French and Greek
|
||
// on the same edit control, which is useful for certain
|
||
// kinds of backward compatibility scenarios.
|
||
//
|
||
// HACK ALERT! the documentation on WM_INPUTLANGCHANGEREQUEST
|
||
// is wrong. It turns out that _only_ the low bit of wparam
|
||
// indicates whether or not the new keyboard can be considered
|
||
// as the same code page.
|
||
|
||
if (_fSingleCodePage && !(wparam & 1))
|
||
{
|
||
// The lowest bit check is not reliable in some platforms e.g. Viet OSR2
|
||
// since it doesnt allow English kbd to match system charset (bug #6365).
|
||
|
||
wparam = PRIMARYLANGID(LOWORD(lparam)) == LANG_ENGLISH &&
|
||
IN_RANGE (SUBLANG_ENGLISH_US, SUBLANGID(LOWORD(lparam)), SUBLANG_ENGLISH_UK);
|
||
}
|
||
|
||
update_kbd:
|
||
if(!_fSingleCodePage || (wparam & 1))
|
||
{
|
||
WORD wKLCurrent = LOWORD(GetKeyboardLayout(0));
|
||
|
||
// Update our idea of current keyboard layout
|
||
W32->RefreshKeyboardLayout();
|
||
|
||
if(GetKeyboardFlags() & CTRL && GetKeyboardFlags() & SHIFT)
|
||
SetKeyboardFlag(LETAFTERSHIFT);
|
||
|
||
if( wKLCurrent == LOWORD(lparam) || // No change in keyboard
|
||
GetSel()->CheckChangeFont((HKL)lparam, CharRepFromLID(LOWORD(lparam))))
|
||
hr = S_FALSE; // cause default window to allow kb switch.
|
||
}
|
||
break;
|
||
#endif
|
||
|
||
case WM_CLEAR:
|
||
OnClear(publdr);
|
||
break;
|
||
|
||
case WM_CONTEXTMENU:
|
||
hr = OnContextMenu(lparam);
|
||
break;
|
||
|
||
case WM_COPY:
|
||
case WM_CUT:
|
||
lres = hr = CutOrCopySelection(msg, wparam, lparam, publdr);
|
||
break;
|
||
|
||
case WM_RENDERFORMAT:
|
||
lres = hr = _ldte.RenderClipboardFormat(wparam);
|
||
break;
|
||
|
||
case WM_RENDERALLFORMATS:
|
||
lres = hr = _ldte.RenderAllClipboardFormats();
|
||
break;
|
||
|
||
case WM_DESTROYCLIPBOARD:
|
||
lres = hr = _ldte.DestroyClipboard();
|
||
break;
|
||
|
||
case EM_DISPLAYBAND:
|
||
if (fInplaceActive())
|
||
{
|
||
{
|
||
CLock lock;
|
||
|
||
if (g_OLSBusy)
|
||
{
|
||
hr = OLE_E_INVALIDRECT;
|
||
break;
|
||
}
|
||
}
|
||
OnDisplayBand((const RECT *) lparam, FALSE);
|
||
lres = 1;
|
||
}
|
||
else
|
||
hr = OLE_E_INVALIDRECT;
|
||
break;
|
||
|
||
#ifdef WM_DROPFILES
|
||
case WM_DROPFILES:
|
||
OnDropFiles((HANDLE) wparam);
|
||
break;
|
||
#endif
|
||
|
||
case EM_EMPTYUNDOBUFFER:
|
||
ClearUndo(publdr);
|
||
break;
|
||
|
||
case WM_ERASEBKGND:
|
||
lres = 1; // We handle background erase during painting
|
||
break;
|
||
|
||
case EM_EXGETSEL: // Has cp output parameter
|
||
OnExGetSel((CHARRANGE *)lparam);
|
||
break;
|
||
|
||
case EM_FINDTEXT: // Has cp input/output parms
|
||
case EM_FINDTEXTW: // Has cp input/output parms
|
||
case EM_FINDTEXTEX: // Has cp input/output parms
|
||
case EM_FINDTEXTEXW: // Has cp input/output parms
|
||
lres = OnFindText(msg, (DWORD)wparam, (FINDTEXTEX *)lparam);
|
||
break;
|
||
|
||
case EM_FINDWORDBREAK: // Has cp input/output parms
|
||
hr = TxFindWordBreak((INT)wparam, (LONG)lparam, &lres);
|
||
break;
|
||
|
||
case EM_FORMATRANGE: // Has cp input/output parms
|
||
if(fInplaceActive())
|
||
{
|
||
{
|
||
CLock lock;
|
||
|
||
if (g_OLSBusy)
|
||
{
|
||
hr = OLE_E_INVALIDRECT;
|
||
break;
|
||
}
|
||
}
|
||
SPrintControl prtcon;
|
||
prtcon._fDoPrint = (wparam) ? TRUE : FALSE;
|
||
lres = OnFormatRange((FORMATRANGE *) lparam, prtcon);
|
||
|
||
}
|
||
else
|
||
hr = OLE_E_INVALIDRECT;
|
||
break;
|
||
|
||
case EM_GETTYPOGRAPHYOPTIONS:
|
||
lres = _bTypography;
|
||
break;
|
||
|
||
case EM_GETBIDIOPTIONS:
|
||
if((Get10Mode() || !wparam) && lparam && ((BIDIOPTIONS *)lparam)->cbSize == sizeof(BIDIOPTIONS))
|
||
{
|
||
((BIDIOPTIONS *)lparam)->wMask =
|
||
BOM_NEUTRALOVERRIDE | BOM_CONTEXTREADING | BOM_CONTEXTALIGNMENT;
|
||
((BIDIOPTIONS *)lparam)->wEffects =
|
||
(_fNeutralOverride ? BOE_NEUTRALOVERRIDE : 0) |
|
||
(_nContextDir == CTX_NONE ? 0 : BOE_CONTEXTREADING) |
|
||
(_nContextAlign == CTX_NONE ? 0 : BOE_CONTEXTALIGNMENT);
|
||
}
|
||
break;
|
||
|
||
case EM_GETCHARFORMAT:
|
||
lres = OnGetCharFormat((CHARFORMAT2 *)lparam, wparam);
|
||
break;
|
||
|
||
case EM_GETCODEPAGE:
|
||
lres = GetDefaultCodePage((UINT)wparam);
|
||
break;
|
||
|
||
case EM_GETFIRSTVISIBLELINE:
|
||
if (fInplaceActive())
|
||
lres = _pdp->GetFirstVisibleLine();
|
||
else
|
||
hr = OLE_E_INVALIDRECT;
|
||
break;
|
||
|
||
case EM_GETLIMITTEXT: // Has cp output parameter (sort of)
|
||
lres = TxGetMaxLength(); // Ignore unless testing screams
|
||
break;
|
||
|
||
case EM_GETLINE:
|
||
if(fInplaceActive())
|
||
{
|
||
lres = _pdp->GetLineText((LONG)wparam, (TCHAR *)lparam,
|
||
(LONG) (*(WORD *) lparam));
|
||
}
|
||
else
|
||
hr = OLE_E_INVALIDRECT;
|
||
break;
|
||
|
||
case EM_GETLINECOUNT:
|
||
hr = TxGetLineCount(&lres);
|
||
break;
|
||
|
||
case EM_GETMODIFY: // RichEdit 1.0 returned -1 if _fModified
|
||
lres = -(LONG)_fModified; // is TRUE (go figure). So for backward
|
||
break; // compatibility, we do too :-(
|
||
|
||
case EM_GETOLEINTERFACE:
|
||
if(lparam)
|
||
{
|
||
#ifndef NOFEPROCESSING
|
||
if (wparam == 0x065737777) // 'AIMM'
|
||
W32->GetAimmObject((IUnknown **)(lparam));
|
||
else
|
||
#endif
|
||
{
|
||
*(IRichEditOle **)lparam = (IRichEditOle *)this;
|
||
AddRef();
|
||
}
|
||
}
|
||
lres = TRUE;
|
||
break;
|
||
|
||
case EM_GETSCROLLPOS:
|
||
{
|
||
POINT *point = (POINT *)lparam;
|
||
point->x = _pdp->GetUpScroll();
|
||
point->y = _pdp->GetVpScroll();
|
||
point->y = _pdp->ConvertVPosToScrollPos(point->y);
|
||
lres = 1;
|
||
}
|
||
break;
|
||
|
||
case EM_SETOLECALLBACK:
|
||
hr = E_FAIL;
|
||
if(lparam)
|
||
{
|
||
pobjmgr = GetObjectMgr();
|
||
if(pobjmgr)
|
||
{
|
||
pobjmgr->SetRECallback((IRichEditOleCallback *)lparam);
|
||
lres = TRUE;
|
||
hr = NOERROR;
|
||
}
|
||
}
|
||
break;
|
||
|
||
case EM_GETPAGE:
|
||
lres = -1; // Signal page not available
|
||
if(_pdp)
|
||
{
|
||
LONG i;
|
||
hr = _pdp->GetPage(&i, (DWORD)wparam, (CHARRANGE *)lparam);
|
||
if(hr == NOERROR)
|
||
lres = i;
|
||
}
|
||
break;
|
||
|
||
case EM_GETPARAFORMAT:
|
||
lres = OnGetParaFormat((PARAFORMAT2 *)lparam, wparam);
|
||
break;
|
||
|
||
case EM_GETSEL: // Has cp output parameter
|
||
lres = OnGetSel((LONG*)wparam, (LONG*)lparam);
|
||
break;
|
||
|
||
case EM_GETSELTEXT:
|
||
lres = OnGetSelText((TCHAR *)lparam);
|
||
break;
|
||
|
||
case WM_GETTEXT:
|
||
{
|
||
GETTEXTEX gt;
|
||
|
||
gt.cb = wparam * 2;
|
||
gt.flags = GT_USECRLF;
|
||
gt.codepage = 1200;
|
||
gt.lpDefaultChar = NULL;
|
||
gt.lpUsedDefChar = NULL;
|
||
|
||
lres = GetTextEx(>, (TCHAR *)lparam);
|
||
}
|
||
break;
|
||
|
||
case WM_GETTEXTLENGTH: // Has cp output parameter
|
||
{
|
||
GETTEXTLENGTHEX gtl;
|
||
|
||
gtl.flags = GTL_NUMCHARS | GTL_PRECISE | GTL_USECRLF;
|
||
gtl.codepage = 1200;
|
||
|
||
lres = GetTextLengthEx(>l);
|
||
}
|
||
break;
|
||
|
||
case EM_GETTEXTEX:
|
||
lres = GetTextEx((GETTEXTEX *)wparam, (TCHAR *)lparam);
|
||
break;
|
||
|
||
case EM_GETTEXTLENGTHEX: // Has cp output parameter
|
||
lres = GetTextLengthEx((GETTEXTLENGTHEX *)wparam);
|
||
break;
|
||
|
||
case EM_GETTEXTRANGE: // Has cp input parameter
|
||
{
|
||
TEXTRANGE * const ptr = (TEXTRANGE *)lparam;
|
||
LONG cch = ValidateTextRange(ptr);
|
||
|
||
// Only copy if there's something to copy and destination is valid
|
||
if(cch)
|
||
{
|
||
LONG cpMin = GetCpFromAcp(ptr->chrg.cpMin);
|
||
if(cch < 0) // Get text character count
|
||
cch = GetTextLength(); // because caller wants it all
|
||
else // + 1 is for terminating 0
|
||
cch = GetCpFromAcp(ptr->chrg.cpMost) - cpMin + 1;
|
||
|
||
if(!IsBadWritePtr(ptr->lpstrText, cch * sizeof(TCHAR)))
|
||
lres = GetTextRange(cpMin, cch, ptr->lpstrText);
|
||
}
|
||
}
|
||
break;
|
||
|
||
case EM_GETVIEWKIND:
|
||
GetViewKind(&lres);
|
||
break;
|
||
|
||
#ifndef NOWORDBREAKPROC
|
||
case EM_GETWORDBREAKPROC:
|
||
// Client can only use either WordBreakProc or ExWordBreakProc
|
||
// Return NULL if ExWordBreakProc is being used.
|
||
if (!_fExWordBreakProc)
|
||
lres = (LRESULT) _pfnWB;
|
||
break;
|
||
|
||
case EM_GETWORDBREAKPROCEX:
|
||
// Return ExWordBreakProc if it is being used.
|
||
if (_fExWordBreakProc)
|
||
lres = (LRESULT) _pfnWB;
|
||
break;
|
||
#endif
|
||
|
||
case EM_GETZOOM:
|
||
if(wparam && lparam)
|
||
{
|
||
*(unsigned *)wparam = GetZoomNumerator();
|
||
*(unsigned *)lparam = GetZoomDenominator();
|
||
lres = 1;
|
||
}
|
||
break;
|
||
|
||
case EM_HIDESELECTION:
|
||
if (Get10Mode() && lparam)
|
||
_fHideSelection = !!wparam;
|
||
|
||
if(!lparam || !_fFocus)
|
||
lres = OnHideSelectionChange((BOOL)wparam);
|
||
break;
|
||
|
||
case WM_HSCROLL:
|
||
if (IsUVerticalTflow(_pdp->GetTflow()))
|
||
{
|
||
WORD wCode = LOWORD(wparam);
|
||
wCode = InterchangeScrollCode(wCode);
|
||
LONG vpPos = HIWORD(wparam);
|
||
|
||
//In vertical displays the scrollbar position needs to be swapped.
|
||
if (_pdp->GetTflow() == tflowSW &&
|
||
(wCode == SB_THUMBTRACK || wCode == SB_THUMBPOSITION))
|
||
{
|
||
LONG vpMax, vpPage;
|
||
TxGetHScroll(NULL, &vpMax, NULL, &vpPage, NULL);
|
||
vpPos = vpMax - vpPos - vpPage;
|
||
vpPos = max(vpPos, 0);
|
||
}
|
||
|
||
hr = _pdp->VScroll(wCode, vpPos);
|
||
}
|
||
else
|
||
{
|
||
_pdp->UScroll(LOWORD(wparam), HIWORD(wparam));
|
||
hr = 0;
|
||
}
|
||
break;
|
||
|
||
case WM_KEYDOWN:
|
||
hr = OnTxKeyDown((WORD) wparam, (DWORD) lparam, publdr);
|
||
break;
|
||
|
||
case WM_KEYUP:
|
||
if(wparam == VK_APPS)
|
||
HandleKbdContextMenu();
|
||
else // Else don't say we processed
|
||
hr = S_FALSE; // message
|
||
|
||
W32->_fLRMorRLM = 0;
|
||
if(wparam == VK_CONTROL || wparam == VK_SHIFT)
|
||
{
|
||
// If a BiDi keyboard is installed, no strong-context behavior,
|
||
// both a Ctrl and a Shift key are pressed, no letter has been
|
||
// typed after the Ctrl and Shift keys have been pressed, and
|
||
// ReadOnly/Protected tests allow, then the selected paragraphs
|
||
// are set to RTL/LTR direction for the right/left Shift key,
|
||
// respectively. The keyboard and caret are also matched to this
|
||
// direction, and an alignment notification is sent.
|
||
// ReadOnly/Protected tests is removed for backward compatibility.
|
||
DWORD dwFlags = GetKeyboardFlags();
|
||
|
||
if (IsBiDiKbdInstalled() &&
|
||
!IsStrongContext(_nContextDir) &&
|
||
!IsStrongContext(_nContextAlign) &&
|
||
(dwFlags & CTRL) && (dwFlags & SHIFT) &&
|
||
!(dwFlags & LETAFTERSHIFT)
|
||
/* && IsntProtectedOrReadOnly(WM_KEYUP, wparam, lparam) */ )
|
||
{
|
||
CParaFormat PF;
|
||
PF._wEffects = (dwFlags & RSHIFT) ? PFE_RTLPARA : 0;
|
||
|
||
OnSetParaFormat(0, &PF, publdr, PFM_RTLPARA, PFM2_PARAFORMAT);
|
||
TxNotify(PF._wEffects ? EN_ALIGNRTL : EN_ALIGNLTR, 0);
|
||
}
|
||
if(wparam == VK_CONTROL)
|
||
lparam = (HIWORD(lparam) & KF_EXTENDED) ? RCTRL : LCTRL;
|
||
else
|
||
{
|
||
lparam = (LOBYTE(HIWORD(lparam)) == 0x36) ? RSHIFT : LSHIFT;
|
||
if(GetKeyState(VK_SHIFT) >= 0) // Ensure both shifts are off
|
||
lparam = SHIFT; // (potential Win95 problem)
|
||
}
|
||
ResetKeyboardFlag(lparam | LETAFTERSHIFT | HOTEURO);
|
||
}
|
||
else if(wparam == VK_MENU)
|
||
ResetKeyboardFlag((HIWORD(lparam) & KF_EXTENDED) ? (RALT | HOTEURO) : (LALT | HOTEURO));
|
||
|
||
break;
|
||
|
||
case WM_KILLFOCUS:
|
||
lres = OnKillFocus();
|
||
break;
|
||
|
||
case WM_LBUTTONDBLCLK:
|
||
hr = OnTxLButtonDblClk(MOUSEX, MOUSEY, (WORD) wparam);
|
||
break;
|
||
|
||
case WM_LBUTTONDOWN:
|
||
if(_fEatLeftDown)
|
||
{
|
||
TxSetFocus();
|
||
_fEatLeftDown = FALSE;
|
||
}
|
||
else
|
||
hr = OnTxLButtonDown(MOUSEX, MOUSEY, (WORD) wparam);
|
||
break;
|
||
|
||
case WM_LBUTTONUP:
|
||
hr = OnTxLButtonUp(MOUSEX, MOUSEY, (WORD) wparam, LB_RELEASECAPTURE | LB_FLUSHNOTIFY);
|
||
break;
|
||
|
||
#if !defined(NOMAGELLAN)
|
||
case WM_MBUTTONDBLCLK: // Magellan zmouse scroll
|
||
case WM_NCMBUTTONDOWN: // support commandeers middle
|
||
case WM_MBUTTONDOWN: // button.
|
||
OnTxMButtonDown(MOUSEX, MOUSEY, (WORD) wparam);
|
||
break;
|
||
|
||
case WM_MBUTTONUP:
|
||
OnTxMButtonUp(MOUSEX, MOUSEY, (WORD) wparam);
|
||
break;
|
||
|
||
case WM_MOUSEWHEEL: // Magellan zmouse scroll n lines.
|
||
lres = HandleMouseWheel(wparam, lparam);
|
||
break;
|
||
#endif
|
||
|
||
case EM_LINEFROMCHAR: // Has cp input parameter
|
||
lparam = wparam; // Fall thru to EM_EXLINEFROMCHAR
|
||
|
||
case EM_EXLINEFROMCHAR: // Has cp input parameter
|
||
hr = TxLineFromCp((LONG)lparam, &lres);
|
||
break;
|
||
|
||
case EM_LINEINDEX: // Has cp output parameter
|
||
hr = TxLineIndex((LONG)wparam, &lres);
|
||
break;
|
||
|
||
case EM_LINELENGTH: // Has cp input/output parameters
|
||
hr = TxLineLength((LONG)wparam, &lres);
|
||
break;
|
||
|
||
case EM_LINESCROLL: // Has cp input parameter (cch)
|
||
// Documentation says the line to scroll to should be relative to the current top line.
|
||
// Richedit 2.0 based it on an absolute position. We're breaking richedit 2.0 compatibility
|
||
// to go back to the documentation specification and to match what riched 1.0 originally
|
||
// did
|
||
hr = TxLineScroll((LONG)lparam, (LONG)wparam);// but not curr impl
|
||
lres = _pdp->IsMultiLine();
|
||
break;
|
||
|
||
#ifdef MA_ACTIVATE
|
||
case WM_MOUSEACTIVATE:
|
||
lres = MA_ACTIVATE;
|
||
// If the window that currently has focus is part of our "application",
|
||
// then don't eat the mouse click. Otherwise, if it's from another
|
||
// app, the user is probably trying to swap apps, so eat the mouse
|
||
// down message and let our host app get a chance to come to the
|
||
// foreground.
|
||
if (!(IsChild((HWND)wparam, GetFocus()) ||
|
||
(wparam && (HWND)wparam == GetFocus())))
|
||
{
|
||
_fEatLeftDown = TRUE;
|
||
}
|
||
hr = S_FALSE; // pass WM_MOUSEACTIVATE message to DefWindProc
|
||
break;
|
||
#endif
|
||
|
||
case WM_MOUSEMOVE:
|
||
// We reset the "number of tries to put an active object
|
||
// in place" count here
|
||
_cActiveObjPosTries = MAX_ACTIVE_OBJ_POS_TRIES;
|
||
hr = OnTxMouseMove(MOUSEX, MOUSEY, (WORD)wparam, publdr);
|
||
break;
|
||
|
||
case EM_OUTLINE:
|
||
{
|
||
CFreezeDisplay cfd(_pdp);
|
||
|
||
if(wparam == EMO_GETVIEWMODE)
|
||
{
|
||
hr = GetViewKind(&lres);
|
||
break;
|
||
}
|
||
|
||
CTxtSelection * psel = GetSelNC();
|
||
|
||
if(!_pdp->IsMultiLine() || !IsRich() || !psel) // Control must be rich,
|
||
break; // multiline and active
|
||
|
||
if(wparam == EMO_ENTER || wparam == EMO_EXIT)
|
||
{
|
||
hr = SetViewKind(wparam == EMO_ENTER ? VM_OUTLINE : VM_NORMAL);
|
||
lres = !hr;
|
||
break;
|
||
}
|
||
|
||
if(!IsInOutlineView() || !IsntProtectedOrReadOnly(msg, wparam, lparam))
|
||
break;
|
||
|
||
CTxtRange rg(*psel);
|
||
|
||
switch(wparam)
|
||
{
|
||
case EMO_PROMOTE:
|
||
hr = rg.Promote(lparam, publdr);
|
||
psel->Update_iFormat(-1);
|
||
psel->Update(FALSE);
|
||
break;
|
||
|
||
case EMO_EXPAND:
|
||
hr = rg.ExpandOutline((short)LOWORD(lparam),
|
||
HIWORD(lparam) == EMO_EXPANDDOCUMENT);
|
||
break;
|
||
|
||
case EMO_MOVESELECTION:
|
||
hr = MoveSelection(lparam, publdr);
|
||
psel->Update(TRUE);
|
||
break;
|
||
|
||
default:
|
||
// TraceMessage("Unknown outline function received\r\n");
|
||
break;
|
||
};
|
||
lres = !hr;
|
||
_fModified = TRUE;
|
||
}
|
||
break;
|
||
|
||
case WM_PASTE:
|
||
case EM_PASTESPECIAL:
|
||
if(IsntProtectedOrReadOnly(msg, wparam, lparam))
|
||
{
|
||
CTxtSelection *psel = GetSel();
|
||
|
||
hr = PasteDataObjectToRange(NULL, psel,
|
||
(CLIPFORMAT) wparam, (REPASTESPECIAL *)lparam, publdr,
|
||
PDOR_NONE);
|
||
}
|
||
break;
|
||
|
||
case WM_USER + 38: // For backward compat with NT 3.51
|
||
case EM_POSFROMCHAR: // Has cp input parameter
|
||
// RichEdit 2.x used wparam instead of lparam for the cp and ignored
|
||
// wparam, unlike RE 1.0 and the Win32 documentation (sigh!). We fix
|
||
// this, but are compatible with RE 2.x for cp's whose values
|
||
// correspond to invalid write ptr's.
|
||
if(IsBadWritePtr((LPPOINT)wparam, sizeof(POINT)))
|
||
{
|
||
// Invalid write ptr, so assume incorrect RE 2.0 params
|
||
// TODO: enable following Assert when msgtest gets updated
|
||
//AssertSz(FALSE,
|
||
// "EM_POSFROMCHAR: wparam is illegal ptr, assuming cp value");
|
||
POINT pt;
|
||
hr = TxPosFromChar((LONG)wparam, &pt);
|
||
lres = SUCCEEDED(hr) ? MAKELONG(pt.x, pt.y) : -1;
|
||
}
|
||
else
|
||
hr = TxPosFromChar((LONG)lparam, (LPPOINT)wparam);
|
||
break;
|
||
|
||
#ifndef NORBUTTON
|
||
case WM_RBUTTONDBLCLK:
|
||
case WM_RBUTTONDOWN:
|
||
case WM_RBUTTONUP:
|
||
// Give client a chance to handle these messages,
|
||
// if we are over a link
|
||
if(HandleLinkNotification(msg, wparam, lparam))
|
||
break;
|
||
|
||
if(msg == WM_RBUTTONUP)
|
||
hr = OnTxRButtonUp(MOUSEX, MOUSEY, (WORD) wparam, RB_DEFAULT);
|
||
|
||
else if( msg == WM_RBUTTONDOWN)
|
||
hr = OnTxRButtonDown(MOUSEX, MOUSEY, (WORD) wparam);
|
||
|
||
break;
|
||
#endif
|
||
|
||
case EM_INSERTTABLE:
|
||
lres = hr = OnInsertTable((TABLEROWPARMS *)wparam, (TABLECELLPARMS *)lparam, publdr);
|
||
break;
|
||
|
||
case EM_REPLACESEL:
|
||
wparam = wparam ? ST_CHECKPROTECTION | ST_SELECTION | ST_KEEPUNDO
|
||
: ST_CHECKPROTECTION | ST_SELECTION;
|
||
hr = SetText((LPTSTR)lparam, wparam, 1200, publdr, &lres);
|
||
break;
|
||
|
||
case EM_REQUESTRESIZE:
|
||
hr = _pdp->RequestResize();
|
||
break;
|
||
|
||
case EM_SCROLL:
|
||
// TxVScroll returns the number of lines scrolled;
|
||
// this info should be returned in lres
|
||
lres = _pdp->VScroll((WORD)wparam, 0);
|
||
break;
|
||
|
||
case EM_SCROLLCARET:
|
||
OnScrollCaret();
|
||
break;
|
||
|
||
case EM_SELECTIONTYPE:
|
||
{
|
||
SELCHANGE selchg;
|
||
|
||
GetSel()->SetSelectionInfo(&selchg);
|
||
lres = selchg.seltyp;
|
||
}
|
||
break;
|
||
|
||
case EM_SETTYPOGRAPHYOPTIONS:
|
||
// Don't allow typography options for password & accelerator instances
|
||
hr = OnSetTypographyOptions(wparam, lparam);
|
||
lres = (hr == S_OK);
|
||
break;
|
||
|
||
case EM_SETBIDIOPTIONS:
|
||
if((Get10Mode() || !wparam) && lparam && !IsRich())
|
||
{
|
||
WORD wMask = ((BIDIOPTIONS *)lparam)->wMask;
|
||
WORD wEffects = (_fNeutralOverride ? BOE_NEUTRALOVERRIDE : 0) |
|
||
(_nContextDir == CTX_NONE ? 0 : BOE_CONTEXTREADING) |
|
||
(_nContextAlign == CTX_NONE ? 0 : BOE_CONTEXTALIGNMENT);
|
||
|
||
wEffects &= ~wMask;
|
||
wEffects |= (wMask & ((BIDIOPTIONS *)lparam)->wEffects);
|
||
if (_fNeutralOverride != !!(wEffects & BOE_NEUTRALOVERRIDE))
|
||
{
|
||
_fNeutralOverride = !_fNeutralOverride;
|
||
if (!_pdp->IsPrinter()) // Refresh display
|
||
{
|
||
_pdp->InvalidateRecalc();
|
||
TxInvalidate();
|
||
}
|
||
}
|
||
_nContextDir = (WORD)((wEffects & BOE_CONTEXTREADING) ? CTX_NEUTRAL : CTX_NONE);
|
||
_nContextAlign = (WORD)((wEffects & BOE_CONTEXTALIGNMENT) ? CTX_NEUTRAL : CTX_NONE);
|
||
if(_nContextDir != CTX_NONE || _nContextAlign != CTX_NONE)
|
||
{
|
||
SetContextDirection(TRUE);
|
||
Assert(_nContextDir != CTX_NONE || _nContextAlign != CTX_NONE);
|
||
}
|
||
}
|
||
break;
|
||
|
||
case WM_SETFOCUS:
|
||
hr = OnSetFocus();
|
||
break;
|
||
|
||
case EM_SETFONTSIZE:
|
||
lres = OnSetFontSize(LONG(wparam), (DWORD)lparam, publdr);
|
||
break;
|
||
|
||
case EM_SETMODIFY:
|
||
_fModified = wparam != 0;
|
||
|
||
#ifdef LATER
|
||
if (!_fModified)
|
||
ObFreezeFrames();
|
||
#endif // LATER
|
||
break;
|
||
|
||
case EM_SETSCROLLPOS:
|
||
{
|
||
POINT *pPoint = (POINT*)lparam;
|
||
_pdp->ScrollView(pPoint->x, pPoint->y, FALSE, TRUE);
|
||
lres = 1;
|
||
}
|
||
break;
|
||
|
||
case EM_EXSETSEL:
|
||
// EM_EXSETSEL duplicates the functionality of the 32-bit EM_SETSEL
|
||
// and exists purely for backward compatibility with Win16. We just
|
||
// repackage the params and fall thru to EM_SETSEL
|
||
wparam = (WPARAM)((CHARRANGE *)lparam)->cpMin;
|
||
lparam = (LPARAM)((CHARRANGE *)lparam)->cpMost;
|
||
|
||
// FALL-THROUGH to EM_SETSEL!!!
|
||
|
||
case EM_SETSEL:
|
||
lres = OnSetSel((LONG)wparam, (LONG)lparam);
|
||
break;
|
||
|
||
// INCREDIBLY EVIL HACK ALERT!!!!! Win95's dialog manager doesn't even
|
||
// pretend to be 32 bits despite the best attempts of our marketing dudes.
|
||
// WM_USER + 1 is the old Win3.0 EM_SETSEL in which the selection range
|
||
// was packed into the lparam.
|
||
//
|
||
// Sometimes (like tabbing through a dialog), Win95 will send us the 16
|
||
// bit EM_SETSEL message, so process it here.
|
||
case (WM_USER + 1):
|
||
lres = OnSetSel(LOWORD(lparam), HIWORD(lparam));
|
||
break;
|
||
|
||
case EM_SETTARGETDEVICE:
|
||
// Keep width sane so that LXtoDX works OK at least for displays
|
||
// Note that 0x7fffff = 485 feet! This keeps LXtoDX working provided
|
||
// _xPerInch < 257 (it's typically 96 for displays). For more
|
||
// generality, we'd need to use 64-bit arithmetic (see LXtoDX).
|
||
lparam = min(lparam, (LPARAM)0x7fffff);
|
||
lres = _pdp->SetMainTargetDC((HDC)wparam, (LONG)lparam);
|
||
break;
|
||
|
||
case EM_SETTEXTEX:
|
||
hr = SetText((LPTSTR)lparam, ((SETTEXTEX *)wparam)->flags,
|
||
((SETTEXTEX *)wparam)->codepage, publdr, &lres);
|
||
break;
|
||
|
||
case WM_SETTEXT:
|
||
hr = SetText((LPTSTR)lparam, ST_CHECKPROTECTION, wparam ? wparam : 1200, publdr, &lres);
|
||
break;
|
||
|
||
case EM_SETVIEWKIND:
|
||
hr = SetViewKind(wparam);
|
||
break;
|
||
|
||
#ifndef NOWORDBREAKPROC
|
||
case EM_SETWORDBREAKPROC:
|
||
_fExWordBreakProc = 0;
|
||
_pfnWB = (EDITWORDBREAKPROC) lparam;
|
||
break;
|
||
|
||
case EM_SETWORDBREAKPROCEX:
|
||
// We don't support this API in 2.0 and greater because we pass
|
||
// UNICODE text to the callback function. Therefore there
|
||
// are no benefits to this API. Exists for 1.0 backward
|
||
// compatibility only.
|
||
if (Get10Mode())
|
||
{
|
||
_fExWordBreakProc = 1;
|
||
|
||
// This is a bit deceiving, but lparam is a EDITWORDBREAKPROCEX but the compiler
|
||
// will generate an error if you try to type cast the l-value
|
||
_pfnWB = (EDITWORDBREAKPROC) lparam;
|
||
}
|
||
break;
|
||
#endif
|
||
|
||
case WM_SYSCHAR:
|
||
lres = hr = OnTxSysChar((WORD)wparam, (DWORD)lparam, publdr);
|
||
if(hr == S_OK)
|
||
break;
|
||
goto def;
|
||
|
||
case WM_SYSKEYUP:
|
||
if(IN_RANGE(VK_SHIFT, wparam, VK_MENU))
|
||
ResetKeyboardFlag(GetKbdFlags((WORD)wparam, (DWORD)lparam));
|
||
|
||
if (IN_RANGE(VK_NUMPAD0, wparam, VK_NUMPAD9) ||
|
||
wparam == VK_CLEAR || wparam == VK_INSERT ||
|
||
IN_RANGE(VK_PRIOR, wparam, VK_DOWN))
|
||
{
|
||
// Collect AltNumPad number to word around NT 4 bug and
|
||
// generalize to any Unicode value (in decimal, ugh!)
|
||
const static BYTE VkeyNumbers[] = {VK_NUMPAD9, VK_NUMPAD3, VK_NUMPAD1,
|
||
VK_NUMPAD7, VK_NUMPAD4, VK_NUMPAD8, VK_NUMPAD6, VK_NUMPAD2, 0, 0,
|
||
0, 0, VK_NUMPAD0};
|
||
// Flag Alt NumPad char typed to
|
||
SetKeyboardFlag(ALTNUMPAD); // distinguish hiANSI from lead
|
||
if(!IN_RANGE(VK_NUMPAD0, wparam, VK_NUMPAD9)) // byte in Win3.1 IME
|
||
{ // Collect AltNumPad number
|
||
if(wparam == VK_CLEAR) // NumLock not active: translate
|
||
wparam = VK_NUMPAD5; // to digit codes
|
||
else
|
||
wparam = VkeyNumbers[wparam - VK_PRIOR];
|
||
}
|
||
DWORD dwNum = GetKeyPadNumber();
|
||
if(!dwNum && wparam == VK_NUMPAD0)
|
||
SetKeyboardFlag(ALT0); // Flag that 0 is first digit
|
||
SetKeyPadNumber(10*dwNum + wparam - VK_NUMPAD0);
|
||
}
|
||
goto def;
|
||
|
||
case WM_SYSKEYDOWN:
|
||
if(OnTxSysKeyDown(wparam, lparam, publdr) == S_OK)
|
||
{
|
||
lres = TRUE;
|
||
break;
|
||
}
|
||
goto def;
|
||
|
||
case WM_TIMER:
|
||
OnTxTimer((UINT)wparam);
|
||
goto def;
|
||
|
||
case EM_UNDO:
|
||
case WM_UNDO:
|
||
if (!_fReadOnly)
|
||
{
|
||
hr = PopAndExecuteAntiEvent(_pundo, (void*)wparam);
|
||
if(hr == NOERROR)
|
||
lres = TRUE;
|
||
}
|
||
break;
|
||
|
||
case EM_REDO:
|
||
if (!_fReadOnly)
|
||
{
|
||
hr = PopAndExecuteAntiEvent(_predo, (void*)wparam);
|
||
if(hr == NOERROR)
|
||
lres = TRUE;
|
||
}
|
||
break;
|
||
|
||
case EM_SETUNDOLIMIT:
|
||
lres = HandleSetUndoLimit((DWORD)wparam);
|
||
break;
|
||
|
||
case WM_VSCROLL:
|
||
// TxVScroll returns the number of lines scrolled;
|
||
// WM_VSCROLL doesn't care about that info however.
|
||
Assert(lres == 0);
|
||
Assert(hr == NOERROR);
|
||
|
||
if (IsUVerticalTflow(_pdp->GetTflow()))
|
||
_pdp->UScroll(LOWORD(wparam), HIWORD(wparam));
|
||
else
|
||
_pdp->VScroll(LOWORD(wparam), HIWORD(wparam));
|
||
break;
|
||
|
||
case EM_GETHYPHENATEINFO:
|
||
{
|
||
HYPHENATEINFO *phyphinfo = (HYPHENATEINFO*) wparam;
|
||
if (phyphinfo->cbSize >= sizeof(HYPHENATEINFO))
|
||
{
|
||
phyphinfo->pfnHyphenate = _pfnHyphenate;
|
||
phyphinfo->dxHyphenateZone = _dulHyphenateZone;
|
||
}
|
||
else
|
||
hr = E_INVALIDARG;
|
||
}
|
||
break;
|
||
|
||
case EM_SETHYPHENATEINFO:
|
||
{
|
||
HYPHENATEINFO *phyphinfo = (HYPHENATEINFO*) wparam;
|
||
if (phyphinfo->cbSize >= sizeof(HYPHENATEINFO))
|
||
{
|
||
BOOL fRedraw = FALSE;
|
||
if (phyphinfo->pfnHyphenate != _pfnHyphenate ||
|
||
_pfnHyphenate && _dulHyphenateZone != phyphinfo->dxHyphenateZone)
|
||
fRedraw = TRUE;
|
||
|
||
_pfnHyphenate = phyphinfo->pfnHyphenate;
|
||
_dulHyphenateZone = _pfnHyphenate ? phyphinfo->dxHyphenateZone : 0;
|
||
if (fRedraw)
|
||
_pdp->UpdateView();
|
||
}
|
||
else
|
||
hr = E_INVALIDARG;
|
||
}
|
||
break;
|
||
|
||
case EM_GETAUTOCORRECTPROC:
|
||
{
|
||
if (_pDocInfo)
|
||
lres = (LRESULT) _pDocInfo->_pfnAutoCorrect;
|
||
}
|
||
break;
|
||
|
||
case EM_SETAUTOCORRECTPROC:
|
||
{
|
||
CDocInfo *pDocInfo = GetDocInfo();
|
||
if (pDocInfo)
|
||
pDocInfo->_pfnAutoCorrect = (AutoCorrectProc) wparam;
|
||
else;
|
||
lres = TRUE;
|
||
}
|
||
break;
|
||
|
||
// Old stuff that's no longer supported
|
||
case EM_FMTLINES: // Controls returning CRCRLFs for soft
|
||
// line breaks in EM_GETTEXT. Could
|
||
// implement
|
||
case WM_GETFONT: // Can support but have to hang onto a
|
||
// default HFONT. CCcs has an _hfont, but
|
||
// need to be sure default font is in
|
||
// cache at time of return
|
||
#ifdef EM_GETHANDLE
|
||
case EM_GETHANDLE: // Not supported by Win95 32-bit MLE either
|
||
case EM_SETHANDLE: // Not supported by Win95 32-bit MLE either
|
||
#endif
|
||
|
||
#ifdef DEBUG
|
||
TRACEINFOSZ("Old message that is no longer supported.");
|
||
#endif
|
||
break;
|
||
|
||
case EM_SETTABSTOPS:
|
||
{
|
||
// this message only works for multi-line edit controls
|
||
if(!_pdp->IsMultiLine())
|
||
break;
|
||
|
||
// perform some validation checks
|
||
Assert(lparam || !wparam);
|
||
LPDWORD prgdwdlgCoord = (LPDWORD)lparam;
|
||
if (wparam && (!prgdwdlgCoord || !(*prgdwdlgCoord)))
|
||
break;
|
||
AssertSz(wparam <= MAX_TAB_STOPS, "Tab stop count beyond maximum allowed");
|
||
if (wparam > MAX_TAB_STOPS)
|
||
wparam = MAX_TAB_STOPS;
|
||
|
||
PARAFORMAT2 pf;
|
||
ZeroMemory(&pf, sizeof(PARAFORMAT2));
|
||
pf.cbSize = sizeof(PARAFORMAT2);
|
||
|
||
// contains the average width for the default font
|
||
LONG lAvgWidth;
|
||
|
||
//Average char width based on default font
|
||
HDC hdc = _phost->TxGetDC();
|
||
GetECDefaultHeightAndWidth(this, hdc, 1, 1,
|
||
W32->GetYPerInchScreenDC(), &lAvgWidth, NULL, NULL);
|
||
_phost->TxReleaseDC(hdc);
|
||
|
||
Assert(lAvgWidth);
|
||
|
||
// According to documentation wparam == 1 means the tab settings
|
||
// will be set at incremental positions *prgdwdlgCoord and wparam == 0
|
||
// the tab settings will be set at the default incremental position 32 (dialog coord)
|
||
long lTab = (wparam) ? *prgdwdlgCoord : 32;
|
||
long nCt = (wparam <= 1) ? MAX_TAB_STOPS : (signed)wparam;
|
||
for (int i = 0; i < nCt; i++)
|
||
{
|
||
long lval;
|
||
lval = (wparam <= 1) ? ((i+1) * lTab) : *prgdwdlgCoord;
|
||
pf.rgxTabs[i] = MulDiv(MulDiv(lval, lAvgWidth, 4), 1440, W32->GetXPerInchScreenDC());
|
||
if((unsigned)pf.rgxTabs[i] > 0xFFFFFF) // Keep in range
|
||
pf.rgxTabs[i] = 0xFFFFFF;
|
||
prgdwdlgCoord++;
|
||
}
|
||
|
||
// Set the default paragraph formatting
|
||
pf.cTabCount = nCt;
|
||
pf.dwMask = PFM_TABSTOPS;
|
||
CParaFormat PF;
|
||
PF.Set(&pf);
|
||
|
||
// Need to turn off group typing just like the selection would.
|
||
if (publdr)
|
||
publdr->StopGroupTyping();
|
||
|
||
lres = OnSetParaFormat(SPF_SETDEFAULT, &PF, publdr, PFM_TABSTOPS, PFM2_PARAFORMAT);
|
||
GetTabsCache()->Release(PF._iTabs);
|
||
break;
|
||
}
|
||
|
||
case EM_SETCHARFORMAT:
|
||
{
|
||
CHARFORMAT2 *pCF2 = (CHARFORMAT2 *)lparam;
|
||
UINT CodePage = 1200;
|
||
DWORD dwMask = pCF2->dwMask;
|
||
DWORD dwMask2 = 0;
|
||
|
||
if(!IsValidCharFormatW(pCF2))
|
||
{
|
||
if(!IsValidCharFormatA((CHARFORMAT2A *)lparam))
|
||
break;
|
||
if(dwMask & CFM_FACE) // Need to convert to Unicode
|
||
CodePage = GetDefaultCodePage(EM_SETCHARFORMAT);
|
||
}
|
||
|
||
if(dwMask & CFM_CHARSET && CharRepFromCharSet(pCF2->bCharSet) < 0)
|
||
dwMask &= ~CFM_CHARSET;
|
||
|
||
if(wparam & (SCF_ASSOCIATEFONT | SCF_ASSOCIATEFONT2))
|
||
{
|
||
lres = OnSetAssociateFont(pCF2, (DWORD)wparam);
|
||
break;
|
||
}
|
||
|
||
if(Get10Mode() && (dwMask & CFM_SIZE) && (pCF2->yHeight <= 0))
|
||
{
|
||
// 1.0 has a hack where if the height is being set and it is
|
||
// negative, then the height field is ignored.
|
||
dwMask &= ~CFM_SIZE;
|
||
}
|
||
|
||
if (pCF2->cbSize == sizeof(CHARFORMATW) ||
|
||
pCF2->cbSize == sizeof(CHARFORMATA))
|
||
{
|
||
// Restrict specifications to CHARFORMAT parameters. If the
|
||
// host isn't our Windows host, we allow this to include the
|
||
// CHARFORMAT2 disabled effect, since Forms^3 wanted that effect
|
||
// but wasn't willing to use CHARFORMAT2 (even tho they asked
|
||
// for it...)
|
||
dwMask &= fInOurHost() ? CFM_ALL : (CFM_ALL | CFM_DISABLED);
|
||
dwMask2 = CFM2_CHARFORMAT; // Tell callees that CHARFORMAT
|
||
} // was used
|
||
|
||
CCharFormat CF; // Transfer external CHARFORMAT(2)
|
||
CF.Set(pCF2, CodePage); // parms to internal CCharFormat
|
||
lres = OnSetCharFormat(wparam, &CF, publdr, dwMask, dwMask2);
|
||
break;
|
||
}
|
||
case WM_SETFONT:
|
||
lres = OnSetFont((HFONT)wparam);
|
||
break;
|
||
|
||
case EM_SETPAGE:
|
||
if(_pdp)
|
||
hr = _pdp->SetPage(wparam);
|
||
break;
|
||
|
||
case EM_SETPARAFORMAT:
|
||
{
|
||
PARAFORMAT2 *pPF2 = (PARAFORMAT2 *)lparam;
|
||
|
||
if(!IsValidParaFormat(pPF2))
|
||
break;
|
||
|
||
DWORD dwMask = pPF2->dwMask;
|
||
|
||
// Two more things to validate: (1) We don't let an applications set
|
||
// up tables and (2) Tabs coming from applications must be valid.
|
||
if(dwMask & (PFM_TABLE | PFM_TABLEROWDELIMITER |
|
||
PFM_OUTLINELEVEL | PFM_COLLAPSED))
|
||
{
|
||
// Trying to set up a table or outline view
|
||
break;
|
||
}
|
||
|
||
if ((dwMask & PFM_TABSTOPS) && (pPF2->cTabCount != 0))
|
||
{
|
||
// Make sure all submitted tabstops make sense.
|
||
int iMax = min(MAX_TAB_STOPS, pPF2->cTabCount);
|
||
|
||
for (int i = 0; i < iMax; i++)
|
||
{
|
||
// Make sure that tab stops make sense - make sure alignment
|
||
// is valid.
|
||
if (GetTabAlign(pPF2->rgxTabs[i]) > tomAlignBar)
|
||
{
|
||
// Invalid alignment.
|
||
break;
|
||
}
|
||
}
|
||
|
||
if (i != iMax)
|
||
{
|
||
// Found error in validation loop so we are done.
|
||
break;
|
||
}
|
||
}
|
||
|
||
DWORD dwMask2 = 0;
|
||
if(pPF2->cbSize == sizeof(PARAFORMAT))
|
||
{
|
||
dwMask &= PFM_ALL; // Restrict to PARAFORMAT parms
|
||
dwMask2 = PFM2_PARAFORMAT; // Tell callees that
|
||
} // PARAFORMAT was used
|
||
|
||
CParaFormat PF; // Transfer external PARAFORMAT(2)
|
||
PF.Set(pPF2); // parms to internal CParaFormat
|
||
lres = OnSetParaFormat(wparam, &PF, publdr, dwMask, dwMask2);
|
||
GetTabsCache()->Release(PF._iTabs);
|
||
break;
|
||
}
|
||
|
||
case EM_SETZOOM:
|
||
if ((unsigned)(wparam | lparam) < 65536 && (!(wparam | lparam) ||
|
||
(LONG)wparam < (lparam << 6) && lparam < (LONG)(wparam << 6)))
|
||
{
|
||
// Only get here if
|
||
// 1) 0 <= wparam <= 65535 and 0 <= lparam <= 65535, and
|
||
// 2) either wparam = lparam = 0 (which turns off zooming by this
|
||
// message) or 1/64 < (zoom factor given by wparam/lparam) < 64.
|
||
SetZoomNumerator(wparam);
|
||
SetZoomDenominator(lparam);
|
||
_pdp->UpdateView();
|
||
lres = 1;
|
||
}
|
||
break;
|
||
|
||
case EM_STREAMIN:
|
||
case EM_STREAMOUT:
|
||
{
|
||
CTxtRange rg(this, 0, -GetTextLength());
|
||
CTxtRange * prg = &rg; // Default whole doc
|
||
|
||
wparam = W32->ValidateStreamWparam(wparam);
|
||
if(wparam & SFF_SELECTION) // Save to current selection
|
||
{
|
||
prg = (CTxtRange *)GetSel();
|
||
AssertSz(prg,
|
||
"EM_STREAMIN/OUT: requested selection doesn't exist");
|
||
}
|
||
else if(msg == EM_STREAMIN)
|
||
{
|
||
// If we are not streaming into the selection, then we are
|
||
// "loading" the entire file; this is not an undo-able operation,
|
||
// so set the undo builder to NULL and get rid of the current
|
||
// undo stacks
|
||
publdr = NULL;
|
||
ClearUndo(&undobldr);
|
||
|
||
// Clear away the file info if necessary
|
||
if(!(wparam & SFF_KEEPDOCINFO))
|
||
CloseFile(FALSE);
|
||
}
|
||
|
||
if(msg == EM_STREAMIN)
|
||
{
|
||
// If we are going to be loading an entire file, we only
|
||
// want to check "normal' protection; we can ignore the
|
||
// fIsDBCS protection. This does mean that somebody
|
||
// can do an "insert file" and break apart a DBCS combo,
|
||
// but we'll have to live with that. Outlook uses
|
||
// RTF streaming in many different places, so the strong
|
||
// fIsDBCS protection breaks them.
|
||
if ((_dwEventMask & ENM_PROTECTED) &&
|
||
prg->IsProtected(CHKPROT_EITHER) == PROTECTED_ASK &&
|
||
QueryUseProtection(prg, msg, wparam, lparam))
|
||
{
|
||
Beep();
|
||
Assert(lres == 0);
|
||
break;
|
||
}
|
||
|
||
// Freeze the display before loading
|
||
CFreezeDisplay fd(_pdp);
|
||
|
||
lres = _ldte.LoadFromEs(prg, wparam, (EDITSTREAM *)lparam,
|
||
FALSE, publdr);
|
||
|
||
if (_fOutlineView)
|
||
{
|
||
// Outline view must have formatting.
|
||
_psel->Check_rpPF();
|
||
}
|
||
|
||
if (_fFocus)
|
||
{
|
||
// Update caret but delay till display is thawed and do so only
|
||
// if we have the focus. If we do this all the time we get wierd
|
||
// scrolling effects such as scrolling to the beginning of a
|
||
// document when the focus is set. See bug #1649 for repro of
|
||
// wierd effects.
|
||
_pdp->SaveUpdateCaret(TRUE);
|
||
}
|
||
}
|
||
else
|
||
lres = _ldte.SaveToEs (prg, wparam, (EDITSTREAM *)lparam);
|
||
break;
|
||
}
|
||
|
||
#ifdef WM_SYSCOLORCHANGE
|
||
case WM_SYSCOLORCHANGE:
|
||
#ifndef NODRAFTMODE
|
||
if (_fDraftMode)
|
||
{
|
||
W32->InitSysParams(TRUE);
|
||
_pdp->InvalidateRecalc();
|
||
}
|
||
#endif
|
||
TxInvalidate();
|
||
break;
|
||
#endif
|
||
|
||
// debug stuff
|
||
#if defined(DEBUG) && !defined(NOFULLDEBUG)
|
||
case EM_DBGPED:
|
||
OnDumpPed();
|
||
break;
|
||
#endif // DEBUG
|
||
|
||
case EM_SETEVENTMASK:
|
||
lres = _dwEventMask; // Set up to return value before
|
||
_dwEventMask = (DWORD)lparam; // the change
|
||
|
||
if (lparam & ENM_REQUESTRESIZE)
|
||
{
|
||
// We need to update the display just in case it changes.
|
||
_pdp->UpdateView();
|
||
}
|
||
break;
|
||
|
||
case EM_GETEVENTMASK:
|
||
lres = _dwEventMask;
|
||
break;
|
||
|
||
#ifdef EM_GETTHUMB
|
||
case EM_GETTHUMB:
|
||
LONG Pos;
|
||
BOOL fIsEnabled;
|
||
|
||
if (TxGetVScroll(NULL, NULL, &Pos, NULL, &fIsEnabled) == S_OK
|
||
&& fIsEnabled)
|
||
{
|
||
lres = Pos;
|
||
}
|
||
break;
|
||
#endif
|
||
|
||
case EM_SETLANGOPTIONS:
|
||
_fAutoFont = (lparam & IMF_AUTOFONT) != 0;
|
||
_fAutoKeyboard = (lparam & IMF_AUTOKEYBOARD) != 0;
|
||
_fAutoFontSizeAdjust = (lparam & IMF_AUTOFONTSIZEADJUST) != 0;
|
||
_fDualFont = (lparam & IMF_DUALFONT) != 0;
|
||
_fUIFont = (lparam & IMF_UIFONTS) != 0;
|
||
lres = 1;
|
||
break;
|
||
|
||
case EM_GETLANGOPTIONS:
|
||
if(_fAutoFont)
|
||
lres |= IMF_AUTOFONT;
|
||
if(_fAutoKeyboard)
|
||
lres |= IMF_AUTOKEYBOARD;
|
||
if(_fAutoFontSizeAdjust)
|
||
lres |= IMF_AUTOFONTSIZEADJUST;
|
||
if(_fDualFont)
|
||
lres |= IMF_DUALFONT;
|
||
if(_fUIFont)
|
||
lres |= IMF_UIFONTS;
|
||
break;
|
||
|
||
case EM_SETEDITSTYLE:
|
||
if (!Get10Mode()) // Not support in 1.0 mode
|
||
{
|
||
BOOL fForceRepaint = FALSE;
|
||
DWORD dwEditStyle = _dwEditStyle & ~lparam; // Kill current flag values
|
||
// Change following mask to give the largest SES_xxx defined)
|
||
dwEditStyle |= wparam & lparam & (SES_CTFALLOWPROOFING*2 - 1); // Or in new values
|
||
|
||
// Certain bits aren't switchable
|
||
dwEditStyle |= (_fSystemEditMode ? SES_EMULATESYSEDIT : 0);
|
||
_dwEditStyle = dwEditStyle;
|
||
|
||
// There are certain things which we won't allow user to reset, ie SES_EMULATESYSEDIT.
|
||
// So reset everything and except for the SES_EMULATESYSEDIT
|
||
if(dwEditStyle & SES_EMULATESYSEDIT)
|
||
{
|
||
if(SUCCEEDED(HandleSetTextMode(TM_SINGLELEVELUNDO | TM_PLAINTEXT)))
|
||
{
|
||
// SES_EMULATESYSEDIT implies SES_BEEPONMAXTEXT
|
||
_fSystemEditBeep = TRUE;
|
||
}
|
||
else
|
||
_fSystemEditMode = FALSE;
|
||
}
|
||
|
||
#ifndef NODRAFTMODE
|
||
// Repaint and recalc if draft mode is turned on or off
|
||
if (lparam & SES_DRAFTMODE)
|
||
fForceRepaint = TRUE;
|
||
#endif
|
||
|
||
if (fForceRepaint || (lparam & SES_USEATFONT))
|
||
{
|
||
_pdp->InvalidateRecalc();
|
||
TxInvalidate();
|
||
}
|
||
|
||
if(dwEditStyle & SES_BIDI)
|
||
OrCharFlags(FRTL, publdr);
|
||
|
||
_fLowerCase = !_fUpperCase && (dwEditStyle & SES_LOWERCASE);
|
||
} // Fall thru to EM_GETEDITSTYLE
|
||
// to return _bEditStyle
|
||
case EM_GETEDITSTYLE:
|
||
if (!Get10Mode()) // Not support in 1.0 mode
|
||
lres |= _dwEditStyle; // Some EditStyles have been filled in Cmsgflt
|
||
|
||
break;
|
||
|
||
case EM_SETPAGEROTATE:
|
||
lres = HandleSetTextFlow(wparam);
|
||
break;
|
||
|
||
case EM_GETPAGEROTATE:
|
||
lres = _pdp->GetTflow();
|
||
break;
|
||
|
||
case EM_SETTEXTMODE:
|
||
// 1.0 mode does not supported EM_SETTEXTMODE
|
||
if (!Get10Mode())
|
||
lres = HandleSetTextMode(wparam);
|
||
break;
|
||
|
||
case EM_GETTEXTMODE:
|
||
lres = IsRich() ? TM_RICHTEXT : TM_PLAINTEXT;
|
||
|
||
lres |= (_pundo && ((CUndoStack *)_pundo)->GetSingleLevelMode())
|
||
? TM_SINGLELEVELUNDO : TM_MULTILEVELUNDO;
|
||
|
||
lres |= _fSingleCodePage ? TM_SINGLECODEPAGE : TM_MULTICODEPAGE;
|
||
break;
|
||
|
||
case EM_LIMITTEXT:
|
||
lparam = wparam;
|
||
// Intentionally fall through. These messages are duplicates. But
|
||
// Win9x manages to convert wparam = 0x3FFFFFFF to 0xFFFFFFFF. No
|
||
// such problem exists with EM_EXLIMITTEXT.
|
||
|
||
case EM_EXLIMITTEXT: // Has cp input parameter (sort of)
|
||
if(!lparam) // We ignore translation between
|
||
{ // acp and cp
|
||
// 0 means set the control to the maximum size. However, because
|
||
// 1.0 set this to 64K will keep this the same value so as not to
|
||
// surprise anyone. Apps are free to set the value to be above 64K.
|
||
lparam = (LPARAM)cResetTextMax;
|
||
}
|
||
if (Get10Mode())
|
||
{
|
||
// 1.0 used a signed variable to hold the length of the string. So
|
||
// if lparam is negative then just set lparam to zero to emulate
|
||
// 1.0 behavior
|
||
if ((LONG)lparam < 0)
|
||
lparam = 0;
|
||
}
|
||
_cchTextMost = (LONG)lparam;
|
||
break;
|
||
|
||
case EM_AUTOURLDETECT:
|
||
if(lparam || (wparam | 1) != 1)
|
||
{
|
||
hr = lres = E_INVALIDARG;
|
||
break;
|
||
}
|
||
if(wparam == TRUE && !_pdetecturl)
|
||
{
|
||
_pdetecturl = new CDetectURL(this);
|
||
if(!_pdetecturl)
|
||
hr = lres = E_OUTOFMEMORY;
|
||
}
|
||
else if(!wparam && _pdetecturl)
|
||
{
|
||
delete _pdetecturl;
|
||
_pdetecturl = NULL;
|
||
}
|
||
break;
|
||
|
||
case EM_GETAUTOURLDETECT:
|
||
Assert(lres == 0 && hr == NOERROR);
|
||
if(_pdetecturl)
|
||
lres = TRUE;
|
||
break;
|
||
|
||
case WM_SIZE:
|
||
// We reset the "number of tries to put an active object
|
||
// in place" count here
|
||
_cActiveObjPosTries = MAX_ACTIVE_OBJ_POS_TRIES;
|
||
hr = S_FALSE;
|
||
break;
|
||
|
||
case WM_SETTINGCHANGE:
|
||
// System parameters have changed. We need to update them.
|
||
// Note : Since we don't protect access to system parameters
|
||
// with locks, it may be possible for some instances to not
|
||
// see the changes immediately
|
||
lres = 0;
|
||
W32->InitSysParams(TRUE);
|
||
|
||
#ifndef NODRAFTMODE
|
||
if (_fDraftMode)
|
||
{
|
||
_pdp->InvalidateRecalc();
|
||
TxInvalidate();
|
||
}
|
||
#endif
|
||
|
||
#ifndef NOCOMPLEXSCRIPTS
|
||
if (W32->GetDigitSubstitutionMode() != DIGITS_NOTIMPL)
|
||
OrCharFlags(FRTL, publdr);
|
||
#endif
|
||
|
||
break;
|
||
|
||
case EM_CONVPOSITION:
|
||
if (wparam)
|
||
lres = GetCpFromAcp(lparam);
|
||
else
|
||
lres = GetAcpFromCp(lparam);
|
||
break;
|
||
|
||
#ifndef NOPRIVATEMESSAGE
|
||
case EM_INSERTOBJ:
|
||
{
|
||
// This message supports Cicero InsertEmbedded
|
||
int cpMin = ((CHARRANGE *)wparam)->cpMin;
|
||
int cpMost = ((CHARRANGE *)wparam)->cpMost;
|
||
CTxtRange rg(this, cpMin, cpMin - cpMost);
|
||
REPASTESPECIAL rps; // @parm Special paste info
|
||
rps.dwAspect = DVASPECT_CONTENT;
|
||
|
||
hr = S_FALSE;
|
||
if (!rg.WriteAccessDenied())
|
||
hr = _ldte.CreateOleObjFromDataObj((IDataObject *)lparam, &rg, &rps, iEmbObj, publdr);
|
||
}
|
||
break;;
|
||
|
||
case EM_SETCALLBACK: // Setup message filter callback
|
||
_pMsgCallBack = (CMsgCallBack *)lparam;
|
||
break;
|
||
|
||
case EM_SETUPNOTIFY:
|
||
if (!_pMsgNotify)
|
||
_pMsgNotify = new CTextNotify(this);
|
||
|
||
if (_pMsgNotify)
|
||
{
|
||
if (wparam == 0)
|
||
_pMsgNotify->Remove((ITxNotify *)lparam);
|
||
else
|
||
_pMsgNotify->Add((ITxNotify *)lparam);
|
||
}
|
||
|
||
break;
|
||
|
||
case EM_GETDOCFLAGS:
|
||
lres = 0;
|
||
if (_fReadOnly)
|
||
lres |= GDF_READONLY;
|
||
|
||
if (_fOverstrike)
|
||
lres |= GDF_OVERTYPE;
|
||
|
||
if (_fSingleCodePage)
|
||
lres |= GDF_SINGLECPG;
|
||
|
||
if (_fRich)
|
||
lres |= GDF_RICHTEXT;
|
||
|
||
lres &= wparam;
|
||
|
||
break;
|
||
|
||
case EM_GETPARATXTFLOW:
|
||
{
|
||
CTxtPara *pTxtPara = (CTxtPara *)lparam;
|
||
lres = pTxtPara->_PF.IsRtlPara();
|
||
break;
|
||
}
|
||
|
||
#endif
|
||
|
||
#ifndef NOACCESSIBILITY
|
||
case WM_GETOBJECT:
|
||
{
|
||
IUnknown* punk = NULL;
|
||
|
||
lres = 0;
|
||
|
||
if (lparam == OBJID_NATIVEOM)
|
||
{
|
||
QueryInterface(IID_IUnknown, (void**)&punk); // Need to expose Tom interdface
|
||
}
|
||
else if (lparam == OBJID_CLIENT && _fInOurHost)
|
||
{
|
||
HWND hwnd = NULL;
|
||
|
||
TxGetWindow( &hwnd );
|
||
|
||
if (hwnd)
|
||
W32->CreateStdAccessibleProxyW(hwnd, L"RichEdit", OBJID_CLIENT, IID_IAccessible, (void**)&punk);
|
||
}
|
||
|
||
if (punk)
|
||
{
|
||
lres = W32->LResultFromObject(IID_IUnknown, wparam, (LPUNKNOWN)punk);
|
||
punk->Release();
|
||
}
|
||
break;
|
||
}
|
||
#endif
|
||
|
||
default:
|
||
def: hr = S_FALSE;
|
||
break;
|
||
}
|
||
|
||
if(plresult)
|
||
*plresult = lres;
|
||
|
||
#ifndef NOFEPROCESSING
|
||
if (hr == S_FALSE && _pMsgFilter && _pMsgCallBack)
|
||
{
|
||
HWND hWnd;
|
||
|
||
TxGetWindow(&hWnd);
|
||
hr = _pMsgCallBack->HandlePostMessage(hWnd, msg, wparam, lparam, plresult);
|
||
}
|
||
#endif
|
||
return hr;
|
||
}
|
||
|
||
/*
|
||
* CTxtEdit::TxDraw (dwDrawAspect, lindex, pvAspect, ptd, hdcDraw,
|
||
* hicTargetDev, lprcBounds, lprcWBounds, lprcUpdate,
|
||
* pfnContinue, dwContinue)
|
||
*
|
||
* @mfunc Draws the text services object
|
||
*
|
||
* @rdesc HRESULT (typically S_OK).
|
||
*
|
||
* @comm
|
||
*
|
||
* This method renders the Text Services. It accepts the same parameters
|
||
* as the corresponding IViewObject::Draw method in OLE, with the extra
|
||
* <p lprcUpdate > parameter. It can be used while the host is inactive
|
||
* or active (in-place).
|
||
*
|
||
* If dwDrawAspect is DVASPECT_CONTENT, this method should render a screen
|
||
* image of the text content to the hdcDraw device context. The hicTargetDev
|
||
* and ptd parameters give information on the target device context if any
|
||
* (usually a printer).
|
||
*
|
||
* The lprcClient parameter gives the rectangle to render to, also called
|
||
* "client rectangle". This rectangle represents the position and extents
|
||
* of the entire image of the Text Services to be drawn. It is expressed in
|
||
* the logical coordinate system of hdcDraw. This parameter can only be NULL
|
||
* if the control is active. In that case, Text Services should render the
|
||
* in-place active view (which client rectangle can be obtained by calling
|
||
* TxGetClientRect on the host).
|
||
*
|
||
* The lprcUpdate parameter, if not NULL, gives the rectangle to update
|
||
* inside that client rectangle. It is given in the logical coordinate system
|
||
* of hdcDraw. If NULL, the entire client rectangle should be painted.
|
||
*
|
||
* Text Services should render with the appropriate zooming factor, which
|
||
* can be obtained from the client rect and the native size given by
|
||
* ITextHost::TxGetExtent. For more information, see ITextHost::TxGetExtent.
|
||
*
|
||
* If the drawing aspect is DVASPECT_DOCPRINT, the TxDraw method can assume
|
||
* that it is rendering to the printer. In that case, hdcDraw is the printer
|
||
* device context. TxDraw should still render the lprcBounds rectangle,
|
||
* starting at the current scrolling position. TS can make optimization for
|
||
* rendering to the printer (like not painting the background color if white)
|
||
* and certain screen specific elements (such as the selection) should not be
|
||
* rendered.
|
||
*
|
||
* General comments on OLE hosts and TxDraw (and TxSetCursor, TxQueryHitPoint):
|
||
*
|
||
* OLE hosts can call the TxDraw method at any time with any rendering DC or
|
||
* client rectangle. All an inactive OLE object has on a permanent basis is
|
||
* a himetric extent. It gets the rectangle in which to render only via the
|
||
* IViewObject::Draw call and this rectangle is valid only for the scope of
|
||
* that method. In fact, the same control can be rendered consecutively in
|
||
* different rectangles and different DCs for example because it is displayed
|
||
* simultaneously in different views on the screen.
|
||
*
|
||
* The client rectangle and DC passed to TxDraw should normally not be cached.
|
||
* However, this would force Text Services to recalc lines for every single
|
||
* draw, which would lead to terrible performance. So it is likely that Text
|
||
* Services will actually cache some information computed for a specific
|
||
* client rectangle and DC (such as the line breaks for example). On the
|
||
* next call to TxDraw, however, the validity of the cached information
|
||
* should be checked before it gets used, and updated information should be
|
||
* regenerated if necessary.
|
||
*
|
||
* When the control is in-place active, the problem is even more complex
|
||
* since TxDraw can still be called to render other views than the in-place
|
||
* active one. In other words, the client rectangle passed to TxDraw may
|
||
* not be the same as the active view one (passed to OnTxInPlaceActivate
|
||
* and obtained via TxGetClientRect on the host).The the host specifies
|
||
* what view they wish to display based on the lViewId parameter. If the
|
||
* value for lViewId is TXTVIEW_ACTIVE, the view referred to is the inplace
|
||
* active view. TXTVIEW_INACTIVE means some other view such as a print
|
||
* preview or even printing itself. It is important to note that
|
||
* TXTVIEW_INACTIVE views may not have scroll bars.
|
||
*
|
||
* The same comments apply to TxSetCursor and TxQueryHitPoint, discussed
|
||
* in the following sections.
|
||
*/
|
||
HRESULT CTxtEdit::TxDraw(
|
||
DWORD dwDrawAspect, //@parm Draw aspect
|
||
LONG lindex, //@parm Currently unused
|
||
void * pvAspect, //@parm Info for drawing optimizations (OCX 96)
|
||
DVTARGETDEVICE *ptd, //@parm Info on target device
|
||
HDC hdcDraw, //@parm Rendering device context
|
||
HDC hicTargetDev, //@parm Target information context
|
||
LPCRECTL lprcBounds, //@parm Bounding (client) rectangle
|
||
LPCRECTL lprcWBounds, //@parm Clipping rect for metafiles
|
||
LPRECT lprcUpdate, //@parm Dirty rectangle inside lprcBounds
|
||
BOOL (CALLBACK * pfnContinue) (DWORD), //@parm Callback for interupting
|
||
// long display (currently unused)
|
||
DWORD dwContinue, //@parm Parameter to pass to pfnContinue function
|
||
LONG lViewId) //@parm View identifier
|
||
{
|
||
TRACEBEGIN(TRCSUBSYSTS, TRCSCOPEEXTERN, "CTxtEdit::TxDraw");
|
||
|
||
HRESULT hr;
|
||
|
||
// JMO : FUTURE : We should do something about reentrant draws sometime.
|
||
// If we do that may procide a simpler fix for RAID bug 7212.
|
||
|
||
#if !defined(NOMAGELLAN)
|
||
CMagellanBMPStateWrap bmpOff(*this, hdcDraw);
|
||
#endif
|
||
|
||
CCallMgr callmgr(this);
|
||
|
||
START_PROFILING
|
||
|
||
{
|
||
CLock lock;
|
||
if (g_OLSBusy)
|
||
return E_UNEXPECTED;
|
||
}
|
||
|
||
// If the display is frozen, don't let ourselves draw. This is a pretty
|
||
// hoaky re-entrancy check.
|
||
// FUTURE (alexgo/ricksa): be better about this.
|
||
if(TXTVIEW_ACTIVE == lViewId && _pdp->IsFrozen())
|
||
{
|
||
_pdp->SetNeedRedisplayOnThaw(TRUE);
|
||
TRACEINFOSZ("Forcing a redisplay on thaw");
|
||
return E_UNEXPECTED;
|
||
}
|
||
|
||
if(dwDrawAspect != DVASPECT_CONTENT && dwDrawAspect != DVASPECT_DOCPRINT)
|
||
{
|
||
// We don't support the aspect requested
|
||
return DV_E_DVASPECT;
|
||
}
|
||
|
||
if(!lprcBounds && !_fInPlaceActive || hicTargetDev && !ptd)
|
||
{
|
||
// If we are not inplace active we must have a client rectangle
|
||
return E_INVALIDARG;
|
||
}
|
||
|
||
HDC hicLocal = NULL;
|
||
|
||
// Did they give us a ptd without a hic?
|
||
if(!hicTargetDev && ptd)
|
||
{
|
||
// Create and information context for the device information
|
||
// since it wasn't supplied.
|
||
hicLocal = CreateIC(
|
||
(TCHAR *)((BYTE *) ptd + ptd->tdDriverNameOffset),
|
||
(TCHAR *)((BYTE *) ptd + ptd->tdDeviceNameOffset),
|
||
(TCHAR *)((BYTE *) ptd + ptd->tdPortNameOffset),
|
||
(DEVMODE *)((BYTE *) ptd + ptd->tdExtDevmodeOffset));
|
||
if(!hicLocal)
|
||
return E_FAIL; // Couldn't create it
|
||
|
||
hicTargetDev = hicLocal;
|
||
}
|
||
|
||
AssertSz(GetMapMode(hdcDraw) == MM_TEXT || GetDeviceCaps(hdcDraw, TECHNOLOGY) == DT_METAFILE,
|
||
"RichEdit requires MM_TEXT."); // REVIEW (keithcu) Clients do (and should) use MM_TEXT
|
||
|
||
// Preallocate the memory so the set cannnot fail and we don't
|
||
// have to use the heap. Note that all clean up is handled
|
||
// outside of this object. Also note that we don't assign any
|
||
// information here because we may not use this structure. If
|
||
// recursion is happening we will use the top level structure.
|
||
CDrawInfo di(this);
|
||
|
||
_pdp->SetDrawInfo(
|
||
&di,
|
||
dwDrawAspect,
|
||
lindex,
|
||
pvAspect,
|
||
ptd,
|
||
hicTargetDev);
|
||
|
||
// We use our main display object if we are the active view (which is
|
||
// indicate by the supplied client rectangle) or if the object is
|
||
// inactive and the ptd is NULL. We assume that the ptd being NULL means
|
||
// that the display request is for the screen and not for a print or
|
||
// print preview.
|
||
if(TXTVIEW_ACTIVE == lViewId || !ptd)
|
||
{
|
||
hr = S_FALSE;
|
||
|
||
// The main display object draws active views and tries to draw
|
||
// inactive views if the control is not active.
|
||
if (!lprcWBounds &&
|
||
( fInplaceActive() && TXTVIEW_ACTIVE == lViewId ||
|
||
!fInplaceActive() && TXTVIEW_INACTIVE == lViewId))
|
||
{
|
||
hr = _pdp->Draw(hdcDraw, hicTargetDev, // We aren't interruptable
|
||
(RECT *)lprcBounds, // drawing to screen, so
|
||
(RECT *)lprcWBounds, // why pretend?
|
||
lprcUpdate, NULL, 0);
|
||
}
|
||
|
||
if(S_FALSE == hr)
|
||
{
|
||
// This is an inactive view for which the cached state
|
||
// does not match the input request so we make a special
|
||
// object to do the drawing.
|
||
CDisplay *pdp = _pdp->Clone();
|
||
if(pdp)
|
||
{
|
||
// Force recalc - this tells Draw to draw no matter what
|
||
pdp->InvalidateRecalc();
|
||
hr = pdp->Draw(hdcDraw, hicTargetDev, // Do the draw
|
||
(RECT *)lprcBounds,
|
||
(RECT *)lprcWBounds,
|
||
lprcUpdate, NULL, 0);
|
||
}
|
||
delete pdp;
|
||
}
|
||
}
|
||
else
|
||
{
|
||
// Make a copy so that we can update it
|
||
RECT rcForPrint = *((RECT *)lprcBounds);
|
||
|
||
// We want data both formatted and printed
|
||
hr = FormatAndPrint(hdcDraw, hicTargetDev, ptd, &rcForPrint,
|
||
(RECT*)lprcWBounds);
|
||
|
||
struct SPrintControl prtcon;
|
||
|
||
// This call to OnFormatRange simply cleans up printer object
|
||
OnFormatRange(NULL, prtcon);
|
||
}
|
||
|
||
_pdp->ReleaseDrawInfo();
|
||
|
||
if(hicLocal) // Clean up information context
|
||
DeleteDC(hicLocal); // if we created one
|
||
|
||
// An active OLE object might have been dragged/scrolled away
|
||
// from where it belongs. We need to put it back.
|
||
// The _cActiveObjPosTries guards us from an indefinite looop here
|
||
// (OnReposition may post another paint message, and so on)
|
||
// We only do this when we were notified of a position or size change
|
||
COleObject* poleobjActive;
|
||
if (HasObjects() && _cActiveObjPosTries &&
|
||
(poleobjActive = GetObjectMgr()->GetInPlaceActiveObject()))
|
||
{
|
||
// Reduce number of tries
|
||
_cActiveObjPosTries--;
|
||
|
||
// BUG FIX 6073
|
||
// Only fetch the extent if the object view size or position
|
||
// has changed
|
||
// Get new object size (we might have resized it,
|
||
// and we don't want to lose that!!)
|
||
if (poleobjActive->GetViewChanged())
|
||
{
|
||
poleobjActive->FetchObjectExtents();
|
||
poleobjActive->ResetViewChanged();
|
||
}
|
||
|
||
// and put it there!!
|
||
poleobjActive->OnReposition();
|
||
}
|
||
|
||
return hr;
|
||
}
|
||
|
||
/*
|
||
* CTxtEdit::TxGetHScroll (plMin, plMax, plPos, plPage, pfEnabled)
|
||
*
|
||
* @mfunc
|
||
* Get horizontal scroll bar state information
|
||
*
|
||
* @rdesc
|
||
* HRESULT = S_OK
|
||
*/
|
||
HRESULT CTxtEdit::TxGetHScroll(
|
||
LONG *plMin, //@parm Minimum scroll position
|
||
LONG *plMax, //@parm Maximum scroll position
|
||
LONG *plPos, //@parm Current scroll position
|
||
LONG *plPage, //@parm View width in pixels
|
||
BOOL *pfEnabled) //@parm Whether horizonatl scrolling is enabled.
|
||
{
|
||
TRACEBEGIN(TRCSUBSYSTS, TRCSCOPEEXTERN, "CTxtEdit::TxGetHScroll");
|
||
|
||
START_PROFILING
|
||
|
||
if(plMin)
|
||
*plMin = 0;
|
||
|
||
if (IsUVerticalTflow(_pdp->GetTflow()))
|
||
{
|
||
if(plMax)
|
||
*plMax = _pdp->GetScrollRange(SB_VERT);
|
||
|
||
if(plPage)
|
||
*plPage = _pdp->ConvertVPosToScrollPos(_pdp->GetDvpView());
|
||
|
||
if(plPos)
|
||
{
|
||
*plPos = _pdp->ConvertVPosToScrollPos(_pdp->GetVpScroll());
|
||
if (_pdp->GetTflow() == tflowSW)
|
||
*plPos = *plMax - *plPos - *plPage;
|
||
*plPos = max(*plPos, 0);
|
||
}
|
||
|
||
if(pfEnabled)
|
||
*pfEnabled = _pdp->IsVScrollEnabled();
|
||
}
|
||
else
|
||
{
|
||
if(plMax)
|
||
*plMax = _pdp->GetScrollRange(SB_HORZ);
|
||
|
||
if(plPos)
|
||
*plPos = _pdp->GetUpScroll();
|
||
|
||
if(plPage)
|
||
*plPage = _pdp->GetDupView();
|
||
|
||
// CDisplay::_fUScrollEnabled may be TRUE when not in-place active
|
||
// because it has a dual meaning: 1) need Horiz scroll bars, and 2)
|
||
// CDisplay::_upScroll is allowed for ES_AUTOHSCROLL even with no
|
||
// horizontal scrollbar. The latter can turn on _fUScrollEnabled when
|
||
// the control is active and when the control goes inactive, it stays
|
||
// on, so we say it's off to keep Forms^3 from displaying a horizontal
|
||
// scroll bar. We probably should have two flags: _fUScrollEnabled and
|
||
// _fUScrollbarEnabled, but for now, we stick with one. No such problem
|
||
// for vertical case, since vertical scrolling always uses a scrollbar.
|
||
if(pfEnabled)
|
||
*pfEnabled = _fInPlaceActive ? _pdp->IsUScrollEnabled() : 0;
|
||
}
|
||
|
||
return S_OK;
|
||
}
|
||
|
||
/*
|
||
* CTxtEdit::TxGetVScroll (plMin, plMax, plPos, plPage, pfEnabled)
|
||
*
|
||
* @mfunc
|
||
* Get vertical scroll bar state information
|
||
*
|
||
* @rdesc
|
||
* HRESULT = S_OK
|
||
*/
|
||
HRESULT CTxtEdit::TxGetVScroll(
|
||
LONG *plMin, //@parm Minimum scroll position
|
||
LONG *plMax, //@parm Maximum scroll position
|
||
LONG *plPos, //@parm Current scroll position
|
||
LONG *plPage, //@parm Height of view in pixels
|
||
BOOL *pfEnabled) //@parm Whether vertical scroll bar is enabled.
|
||
{
|
||
TRACEBEGIN(TRCSUBSYSTS, TRCSCOPEEXTERN, "CTxtEdit::TxGetVScroll");
|
||
|
||
if(plMin)
|
||
*plMin = 0;
|
||
|
||
if (IsUVerticalTflow(_pdp->GetTflow()))
|
||
{
|
||
if(plMax)
|
||
*plMax = _pdp->GetScrollRange(SB_HORZ);
|
||
|
||
if(plPos)
|
||
*plPos = _pdp->GetUpScroll();
|
||
|
||
if(plPage)
|
||
*plPage = _pdp->GetDupView();
|
||
|
||
if(pfEnabled)
|
||
*pfEnabled = _fInPlaceActive ? _pdp->IsUScrollEnabled() : 0;
|
||
}
|
||
else
|
||
{
|
||
if(plMax)
|
||
*plMax = _pdp->GetScrollRange(SB_VERT);
|
||
|
||
if(plPos)
|
||
*plPos = _pdp->ConvertVPosToScrollPos(_pdp->GetVpScroll());
|
||
|
||
if(plPage)
|
||
*plPage = _pdp->ConvertVPosToScrollPos(_pdp->GetDvpView());
|
||
|
||
if(pfEnabled)
|
||
*pfEnabled = _pdp->IsVScrollEnabled();
|
||
}
|
||
|
||
return S_OK;
|
||
}
|
||
|
||
/*
|
||
* CTxtEdit::OnTxSetCursor (dwDrawAspect, lindex, pvAspect, ptd, hdcDraw,
|
||
* hicTargetDev, lprcClient, x, y)
|
||
* @mfunc
|
||
* Notification for text services to set the cursor
|
||
*
|
||
* @rdesc
|
||
* HRESULT = FAILED(RectChangeHelper()) ? E_INVALIDARG : S_OK
|
||
*
|
||
* @comm
|
||
* Text Services may remeasure as a result of this call in
|
||
* order to determine the correct cursor. The correct
|
||
* cursor will be set via ITextHost::TxSetCursor
|
||
*
|
||
* More details:
|
||
*
|
||
* The lprcClient parameter is the client rectangle of the view of the
|
||
* control over which the mouse cursor is. It is in device coordinates
|
||
* of the containing window in the same way the WM_SIZE message is. This
|
||
* may not be the view that was rendered last. Furthermore, if the control
|
||
* is in-place active, this may not be the view currently being active.
|
||
* As a consequence, Text Services should check this rectangle against
|
||
* its current caches values and determine whether recalcing the lines
|
||
* is necessary or not. The zoom factor should be included in this
|
||
* computation.
|
||
*
|
||
* This method should only be called for screen views of the control.
|
||
* Therefore the DC is not passed in but should be assumed to be a screen
|
||
* DC.
|
||
*
|
||
* The x and y parameters hold the cursor position in the same coordinate
|
||
* system as lprcClient, i.e., the client coordinates of the containing
|
||
* window.
|
||
*/
|
||
//REVIEW (keithcu) Do people really pass rectangles different from those
|
||
//returned from TxGetClientRect? I'd be surprised if that happens, and if it did
|
||
//who cares if we display the wrong cursor??
|
||
HRESULT CTxtEdit::OnTxSetCursor (
|
||
DWORD dwDrawAspect, //@parm Draw aspect
|
||
LONG lindex, //@parm Currently unused
|
||
void * pvAspect, //@parm Info for drawing optimizations (OCX 96)
|
||
DVTARGETDEVICE *ptd, //@parm Info on target device
|
||
HDC hdcDraw, //@parm Rendering device context
|
||
HDC hicTargetDev, //@parm Target information context
|
||
LPCRECT lprcClient, //@parm Control's client rectangle
|
||
INT x, //@parm x position of cursor
|
||
INT y) //@parm y position of cursor
|
||
{
|
||
TRACEBEGIN(TRCSUBSYSTS, TRCSCOPEEXTERN, "CTxtEdit::OnTxSetCursor");
|
||
|
||
CCallMgr callmgr(this);
|
||
BOOL fText = FALSE;
|
||
HITTEST Hit;
|
||
RECT rcxyClient;
|
||
BOOL fGotDC = FALSE;
|
||
START_PROFILING
|
||
|
||
if (_fInPlaceActive)
|
||
TxGetClientRect(&rcxyClient);
|
||
else if (lprcClient)
|
||
rcxyClient = *lprcClient;
|
||
else
|
||
return E_INVALIDARG;
|
||
|
||
if (!_pdp->IsValid())
|
||
{
|
||
HDC hdc = GetDC(NULL);
|
||
_pdp->SetDC(hdc);
|
||
fGotDC = TRUE;
|
||
}
|
||
|
||
// Set the cursor
|
||
CTxtSelection * const psel = GetSel();
|
||
HCURSOR hcurNew = _hcurArrow; // Default using system arrow
|
||
POINT ptxy = {x, y};
|
||
POINTUV pt;
|
||
RECTUV rcClient;
|
||
BOOL fInLink = FALSE;
|
||
|
||
_pdp->RectuvFromRect(rcClient, rcxyClient);
|
||
_pdp->PointuvFromPoint(pt, ptxy);
|
||
|
||
if(PtInRect(&rcxyClient, ptxy))
|
||
{
|
||
// Find out what the cursor is pointing at
|
||
_pdp->CpFromPoint(pt, &rcClient, NULL, NULL, FALSE, &Hit);
|
||
|
||
if(Hit == HT_LeftOfText)
|
||
hcurNew = _hcurSelBar;
|
||
|
||
// This is a bit strange, but RichEdit 1.0 does this--give client a
|
||
// chance to handle cursor itself if we are over a link.
|
||
else if(Hit == HT_Link)
|
||
{
|
||
if(HandleLinkNotification(WM_SETCURSOR, 0, MAKELPARAM(ptxy.x, ptxy.y), &fInLink))
|
||
{
|
||
return NOERROR;
|
||
}
|
||
hcurNew = _hcurHand;
|
||
}
|
||
else if(Hit != HT_Nothing && Hit != HT_OutlineSymbol && Hit != HT_BulletArea)
|
||
{
|
||
if(!psel || !psel->PointInSel(pt, &rcClient, Hit) || _fDisableDrag)
|
||
{
|
||
if (IsUVerticalTflow(_pdp->GetTflow()))
|
||
hcurNew = (Hit == HT_Italic) ? _hcurVItalic : _hcurVIBeam;
|
||
else
|
||
hcurNew = (Hit == HT_Italic) ? _hcurItalic : _hcurIBeam;
|
||
fText = TRUE;
|
||
}
|
||
|
||
// If we have an object manager and if there is a selected object,
|
||
// check for hits on the frame handles.
|
||
if(_pobjmgr)
|
||
{
|
||
COleObject *pobjselect = _pobjmgr->GetSingleSelect();
|
||
if(pobjselect)
|
||
{
|
||
// Handle hits on frame handles.
|
||
LPTSTR idcur = pobjselect->CheckForHandleHit(pt);
|
||
HCURSOR hcurObj = W32->GetSizeCursor(idcur);
|
||
if(hcurObj)
|
||
hcurNew = hcurObj;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
_phost->TxSetCursor(hcurNew, fText); // Tell host to set cursor
|
||
|
||
if (fGotDC)
|
||
{
|
||
HDC hdc = _pdp->GetDC();
|
||
::ReleaseDC(NULL, hdc);
|
||
_pdp->SetDC(NULL);
|
||
}
|
||
|
||
return S_OK;
|
||
}
|
||
|
||
/*
|
||
* CTxtEdit::TxQueryHitPoint (dwDrawAspect, lindex, pvAspect, ptd, hdcDraw,
|
||
* hicTargetDev, lprcClient, x, y, pHitResult)
|
||
* @mfunc
|
||
* Returns whether point is within text services rectangle
|
||
*
|
||
* @rdesc
|
||
* HRESULT
|
||
*
|
||
* @comm
|
||
* This method allows the host to implement transparent hit-testing
|
||
* on text.
|
||
*
|
||
* The lprcClient parameter is the client rectangle in device coordinates
|
||
* of the view on which hit testing is performed.
|
||
*
|
||
* The pt parameter hold the position of the cursor in the same
|
||
* coordinate system as the lprcClient rectangle (the client
|
||
* coordinates of the containing window).
|
||
*
|
||
* Same general comments about client rectangle and DC as for
|
||
* TxSetCursor apply.
|
||
*
|
||
* pHitResult returns one of the following values: <nl>
|
||
*
|
||
* TXTHITRESULT_NOHIT Hit was outside client rectangle. <nl>
|
||
* TXTHITRESULT_HIT Point was inside client rectangle and over
|
||
* either text or an opaque background.
|
||
* TXTHITRESULT_TRANSPARENT Point was inside client rectangle with a
|
||
* transparent background and not over text.
|
||
* TXTHITRESULT_CLOSE Hit was close to an opaque area.
|
||
*
|
||
* Refer to the Windowless OLE Control spec for more details on
|
||
* these return values and how they should be determined.
|
||
*/
|
||
HRESULT CTxtEdit::TxQueryHitPoint(
|
||
DWORD dwDrawAspect, //@parm Draw aspect
|
||
LONG lindex, //@parm Currently unused
|
||
void * pvAspect, //@parm Info for drawing optimizations (OCX 96)
|
||
DVTARGETDEVICE *ptd, //@parm Info on target device
|
||
HDC hdcDraw, //@parm Rendering device context
|
||
HDC hicTargetDev, //@parm Target information context
|
||
LPCRECT lprcClient, //@parm Control's client rectangle
|
||
INT x, //@parm x coordinate to check
|
||
INT y, //@parm y coordinate to check
|
||
DWORD * pHitResult) //@parm Result of hit test see TXTHITRESULT
|
||
// enumeration for valid values
|
||
{
|
||
TRACEBEGIN(TRCSUBSYSTS, TRCSCOPEEXTERN, "CTxtEdit::TxQueryHitPoint");
|
||
|
||
RECTUV rcClient;
|
||
RECT rcxyClient;
|
||
CCallMgr callmgr(this);
|
||
|
||
START_PROFILING
|
||
|
||
if (_fInPlaceActive)
|
||
TxGetClientRect(&rcxyClient);
|
||
else if (lprcClient)
|
||
rcxyClient = *lprcClient;
|
||
else
|
||
return E_INVALIDARG;
|
||
|
||
HRESULT hr;
|
||
POINT ptxy = {x, y};
|
||
POINTUV pt;
|
||
|
||
_pdp->PointuvFromPoint(pt, ptxy);
|
||
_pdp->RectuvFromRect(rcClient, rcxyClient);
|
||
|
||
if(!_fTransparent)
|
||
{
|
||
*pHitResult = TXTHITRESULT_HIT;
|
||
hr = S_OK;
|
||
}
|
||
else
|
||
hr = _pdp->TransparentHitTest(hdcDraw, &rcxyClient, pt, pHitResult);
|
||
|
||
return hr;
|
||
}
|
||
|
||
/*
|
||
* CTxtEdit::OnTxInPlaceActivate (prcClient)
|
||
*
|
||
* @mfunc
|
||
* Notifies text services that this control is inplace active
|
||
*
|
||
* @rdesc
|
||
* S_OK - successfully activated object <nl>
|
||
* E_FAIL - could not activate object due to error. <nl>
|
||
*
|
||
* @comm
|
||
* When transitioning directly from a non-active state to the UI-active
|
||
* state, the host should call OnTxInPlaceActivate first and then
|
||
* OnTxUIActivate. Similarly, when transitioning from the UI-active
|
||
* state to a non active state, the host should call OnTxUIDeactivate
|
||
* first and then OnTxInPlaceDeactivate.
|
||
*
|
||
* OnTxInPlaceActivate takes the client rectangle of the view being
|
||
* activated as a parameter. This rectangle is given in client coordinate
|
||
* of the containing window. It is the same as would be obtained by
|
||
* calling TxGetClientRect on the host.
|
||
*
|
||
* UI-activation is different from getting the focus. To let Text
|
||
* Services know that the control is getting or losing focus, the
|
||
* host will send WM_SETFOCUS and WM_KILLFOCUS messages. Note that a
|
||
* windowless host will pass NULL as the wParam (window that lost the
|
||
* focus) for these messages.
|
||
*
|
||
* As a reminder, inplace activation typically refers to an embedded
|
||
* object "running inplace" (for regular controls && embeddings, it
|
||
* would have a window to draw in, for example). UI active means that
|
||
* an object currently has the 'editing focus'. Specifically, things
|
||
* like menus and toolbars on the container may also contain elements
|
||
* from the UI active control/embedding. There can only be one
|
||
* UI active control at any given time, while many can be inplace active
|
||
* at once.
|
||
*/
|
||
HRESULT CTxtEdit::OnTxInPlaceActivate(
|
||
const RECT *prcClient) //@parm Control's client rectangle
|
||
{
|
||
TRACEBEGIN(TRCSUBSYSTS, TRCSCOPEEXTERN, "CTxtEdit::OnTxInPlaceActivate");
|
||
|
||
RECTUV rcView;
|
||
HDC hdc;
|
||
BOOL fSucceeded = TRUE;
|
||
CCallMgr callmgr(this);
|
||
RECTUV rcClient;
|
||
|
||
START_PROFILING
|
||
|
||
// Needs to set here for further TxGetDC() to work
|
||
_fInPlaceActive = TRUE;
|
||
|
||
// Set rendering DC to be the screen
|
||
hdc = TxGetDC();
|
||
if(!hdc)
|
||
goto err;
|
||
|
||
// Tell display that it is active
|
||
_pdp->SetActiveFlag(TRUE);
|
||
_pdp->SetDC(hdc);
|
||
|
||
//REVIEW (keithcu) I removed prcClient usage here because it appears that
|
||
//clients pass in wrong rectangles to OnTxInPlaceActivate. That is quite
|
||
//scary--do they pass in wrong rectangles to other places? (We could see
|
||
//weird results when not in-place active. If (as the comment says) the prcClient
|
||
//should be the same as what would be gotten from the host, we will now just fetch
|
||
//the value from the host rather than look at what is passed down.
|
||
#if 1
|
||
prcClient = 0;
|
||
#else
|
||
|
||
if (prcClient)
|
||
_pdp->RectuvFromRect(rcClient, *prcClient);
|
||
|
||
//Verify the rectangle passed in is the same as what we'd fetch from
|
||
//getting it from the client
|
||
#ifdef DEBUG
|
||
{
|
||
RECT rcDebug;
|
||
TxGetClientRect(&rcDebug);
|
||
AssertSz(rcDebug.right - rcDebug.left == prcClient->right - prcClient->left &&
|
||
rcDebug.bottom - rcDebug.top == prcClient->bottom - prcClient->top,
|
||
"CLIENT BUG: Inconsistent rectangles between ITextServices::"
|
||
"OnTxInPlaceActivate(RECT*) and ITextHost::TxGetClientRect(RECT*)");
|
||
}
|
||
#endif
|
||
#endif
|
||
|
||
// Compute view rect from passed in client rect
|
||
_pdp->GetViewRect(rcView, prcClient ? &rcClient : 0);
|
||
|
||
// Recalc/update view
|
||
_pdp->RecalcView(rcView);
|
||
|
||
// Get selection. Otherwise, if SetFocus is called later without
|
||
// selection, then the Selection state is not set correctly.
|
||
GetSel();
|
||
if(_pdp->GetDupView())
|
||
{
|
||
// Get selection if we can
|
||
if(_psel) // Set the caret
|
||
_psel->Update(FALSE);
|
||
else // Couldn't create selection,
|
||
fSucceeded = FALSE; // so fail activation
|
||
}
|
||
|
||
// Release the DC
|
||
TxReleaseDC(hdc);
|
||
_pdp->SetDC(NULL);
|
||
|
||
// If getting the selection worked we are home free
|
||
if(fSucceeded)
|
||
return S_OK;
|
||
|
||
err:
|
||
_fInPlaceActive = FALSE;
|
||
return E_FAIL;
|
||
}
|
||
|
||
/*
|
||
* CTxtEdit::OnTxInPlaceDeactivate()
|
||
*
|
||
* @mfunc Notifies text services that this is no longer in place active.
|
||
*
|
||
* @rdesc S_OK
|
||
*
|
||
* @comm See OnTxInPlaceActivate for a detailed description of
|
||
* activation/deactivation.
|
||
*
|
||
* @xref <mf CTxtEdit::OnTxInPlaceActivate>
|
||
*
|
||
*/
|
||
HRESULT CTxtEdit::OnTxInPlaceDeactivate()
|
||
{
|
||
TRACEBEGIN(TRCSUBSYSTS, TRCSCOPEEXTERN, "CTxtEdit::OnTxInPlaceDeactivate");
|
||
|
||
START_PROFILING
|
||
|
||
// Get properties that affect whether we will discard the selection
|
||
DWORD dwBits;
|
||
|
||
// Tell display that it is not longer active
|
||
_pdp->SetActiveFlag(FALSE);
|
||
|
||
// Because we are inactive, this will tell any background recalc going
|
||
// on to stop.
|
||
_pdp->StepBackgroundRecalc();
|
||
|
||
_phost->TxGetPropertyBits(TXTBIT_HIDESELECTION | TXTBIT_SAVESELECTION,
|
||
&dwBits);
|
||
|
||
// If we don't want to save the selection and we want to hide it while
|
||
// inactive, then we discard our selection
|
||
if(!(dwBits & TXTBIT_SAVESELECTION) && (dwBits & TXTBIT_HIDESELECTION))
|
||
DiscardSelection();
|
||
|
||
_fInPlaceActive = FALSE;
|
||
return S_OK;
|
||
}
|
||
|
||
/*
|
||
* CTxtEdit::OnTxUIActivate()
|
||
*
|
||
* @mfunc Informs text services that the control is now UI active.
|
||
*
|
||
* @rdesc S_OK
|
||
*
|
||
* @comm See OnTxInPlaceActivate for a detailed description of
|
||
* activation/deactivation.
|
||
*
|
||
* @xref <mf CTxtEdit::OnTxInPlaceActivate>
|
||
*
|
||
*
|
||
*/
|
||
HRESULT CTxtEdit::OnTxUIActivate()
|
||
{
|
||
TRACEBEGIN(TRCSUBSYSTS, TRCSCOPEEXTERN, "CTxtEdit::OnTxUIActivate");
|
||
|
||
return S_OK;
|
||
}
|
||
|
||
/*
|
||
* CTxtEdit::OnTxUIDeactivate()
|
||
*
|
||
* @mfunc Informs text services that the control is now UI deactive.
|
||
*
|
||
* @rdesc S_OK
|
||
*
|
||
* @comm See OnTxInPlaceActivate for a detailed description of
|
||
* activation/deactivation.
|
||
*
|
||
* @xref <mf CTxtEdit::OnTxInPlaceActivate>
|
||
*
|
||
*/
|
||
HRESULT CTxtEdit::OnTxUIDeactivate()
|
||
{
|
||
TRACEBEGIN(TRCSUBSYSTS, TRCSCOPEEXTERN, "CTxtEdit::OnTxUIDeactivate");
|
||
|
||
return S_OK;
|
||
}
|
||
|
||
/*
|
||
* CTxtEdit::TxGetText (pbstrText)
|
||
*
|
||
* @mfunc Returns all of the UNICODE plain text in the control as an
|
||
* OLE BSTR.
|
||
*
|
||
* @rdesc
|
||
* S_OK - Text successfully returned in the output argument <nl>
|
||
* E_INVALIDARG - invalid BSTR pointer passed in. <nl>
|
||
* E_OUTOFMEMORY - could not allocate memory for copy of the text <nl>
|
||
*
|
||
* @comm The caller takes ownership of the returned BSTR. WM_GETTEXT
|
||
* and TOM ITextRange::GetText are alternate techniques for
|
||
* retrieving plain text data.
|
||
*
|
||
* If there is no text in the control, no BSTR will be allocated
|
||
* and NULL will be returned.
|
||
*
|
||
* The returned text will NOT necessarily be NULL terminated.
|
||
*/
|
||
HRESULT CTxtEdit::TxGetText(
|
||
BSTR *pbstrText ) //@parm where to return an allocated BSTR
|
||
{
|
||
TRACEBEGIN(TRCSUBSYSTS, TRCSCOPEEXTERN, "CTxtEdit::TxGetText");
|
||
|
||
CTxtPtr tp(this, 0);
|
||
CCallMgr callmgr(this);
|
||
|
||
START_PROFILING
|
||
|
||
if(!pbstrText)
|
||
return E_INVALIDARG;
|
||
|
||
const LONG cch = GetTextLength();
|
||
|
||
if(cch <= 0)
|
||
{
|
||
*pbstrText = 0;
|
||
return S_OK;
|
||
}
|
||
*pbstrText = SysAllocStringLen(NULL, cch);
|
||
if(!*pbstrText)
|
||
{
|
||
GetCallMgr()->SetOutOfMemory();
|
||
return E_OUTOFMEMORY;
|
||
}
|
||
|
||
tp.GetText(cch, *pbstrText);
|
||
return S_OK;
|
||
}
|
||
|
||
/*
|
||
* CTxtEdit::TxSetText (pszText)
|
||
*
|
||
* @mfunc Sets all of the text in the control
|
||
*
|
||
* @rdesc
|
||
* S_OK - text was successfully set <nl>
|
||
* E_FAIL - text could not be updated. <nl>
|
||
*
|
||
* @comm
|
||
* This method should be used with care; it essentially re-initializes
|
||
* the text engine with some new data; any previous data and formatting
|
||
* information will be LOST, including undo information.
|
||
*
|
||
* If previous data has been copied to the clipboard, that data will be
|
||
* rendered completely to the clipboard (via OleFlushClipboard) before
|
||
* it is discarded.
|
||
*
|
||
* This method is NOT undo-able.
|
||
*
|
||
* Two alternate approaches to setting text are WM_SETTEXT and TOM
|
||
* ITextRange::SetText.
|
||
*
|
||
* @xref
|
||
* <mf CTxtRange::SetText>
|
||
*/
|
||
HRESULT CTxtEdit::TxSetText(
|
||
LPCTSTR pszText) //@parm String to replace the current text with
|
||
{
|
||
TRACEBEGIN(TRCSUBSYSTS, TRCSCOPEEXTERN, "CTxtEdit::TxSetText");
|
||
|
||
START_PROFILING
|
||
|
||
return SetText(pszText, ST_CHECKPROTECTION, 1200);
|
||
}
|
||
|
||
/*
|
||
* CTxtEdit::TxGetCurTargetX (px)
|
||
*
|
||
* @mfunc
|
||
* Get the target x position of the caret
|
||
*
|
||
* @rdesc
|
||
* HRESULT with possible values:
|
||
*
|
||
* S_OK - x position of the caret returned <nl>
|
||
* E_FAIL - There is no selection <nl>
|
||
* E_INVALIDARG - Input argument is invalid <nl>
|
||
*
|
||
* @comm
|
||
* This method is useful for implementing up-down cursoring
|
||
* through a conceptual vertical line. To illustrate this feature,
|
||
* consider setting the insertion point at, say, column 20 in a
|
||
* text editor. Now cursor up and down--notice that wherever possible,
|
||
* the editor tries to put the insertion point as close to column 20
|
||
* as it can for the current line. Column 20 is thus the "target" column
|
||
* for the insertion point.
|
||
*
|
||
* Users would like to have this same capability when cursoring through
|
||
* Forms; however, as other controls don't necessarily share the same
|
||
* notion of column position, the target caret position is expressed simply
|
||
* as an x-coordinate on the display (in *client* coordinates).
|
||
*/
|
||
HRESULT CTxtEdit::TxGetCurTargetX(
|
||
LONG *px) //@parm the x location in client coordinates
|
||
{
|
||
TRACEBEGIN(TRCSUBSYSTS, TRCSCOPEEXTERN, "CTxtEdit::TxGetCurTargetX");
|
||
|
||
START_PROFILING
|
||
CTxtSelection *psel = GetSel();
|
||
|
||
if(!psel)
|
||
return E_FAIL;
|
||
|
||
if(!px)
|
||
return E_INVALIDARG;
|
||
|
||
*px = psel->GetUpCaretReally();
|
||
return S_OK;
|
||
}
|
||
|
||
/*
|
||
* CTxtEdit::TxGetBaseLinePos(pBaseLinePos)
|
||
*
|
||
* @mfunc Get the base line position of the first visible line, in pixels,
|
||
* relative the TS client rectangle. Needed for aligning controls on their
|
||
* baselines.
|
||
*
|
||
* @rdesc HRESULT = E_NOTIMPL
|
||
*/
|
||
HRESULT CTxtEdit::TxGetBaseLinePos(
|
||
LONG *pBaseLinePos) //@parm Where to return baseline position
|
||
{
|
||
TRACEBEGIN(TRCSUBSYSTS, TRCSCOPEEXTERN, "CTxtEdit::TxGetBaseLinePos");
|
||
|
||
return E_NOTIMPL;
|
||
}
|
||
|
||
/*
|
||
* CTxtEdit::TxGetNaturalSize (dwAspect, hdcDraw, hicTargetDev, ptd, dwMode,
|
||
* psizelExtent, pwidth, pheight)
|
||
*
|
||
* @mfunc Allow control to be resized so it fits content appropriately
|
||
*
|
||
* @rdesc S_OK <nl>
|
||
* E_INVALIDARG <nl>
|
||
* E_FAIL Unable to determine correct size <nl>
|
||
* E_OUTOFMEMORY <nl>
|
||
*
|
||
* @comm
|
||
*
|
||
* The first 4 parameters are similar to equivalent parameters in
|
||
* TxDraw and give the same information. In the case TS needs to
|
||
* recalc lines, it should use these values the same ways as in
|
||
* TxDraw.
|
||
*
|
||
* <p pWidth> and <p pHeight> are IN/OUT parameters. The host passes the
|
||
* "tentative" width and height of the client rectangle for the text object
|
||
* and Text Services will compare these values against its current cached
|
||
* state, and if different should recalc lines. Then it will compute
|
||
* and return the natural size. As spec-ed currently, the host can ask for 2
|
||
* different kinds of natural sizes:
|
||
*
|
||
* TXTNS_FITTOCONTENT: the entire text should be formatted to the
|
||
* width that is passed in.Then Text Services return the height of
|
||
* the entire text and the width of the widest line. Note that this
|
||
* option ignores any paragraph formatting such as centering and
|
||
* only returns the raw size for the text.
|
||
*
|
||
* TXTNS_ROUNDTOLINE: returns the integral height of the number of lines that
|
||
* will fit in the input height rounded to the next full line boundary.
|
||
*
|
||
* Note that passed and returned width and height correspond to
|
||
* the *client* rectangle in client units.
|
||
*
|
||
*
|
||
* BACKGROUND
|
||
* Here is a quick description of the features mentioned above:
|
||
*
|
||
* FITTOCONTEXT: Normally happens when the user double clicks one
|
||
* of the control grab handles. Sizes the control to the "optimal"
|
||
* size to fit the entire content. Should accomodate the height of
|
||
* the entire text and the width of the widest line.
|
||
*
|
||
* ROUNDTOLINE (Integral height): if this property is set, when the
|
||
* user resizes the control, it snaps to heights that allow an
|
||
* integral number of lines to be displayed (no line will be clipped).
|
||
*/
|
||
HRESULT CTxtEdit::TxGetNaturalSize(
|
||
DWORD dwAspect, //@parm Aspect for drawing. Values taken from OLE's
|
||
// DVASPECT enumeration
|
||
HDC hdcDraw, //@parm DC into which drawing would occur
|
||
HDC hicTargetDev, //@parm DC for which text should be formatted, i.e.,
|
||
// for WYSIWYG
|
||
DVTARGETDEVICE *ptd,//@parm More info on the target device
|
||
DWORD dwMode, //@parm Type of fitting requested. Either
|
||
// TXTNS_FITTOCONTENT or TXTNS_ROUNDTOLINE
|
||
const SIZEL *psizelExtent,//@parm Size of extent to use for zooming
|
||
LONG * pwidth, //@parm Width for such a fitting [in,out]
|
||
LONG * pheight) //@parm Height for such a fitting [in,out]
|
||
{
|
||
TRACEBEGIN(TRCSUBSYSTS, TRCSCOPEEXTERN, "CTxtEdit::TxGetNaturalSize");
|
||
|
||
HRESULT hr;
|
||
CCallMgr callmgr(this);
|
||
|
||
START_PROFILING
|
||
|
||
if(dwAspect != DVASPECT_CONTENT && dwAspect != DVASPECT_DOCPRINT)
|
||
{
|
||
// We don't support the aspect requested
|
||
return DV_E_DVASPECT;
|
||
}
|
||
|
||
if (hicTargetDev && !ptd || !pwidth || !pheight ||
|
||
!IN_RANGE(TXTNS_FITTOCONTENT2, dwMode, TXTNS_ROUNDTOLINE))
|
||
{
|
||
// Either and information context is provided without the device
|
||
// target or the mode is not valid or the width was not provided
|
||
// or the height was not provided. In short, the input parameters
|
||
// are not valid so tell the caller.
|
||
return E_INVALIDARG;
|
||
}
|
||
|
||
if(!psizelExtent->cy)
|
||
{
|
||
// No extent for control, so just return 0
|
||
*pwidth = 0;
|
||
*pheight = 0;
|
||
return S_OK;
|
||
}
|
||
|
||
HDC hicLocal = NULL;
|
||
|
||
// Did they give us a ptd without a hic?
|
||
if(!hicTargetDev && ptd)
|
||
{
|
||
// Create and information context for the device information
|
||
// since it wasn't supplied.
|
||
hicLocal = CreateIC(
|
||
(TCHAR *)((BYTE *) ptd + ptd->tdDriverNameOffset),
|
||
(TCHAR *)((BYTE *) ptd + ptd->tdDeviceNameOffset),
|
||
(TCHAR *)((BYTE *) ptd + ptd->tdPortNameOffset),
|
||
(DEVMODE *)((BYTE *) ptd + ptd->tdExtDevmodeOffset));
|
||
|
||
if(!hicLocal)
|
||
return E_FAIL; // Couldn't create it
|
||
|
||
hicTargetDev = hicLocal;
|
||
}
|
||
|
||
// Convenient place to put height & width for converting them to
|
||
// device units.
|
||
POINT pt;
|
||
pt.x = *pwidth;
|
||
pt.y = *pheight;
|
||
|
||
AssertSz(GetMapMode(hdcDraw) == MM_TEXT || GetDeviceCaps(hdcDraw, TECHNOLOGY) == DT_METAFILE,
|
||
"RichEdit requires MM_TEXT."); // REVIEW (keithcu) Clients do (and should) use MM_TEXT
|
||
|
||
// Set the extent information needed for zooming
|
||
_pdp->SetTempZoomDenominator(psizelExtent->cy);
|
||
|
||
if(TXTNS_ROUNDTOLINE == dwMode)
|
||
{
|
||
// Round to fit simply calculates the
|
||
hr = _pdp->RoundToLine(hdcDraw, pt.x, &pt.y);
|
||
}
|
||
else
|
||
{
|
||
// Get natural size for entire presentation
|
||
// Allocate memory for the draw information
|
||
CDrawInfo di(this);
|
||
|
||
// Set up the drawing parameters
|
||
_pdp->SetDrawInfo(
|
||
&di,
|
||
dwAspect,
|
||
-1,
|
||
NULL,
|
||
ptd,
|
||
hicTargetDev);
|
||
|
||
// Set the Draw DC
|
||
_pdp->SetDC(hdcDraw);
|
||
|
||
// Tell display to figure size needed for this display
|
||
hr = _pdp->GetNaturalSize(hdcDraw, hicTargetDev, dwMode, &pt.x, &pt.y);
|
||
|
||
_pdp->ResetDC(); // Restore state
|
||
_pdp->ReleaseDrawInfo();
|
||
}
|
||
|
||
if(SUCCEEDED(hr)) // Set return values if this worked
|
||
{
|
||
*pwidth = pt.x; // Update return values
|
||
*pheight = pt.y;
|
||
}
|
||
|
||
if(hicLocal) // Clean up info context
|
||
DeleteDC(hicLocal); // if we created one
|
||
|
||
_pdp->ResetTempZoomDenominator(); // Reset temporary zoom factor
|
||
|
||
return hr;
|
||
}
|
||
|
||
/*
|
||
* CTxtEdit::TxGetDropTarget (ppDropTarget)
|
||
*
|
||
* @mfunc Get the drop target for the text control
|
||
*
|
||
* @rdesc
|
||
* S_OK - Got drop target successfully <nl>
|
||
* E_OUTOFMEMORY - Could not create drop target <nl>
|
||
*
|
||
* @comm
|
||
* The caller (host) is responsible for calling Register/Revoke
|
||
* DragDrop and for calling IUnknown::Release on the returned
|
||
* drop target when done.
|
||
*/
|
||
HRESULT CTxtEdit::TxGetDropTarget(
|
||
IDropTarget **ppDropTarget) //@parm Where to put pointer to drop target
|
||
{
|
||
#ifndef NODRAGDROP
|
||
TRACEBEGIN(TRCSUBSYSTS, TRCSCOPEEXTERN, "CTxtEdit::TxGetDropTarget");
|
||
|
||
HRESULT hr;
|
||
CCallMgr callmgr(this);
|
||
|
||
START_PROFILING
|
||
|
||
hr = _ldte.GetDropTarget(ppDropTarget);
|
||
if(hr == NOERROR)
|
||
(*ppDropTarget)->AddRef();
|
||
return hr;
|
||
#else
|
||
return 0;
|
||
#endif
|
||
}
|
||
|
||
/*
|
||
* CTxtEdit::OnTxPropertyBitsChange (dwMask, dwBits)
|
||
*
|
||
* @mfunc Set properties that can be represented by bits.
|
||
*
|
||
* @rdesc HRESULT
|
||
*
|
||
* @comm The following property bits are understood: <nl>
|
||
*
|
||
* TXTBIT_RICHTEXT <nl>
|
||
* TXTBIT_MULTILINE <nl>
|
||
* TXTBIT_READONLY <nl>
|
||
* TXTBIT_SHOWACCELERATOR <nl>
|
||
* TXTBIT_USEPASSWORD <nl>
|
||
* TXTBIT_HIDESELECTION <nl>
|
||
* TXTBIT_SAVESELECTION <nl>
|
||
* TXTBIT_AUTOWORDSEL <nl>
|
||
* TXTBIT_AUTOSIZE <nl>
|
||
* TXTBIT_VERTICAL <nl>
|
||
* TXTBIT_SELECTIONBAR <nl>
|
||
* TXTBIT_WORDWRAP <nl>
|
||
*
|
||
* TXTBIT_CLIENTRECTCHANGE <nl>
|
||
* TXTBIT_VIEWINSETCHANGE <nl>
|
||
* TXTBIT_BACKSTYLECHANGE <nl>
|
||
* TXTBIT_MAXLENGTHCHANGE <nl>
|
||
* TXTBIT_SCROLLBARCHANGE <nl>
|
||
* TXTBIT_CHARFORMATCHANGE <nl>
|
||
* TXTBIT_PARAFORMATCHANGE <nl>
|
||
* TXTBIT_ALLOWBEEP <nl>
|
||
* TXTBIT_EXTENTCHANGE <nl>
|
||
*
|
||
* A brief description of each property follows:
|
||
*
|
||
*
|
||
* Client rectangle (TXTBIT_CLIENTRECTCHANGE):
|
||
*
|
||
* The rectangle the Text Services are responsible for painting
|
||
* and managing. The host will rely on the Text Services for painting
|
||
* that area. Text Services must not paint or invalidate areas outside of
|
||
* that rectangle.
|
||
*
|
||
* The host will forward mouse messages to the Text Services whenever the
|
||
* cursor is over this rectangle.
|
||
*
|
||
* This rectangle is expressed in client coordinates of the containing window.
|
||
*
|
||
* IMPORTANT: this property cannot be queried from the host when it is
|
||
* inactive. The TxGetClientRect method will fail if called at inactive time.
|
||
*
|
||
*
|
||
* View inset (TXTBIT_VIEWINSETCHANGE):
|
||
*
|
||
* This is the amount of space on each side between the client rectangle and
|
||
* the view rectangle. The view rectangle (also called Formating rectangle)
|
||
* is the rectangle the text should be formatted in.
|
||
*
|
||
* The view insets are is passed in a RECT structure but this is not really
|
||
* a rectangle. It should be treated as 4 independent values to substract
|
||
* on each side of the client rectangle to figure the view rectangle.
|
||
*
|
||
* The view insets are passed in himetrics so that they do not depend on
|
||
* the client rectangle and the rendering DC.
|
||
*
|
||
* View insets can be negative on either side of the client rectangle,
|
||
* leading to a bigger view rectangle than the client rectangle. The text
|
||
* should then be clipped to the client rectangle. If the view rectangle
|
||
* is wider than the client rectangle, then the host may add a horizontal
|
||
* scrollbar to the control.
|
||
*
|
||
* Single line Text Services ignore the right boundary of the view rectangle
|
||
* when formatting text.
|
||
*
|
||
* The view inset is available from the host at all times, active or
|
||
* inactive.
|
||
*
|
||
*
|
||
* Backstyle (TXTBIT_BACKSTYLECHANGE):
|
||
*
|
||
* The style of the background of the client rectangle. Can be either of
|
||
* the following values: <nl>
|
||
* #define TXTBACK_TRANSPARENT 0 <nl>
|
||
* #define TXTBACK_SOLID 1 <nl>
|
||
*
|
||
* Values for this property are similar to VB4 values for the same property.
|
||
*
|
||
*
|
||
* MaxLength (TXTBIT_MAXLENGTHCHANGE):
|
||
*
|
||
* The maximum length the text can have. Text Services should reject
|
||
* character insertion and pasted text when this maximum is reached.
|
||
* TxSetText however should still accept (and set) text longer than the
|
||
* maximum length. This is because this method is used for binding and
|
||
* it is critical to maintain the integrity of the data the control
|
||
* is bound to.
|
||
*
|
||
*
|
||
* Scrollbar (TXTBIT_SCROLLBARCHANGE):
|
||
*
|
||
* This property indicates which scollbar is present and whether scollbars
|
||
* are hidden or disabled when scrolling is impossible. It also controls
|
||
* auto-scrolling when the insertion point gets off the client rectangle.
|
||
*
|
||
* This is a DWORD where bits are layed out as in the system window style.
|
||
* Possible bits are:
|
||
* WS_HSCROLL // control has horizontal scrollbar <nl>
|
||
* WS_VSCROLL // control has vertical scrollbar <nl>
|
||
* ES_AUTOVSCROLL // auto-scroll horizontally <nl>
|
||
* ES_AUTOVSCROLL // auto-scroll vertically <nl>
|
||
* ES_DISABLENOSCROLL // scrollbar should be disabled when scrolling
|
||
* impossible <nl>
|
||
*
|
||
* Default CHARFORMAT (TXTBIT_CHARFORMATCHANGE):
|
||
*
|
||
* The CHARFORMAT or CHARFORMAT2 used for default character-format runs,
|
||
* i.e., those not explicitly formatted via the selection or TOM methods.
|
||
|
||
*
|
||
* Default PARAFORMAT (TXTBIT_PARAFORMATCHANGE):
|
||
*
|
||
* The PARAFORMAT or PARAFORMAT2 used for default paragraph-format runs,
|
||
* i.e., those not explicitly formatted via the selection or TOM methods.
|
||
*
|
||
*
|
||
* TXTBIT_ALLOWBEEP:
|
||
*
|
||
* TXTBIT_EXTENTCHANGE:
|
||
*
|
||
*
|
||
* TXTBIT_RICHTEXT:
|
||
*
|
||
* Whether the Text Services should be in Rich-Text mode or not. This
|
||
* principally affects how editing commands are applied. For example,
|
||
* applying bold to some text in a plain edit control makes all of the
|
||
* text bold, rather than just the selected text in a rich text control.
|
||
*
|
||
* Note that if there is either undo state or the object has any text,
|
||
* the attempt to change this bit will be ignored.
|
||
*
|
||
*
|
||
* TXTBIT_MULTILINE:
|
||
*
|
||
* If this property is FALSE, Text Services should not process the CR
|
||
* key and truncate any incoming text containing hard line breaks just
|
||
* before the first line break. It is OK to also truncate text set via
|
||
* TxSetText (meaning, it is the responsibility of the host to not use a s
|
||
* single line control when bound to a multi-line field).
|
||
*
|
||
* If this property is TRUE, Text Services should work in multiline mode.
|
||
* The TXTBIT_WORDWRAP can be used to know whether to wrap the lines to
|
||
* the view rectangle or clip them.
|
||
*
|
||
*
|
||
* TXTBIT_READONLY:
|
||
*
|
||
* If this property is TRUE, Text Services should not accept any editing
|
||
* change via the user interface. However, they should still accept
|
||
* programmatic changes via EM_SETTEXT, EM_REPLACETEXT and TxSetText.
|
||
*
|
||
* In read only mode, the user should still be able to move the
|
||
* insertion point, select text and carry out other non content modifying
|
||
* operations such as Copy.
|
||
*
|
||
*
|
||
* TXTBIT_SHOWACCELERATOR:
|
||
*
|
||
* Refer to the "Accelerator" section for details about this property.
|
||
*
|
||
*
|
||
* TXTBIT_USEPASSWORD:
|
||
*
|
||
* If this property is TRUE, the Text Services should show the entire
|
||
* text using the character obtained by TxGetPasswordChar.
|
||
*
|
||
* The notification on this property may mean two different things:
|
||
* <09> The password character changed,
|
||
* <09> The password character was not used before and is used now
|
||
* (or vice versa).
|
||
*
|
||
*
|
||
* TXTBIT_HIDESELECTION:
|
||
*
|
||
* If this property is TRUE, Text Services should hide the selection
|
||
* when the control is inactive. If it is FALSE, the selection, if any,
|
||
* should still be displayed when the control is inactive.
|
||
*
|
||
* If TRUE, this property implies TXTBIT_SAVESELECTION = TRUE.
|
||
*
|
||
*
|
||
* TXTBIT_SAVESELECTION:
|
||
*
|
||
* If this property is TRUE, Text Services should remember the
|
||
* boundaries of the selection when the control goes inactive. If FALSE,
|
||
* it is not necessary to remember the selection when the control goes
|
||
* inactive. It can be reset to start = 0, length = 0 when the control
|
||
* goes active again.
|
||
*
|
||
* This property is used by hosts for which it is not necessary to
|
||
* remember the selection when inactive.
|
||
*
|
||
*
|
||
* TXTBIT_AUTOWORDSEL:
|
||
*
|
||
* This property turns the AutoWordSelect feature on or off.
|
||
*
|
||
*
|
||
* TXTBIT_AUTOSIZE:
|
||
*
|
||
* This property turns the AutoSize feature on or off. Refer to the
|
||
* "AutoSize" section for more details.
|
||
*
|
||
*
|
||
* TXTBIT_VERTICAL:
|
||
*
|
||
* This property turns on vertical writing. Used for FE support.
|
||
* Details TBD.
|
||
*
|
||
*
|
||
* TXTBIT_WORDWRAP:
|
||
*
|
||
* If this property is TRUE and MultiLine is also TRUE, then Text Services
|
||
* should wrap the line to the view rectangle. If this property is FALSE,
|
||
* the lines should not be wrapped but clipped. The right side of the
|
||
* view rectangle should be ignored.
|
||
*
|
||
* If the MultiLine property is off, this property has no effect.
|
||
*
|
||
*
|
||
* TXTBIT_LINESELECTION:
|
||
*
|
||
* This property turns on or off the Line Selection feature. This feature
|
||
* enable the user to select lines or paragraph by placing the mouse cursor
|
||
* over a "line selection" area on the left of the control. The cursor is
|
||
* displayed as a NE arrow in that area. If the Line Selection feature is
|
||
* off, that area should not be shown.
|
||
*
|
||
*/
|
||
HRESULT CTxtEdit::OnTxPropertyBitsChange(
|
||
DWORD dwMask, //@parm Bits representing properties to be changed
|
||
DWORD dwBits) //@parm New values for bit properties
|
||
{
|
||
TRACEBEGIN(TRCSUBSYSTS, TRCSCOPEEXTERN, "CTxtEdit::OnTxPropertyBitsChange");
|
||
|
||
HRESULT hr = E_FAIL;
|
||
DWORD dwLoopMask = dwMask;
|
||
CCallMgr callmgr(this);
|
||
|
||
START_PROFILING
|
||
|
||
for (int i = 0; (i < MAX_PROPERTY_BITS) && (dwLoopMask != 0);
|
||
i++, dwLoopMask >>= 1)
|
||
{
|
||
if (dwLoopMask & 1)
|
||
{
|
||
hr = (this->*_fnpPropChg[i])((dwBits & (1 << i)) != 0);
|
||
if (FAILED(hr))
|
||
return hr;
|
||
}
|
||
}
|
||
return S_OK;
|
||
}
|
||
|
||
/*
|
||
* CTxtEdit::TxGetCachedSize (pdup, pdvp)
|
||
*
|
||
* @mfunc
|
||
* Returns the cached drawing size (if any) that text services
|
||
* is using. Typically, this will be the size of the last client
|
||
* rect used in TxDraw, TxSetCursor, etc., although it is not
|
||
* guaranteed to be.
|
||
*
|
||
* @rdesc
|
||
* HRESULT
|
||
*
|
||
* @comm
|
||
* This information is provided to allow the host to potentially
|
||
* perform various optimizations, amongst other things.
|
||
*/
|
||
HRESULT CTxtEdit::TxGetCachedSize(
|
||
DWORD *pdupClient, //@parm Where to put width (in client coords)
|
||
DWORD *pdvpClient) //@parm Where to put height (in client coords)
|
||
{
|
||
TRACEBEGIN(TRCSUBSYSTS, TRCSCOPEEXTERN, "CTxtEdit::TxGetCachedSize");
|
||
|
||
return _pdp->GetCachedSize((long*) pdupClient, (long*) pdvpClient);
|
||
}
|
||
|
||
// Forward declaration of initialization helper.
|
||
// These really should be in some header file. But which?
|
||
// Currently the definitions are in dxfrobj.cpp and font.cpp
|
||
void RegisterFETCs();
|
||
void InitFontCache();
|
||
|
||
/*
|
||
* CreateTextServices (punkOuter, phost, ppserv)
|
||
*
|
||
* @func
|
||
* Create an instance of the RichEdit Engine. This engine supports the
|
||
* ITextServices and Microsoft Text Object Model (TOM) interfaces.
|
||
*
|
||
* @rdesc
|
||
* S_OK - New text services instance created successfully. <nl>
|
||
* E_INVALIDARG - An invalid argument was passed in. <nl>
|
||
* E_OUTOFMEMORY - Memory for text services object could not be allocated. <nl>
|
||
* E_FAIL - Text services could not be initialized
|
||
*
|
||
* @comm
|
||
* Text Services may be created as a standard OLE aggregated object.
|
||
* Callers should follow standard OLE32 rules for dealing with
|
||
* aggregated objects and caching interface pointers obtained via
|
||
* QueryInterface from the private IUnknown.
|
||
*/
|
||
STDAPI CreateTextServices(
|
||
IUnknown *punkOuter, //@parm Outer unknown, may be NULL
|
||
ITextHost *phost, //@parm Client's ITextHost implementation; must be
|
||
// valid
|
||
IUnknown **ppUnk) //@parm Private IUnknown of text services engine
|
||
{
|
||
TRACEBEGIN(TRCSUBSYSTS, TRCSCOPEEXTERN, "CreateTextServices");
|
||
|
||
static bool fOnce = FALSE;
|
||
|
||
if (!fOnce) {
|
||
CLock lock;
|
||
fOnce = TRUE;
|
||
W32->InitSysParams();
|
||
W32->InitPreferredFontInfo();
|
||
RegisterFETCs(); // Register new clipboard formats
|
||
CreateFormatCaches(); // Create global format caches
|
||
if ( !InitKinsokuClassify() )
|
||
{
|
||
// Init tables for classifying Unicode chars.
|
||
return E_FAIL;
|
||
}
|
||
InitFontCache();
|
||
}
|
||
|
||
if(!ppUnk)
|
||
return E_INVALIDARG;
|
||
|
||
CTxtEdit *ped = new CTxtEdit((ITextHost2*)phost, punkOuter);
|
||
if(!ped)
|
||
return E_OUTOFMEMORY;
|
||
|
||
if(ped->Init(NULL))
|
||
{
|
||
*ppUnk = ped->GetPrivateIUnknown();
|
||
return S_OK;
|
||
}
|
||
delete ped;
|
||
return E_FAIL;
|
||
}
|