mirror of https://github.com/tongzx/nt5src
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
3597 lines
116 KiB
3597 lines
116 KiB
/*
|
|
* @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-1998, Microsoft Corporation. All rights reserved.
|
|
*/
|
|
|
|
#include "_common.h"
|
|
#include "_edit.h"
|
|
#include "_dispprt.h"
|
|
#include "_dispml.h"
|
|
#include "_dispsl.h"
|
|
#include "_select.h"
|
|
#include "_text.h"
|
|
#include "_runptr.h"
|
|
#include "_font.h"
|
|
#include "_measure.h"
|
|
#include "_render.h"
|
|
#include "_m_undo.h"
|
|
#include "_antievt.h"
|
|
#include "_rtext.h"
|
|
#include "_urlsup.h"
|
|
#include "_magelln.h"
|
|
#include "_ols.h"
|
|
#include "_clasfyc.h"
|
|
|
|
#ifndef OBJID_NATIVEOM
|
|
#define OBJID_NATIVEOM 0xFFFFFFF0
|
|
#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);
|
|
|
|
// 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)
|
|
|
|
|
|
///////////////////////////// Helper Functions ///////////////////////////////////
|
|
/*
|
|
* ConvertDrawDCMapping(hdcDraw)
|
|
*
|
|
* @func
|
|
* Put screen DC in MM_TEXT mapping mode.
|
|
*/
|
|
void ConvertDrawDCMapping(
|
|
HDC hdcDraw) //@parm HDC to draw on
|
|
{
|
|
TRACEBEGIN(TRCSUBSYSTS, TRCSCOPEINTERN, "ConvertDrawDCMapping");
|
|
|
|
SaveDC(hdcDraw);
|
|
SetViewportOrgEx(hdcDraw, 0, 0, NULL);
|
|
SetWindowOrgEx(hdcDraw, 0, 0, NULL);
|
|
SetMapMode(hdcDraw, MM_TEXT);
|
|
}
|
|
|
|
/*
|
|
* 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
|
|
if (!_fCheckAIMM)
|
|
{
|
|
DWORD dwThreadId;
|
|
BOOL fLoadAimm = FALSE;
|
|
|
|
_fCheckAIMM = 1;
|
|
|
|
if (W32->fUseAimm()) // Ini file say use Aimm
|
|
fLoadAimm = TRUE;
|
|
|
|
else if (dwThreadId = GetCurrentThreadId())
|
|
{
|
|
char szBuf[20];
|
|
|
|
sprintf(szBuf, "AIMM:%08x", dwThreadId);
|
|
|
|
if (FindAtomA(szBuf)) // Atom presented, load Aimm
|
|
fLoadAimm = TRUE;
|
|
}
|
|
|
|
if (fLoadAimm)
|
|
{
|
|
HWND hWnd;
|
|
|
|
TxGetWindow( &hWnd );
|
|
|
|
if (hWnd)
|
|
PostMessage(hWnd, EM_SETEDITSTYLE, SES_USEAIMM, SES_USEAIMM);
|
|
}
|
|
}
|
|
|
|
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)) ||
|
|
(wparam & (SES_USEAIMM | SES_NOIME)))
|
|
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:
|
|
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;
|
|
|
|
}
|
|
|
|
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::RectChangeHelper (pdi, dwDrawAspect, lindex, pvAspect, ptd,
|
|
* hdcDraw, hicTargetDev, lprcClient, prcLocal)
|
|
* @func
|
|
* Format and Print data in the control
|
|
*
|
|
* @rdesc
|
|
* S_OK - everything worked
|
|
* E_INVALIDARG - client parameter is invalid
|
|
*
|
|
* @devnote
|
|
* Caller must release the DC from the display object.
|
|
*/
|
|
HRESULT CTxtEdit::RectChangeHelper(
|
|
CDrawInfo *pdi, //@parm Draw information memory
|
|
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
|
|
const RECT ** pprcClient, //@parm New client rectangle
|
|
RECT * prcLocal) //@parm Rect to use if previous parm is NULL
|
|
{
|
|
TRACEBEGIN(TRCSUBSYSTS, TRCSCOPEINTERN, "CTxtEdit::RectChangeHelper");
|
|
|
|
HRESULT hr = S_OK;
|
|
BOOL fRestore = FALSE;
|
|
|
|
// We assume that if client's rectangle is supplied, it has changed.
|
|
if(pprcClient && *pprcClient)
|
|
{
|
|
// Set up information context if necessary
|
|
HDC hicLocal = NULL;
|
|
|
|
// Did they give us a ptd without a hic?
|
|
if(!hicTargetDev && ptd)
|
|
{
|
|
// Create information context for 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;
|
|
}
|
|
|
|
*prcLocal = **pprcClient; // Define *prcLocal in any case
|
|
|
|
// Force DC in MM_TEXT
|
|
if (GetMapMode(hdcDraw) != MM_TEXT &&
|
|
GetDeviceCaps(hdcDraw, TECHNOLOGY) != DT_METAFILE)
|
|
{
|
|
fRestore = TRUE;
|
|
|
|
// Convert input parameters to new mapping
|
|
WinLPtoDP(hdcDraw, (POINT *)prcLocal, 2);
|
|
|
|
*pprcClient = prcLocal;
|
|
|
|
// Convert HDC to new mapping
|
|
ConvertDrawDCMapping(hdcDraw);
|
|
}
|
|
|
|
_pdp->SetDC(hdcDraw); // Set the DC
|
|
_pdp->SetDrawInfo( // Set the draw info
|
|
pdi,
|
|
dwDrawAspect,
|
|
lindex,
|
|
pvAspect,
|
|
ptd,
|
|
hicTargetDev);
|
|
|
|
_pdp->ReDrawOnRectChange(hicTargetDev, *pprcClient);
|
|
|
|
if(fRestore) // Put DC back into correct
|
|
RestoreDC(hdcDraw, -1); // mapping mode
|
|
|
|
if(hicLocal) // Clean up info context if we
|
|
DeleteDC(hicLocal); // created one
|
|
}
|
|
else if (pprcClient && _fInPlaceActive)
|
|
{
|
|
// We can figure out what the client rectangle is.
|
|
TxGetClientRect(prcLocal);
|
|
*pprcClient = prcLocal;
|
|
}
|
|
else // If not inplace active, a RECT
|
|
hr = E_INVALIDARG; // must be supplied
|
|
|
|
return hr;
|
|
}
|
|
|
|
/*
|
|
* CTxtEdit::SetText (pstr, flags, CodePage)
|
|
*
|
|
* @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;
|
|
|
|
// 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
|
|
{
|
|
_dwCharFlags &= 0xFF; // 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
|
|
_dwCharFlags |= 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 seleection 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 the 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.AdvanceCp(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();
|
|
|
|
|
|
LONG lStreamFormat = IsRTF((char *)pstr) ? SF_RTF : 0;
|
|
|
|
if(pstr && (CodePage != 1200 || lStreamFormat))
|
|
{
|
|
LONG cch = strlen((LPSTR)pstr);
|
|
LONG ch = *(LPBYTE)pstr;
|
|
|
|
if(ch < 128 && fSel && cch == 1)
|
|
{
|
|
lres = 1;
|
|
fSetTextMax = FALSE;
|
|
TxSetMaxToMaxText(1);
|
|
_psel->PutChar(ch, 0, publdr);
|
|
}
|
|
else if(cch == 2 && ch == CR && *((LPSTR)pstr + 1) == LF)
|
|
{
|
|
lres = 2;
|
|
fSetTextMax = FALSE;
|
|
TxSetMaxToMaxText(2);
|
|
_psel->InsertEOP(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 = SetCursor(LoadCursor(NULL, IDC_WAIT));
|
|
|
|
if (CodePage <= 0)
|
|
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)
|
|
SetCursor(hcur);
|
|
|
|
if(es.dwError != NOERROR)
|
|
return (HRESULT)es.dwError;
|
|
}
|
|
}
|
|
else
|
|
lres = prg->CleanseAndReplaceRange(-1, pstr, FALSE, publdr, NULL, NULL, RR_ITMZ_UNICODEBIDI);
|
|
|
|
if (_fOutlineView)
|
|
{
|
|
// Outline view must have formatting.
|
|
_psel->Check_rpPF();
|
|
}
|
|
|
|
if(!lres && pstr && (!lStreamFormat && *pstr != '\0' ||
|
|
lStreamFormat && *(char *)pstr != '\0'))
|
|
{
|
|
// There was an input string but for some reason there was no update.
|
|
return E_FAIL;
|
|
}
|
|
|
|
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
|
|
void CreateIMEMessageFilter(ITextMsgFilter **ppNewFilter);
|
|
|
|
/*
|
|
* @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;
|
|
}
|
|
|
|
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;
|
|
CreateIMEMessageFilter(&pNewFilter);
|
|
if (pNewFilter)
|
|
{
|
|
pNewFilter->AttachDocument( hwnd, (ITextDocument2 *) this);
|
|
AttachMsgFilter(pNewFilter);
|
|
goto PassMsg;
|
|
}
|
|
}
|
|
|
|
START_PROFILING
|
|
|
|
IUndoBuilder * publdr;
|
|
CGenUndoBuilder undobldr(this, UB_AUTOCOMMIT, &publdr);
|
|
|
|
#ifdef MACPORTREMOVEIT
|
|
// PowerMac's cannot set breakpoints on a running application and have
|
|
// no way to stop the running appliation.This code allows one to
|
|
// stop the executable when the user holds down the option key and
|
|
// a break point has been set in the indicated spot below. -jOn
|
|
|
|
BOOL fMacBreak = GetAsyncKeyState(VK_OPTION)<0;// Is user holding OPTION?
|
|
|
|
if(fMacBreak) // any old statement will due.
|
|
fMacBreak = TRUE; // Set a break point here for stopping the Mac.
|
|
|
|
#endif // MACPORTREMOVE
|
|
|
|
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_CHAR:
|
|
if(GetKeyboardFlags() & (ALTNUMPAD | HOTEURO))
|
|
{
|
|
if(GetKeyboardFlags() & ALTNUMPAD)
|
|
{
|
|
CW32System::WM_CHAR_INFO wmci;
|
|
wmci._fAccumulate = FALSE;
|
|
W32->AnsiFilter(msg, wparam, lparam, (void *)&wmci);
|
|
}
|
|
else
|
|
{
|
|
// 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((WORD) 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;
|
|
|
|
#ifndef NOMLKEYBOARD
|
|
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))
|
|
{
|
|
// Update our idea of current keyboard layout
|
|
W32->RefreshKeyboardLayout();
|
|
|
|
if(GetKeyboardFlags() & CTRL && GetKeyboardFlags() & SHIFT)
|
|
SetKeyboardFlag(LETAFTERSHIFT);
|
|
|
|
if (GetSel()->CheckChangeFont(
|
|
(HKL)lparam,
|
|
ConvertLanguageIDtoCodePage(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())
|
|
{
|
|
OnDisplayBand((const RECT *) lparam, FALSE);
|
|
lres = 1;
|
|
}
|
|
else
|
|
hr = OLE_E_INVALIDRECT;
|
|
break;
|
|
|
|
#ifndef NODROPFILES
|
|
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())
|
|
{
|
|
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(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)
|
|
{
|
|
if (wparam == 0x065737777) // 'AIMM'
|
|
W32->GetAimmObject((IUnknown **)(lparam));
|
|
else
|
|
{
|
|
*(IRichEditOle **)lparam = (IRichEditOle *)this;
|
|
AddRef();
|
|
}
|
|
}
|
|
lres = TRUE;
|
|
break;
|
|
|
|
case EM_GETSCROLLPOS:
|
|
{
|
|
POINT *point = (POINT *)lparam;
|
|
point->x = _pdp->GetXScroll();
|
|
point->y = _pdp->GetYScroll();
|
|
point->y = _pdp->ConvertYPosToScrollPos(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_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_GETWORDBREAKPROC:
|
|
// Client can only use either WordBreakProc or ExWordBreakProc
|
|
// Return NULL if ExWordBreakProc is being used.
|
|
if (!_fExWordBreakProc)
|
|
lres = OnGetWordBreakProc();
|
|
break;
|
|
|
|
case EM_GETWORDBREAKPROCEX:
|
|
// Return ExWordBreakProc if it is being used.
|
|
if (_fExWordBreakProc)
|
|
lres = OnGetWordBreakProc();
|
|
break;
|
|
|
|
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:
|
|
hr = TxHScroll(LOWORD(wparam), HIWORD(wparam));
|
|
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 control, no strong-context behavior, both a ctrl
|
|
// and a shift key are pressed and no letter has been typed
|
|
// after the Ctrl and Shift keys have been pressed, 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.
|
|
DWORD dwFlags = GetKeyboardFlags();
|
|
|
|
if (IsBiDi() && !IsStrongContext(_nContextDir) &&
|
|
!IsStrongContext(_nContextAlign) &&
|
|
(dwFlags & CTRL) && (dwFlags & SHIFT) &&
|
|
// IsBiDiKbdInstalled() && // Do we want this???
|
|
!(dwFlags & LETAFTERSHIFT))
|
|
{
|
|
CParaFormat PF;
|
|
PF._wEffects = (dwFlags & RSHIFT) ? PFE_RTLPARA : 0;
|
|
|
|
OnSetParaFormat(0, &PF, publdr, PFM_RTLPARA | PFM_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;
|
|
|
|
#ifndef PEGASUS
|
|
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 PEGASUS
|
|
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_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 = TxVScroll((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(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();
|
|
TxInvalidateRect(NULL, FALSE);
|
|
}
|
|
}
|
|
_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), 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_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;
|
|
|
|
|
|
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];
|
|
}
|
|
WORD wNum = GetKeyPadNumber();
|
|
if(!wNum && wparam == VK_NUMPAD0)
|
|
SetKeyboardFlag(ALT0); // Flag that 0 is first digit
|
|
SetKeyPadNumber(10*wNum + 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 (_pundo && !_fReadOnly && _fUseUndo)
|
|
{
|
|
hr = PopAndExecuteAntiEvent(_pundo, (void*)wparam);
|
|
if(hr == NOERROR)
|
|
lres = TRUE;
|
|
}
|
|
break;
|
|
|
|
case EM_REDO:
|
|
if(_predo && !_fReadOnly && _fUseUndo)
|
|
{
|
|
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);
|
|
TxVScroll(LOWORD(wparam), HIWORD(wparam));
|
|
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
|
|
case EM_GETHANDLE: // Not supported by Win95 32-bit MLE either
|
|
case EM_SETHANDLE: // Not supported by Win95 32-bit MLE either
|
|
#ifdef DEBUG
|
|
TRACEINFOSZ("Homey don't play dat");
|
|
#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 documenation 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());
|
|
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 | PFM_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(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_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_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;
|
|
}
|
|
}
|
|
|
|
if(pPF2->cbSize == sizeof(PARAFORMAT))
|
|
{
|
|
dwMask &= PFM_ALL; // Restrict to PARAFORMAT parms
|
|
dwMask |= PFM_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);
|
|
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 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);
|
|
if(msg == EM_STREAMIN)
|
|
{
|
|
// 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(0) == CTxtRange::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;
|
|
}
|
|
|
|
#ifndef PEGASUS
|
|
case WM_SYSCOLORCHANGE:
|
|
TxInvalidateRect(NULL, FALSE);
|
|
break;
|
|
#endif
|
|
|
|
// debug stuff
|
|
#ifdef DEBUG
|
|
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;
|
|
|
|
case EM_GETTHUMB:
|
|
LONG Pos;
|
|
BOOL fIsEnabled;
|
|
|
|
if (TxGetVScroll(NULL, NULL, &Pos, NULL, &fIsEnabled) == S_OK
|
|
&& fIsEnabled)
|
|
{
|
|
lres = Pos;
|
|
}
|
|
break;
|
|
|
|
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
|
|
{
|
|
DWORD dwEditStyle = _bEditStyle & ~lparam; // Kill current flag values
|
|
dwEditStyle |= wparam & lparam; // Or in new values
|
|
|
|
// Certain bits aren't switchable
|
|
dwEditStyle |= ((_fSystemEditMode) ? SES_EMULATESYSEDIT : 0);
|
|
_bEditStyle = (WORD)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(wparam & SES_EMULATESYSEDIT)
|
|
{
|
|
if(SUCCEEDED(HandleSetTextMode(TM_SINGLELEVELUNDO | TM_PLAINTEXT)))
|
|
{
|
|
// SES_EMULATESYSEDIT implies SES_BEEPONMAXTEXT
|
|
_fSystemEditBeep = TRUE;
|
|
}
|
|
else
|
|
_fSystemEditMode = FALSE;
|
|
}
|
|
|
|
if(wparam & SES_BIDI)
|
|
OrCharFlags(fBIDI, 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 |= _bEditStyle; // Some EditStyles have been filled in Cmsgflt
|
|
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.
|
|
|
|
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(!_fRich)
|
|
// hr = lres = E_FAIL;
|
|
|
|
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);
|
|
|
|
if (W32->GetDigitSubstitutionMode() != DIGITS_NOTIMPL)
|
|
OrCharFlags(fDIGITSHAPE, publdr);
|
|
|
|
break;
|
|
|
|
case EM_CONVPOSITION:
|
|
if (wparam)
|
|
lres = GetCpFromAcp(lparam);
|
|
else
|
|
lres = GetAcpFromCp(lparam);
|
|
break;
|
|
|
|
#ifndef NOACCESSIBILITY
|
|
case WM_GETOBJECT:
|
|
// We need to expose the TOM interface for Accessibility by
|
|
// calling LresultFromObject when lparam == OBJID_NATIVEOM
|
|
if (lparam == OBJID_NATIVEOM)
|
|
{
|
|
IUnknown* punk;
|
|
QueryInterface(IID_IUnknown, (void**)&punk);
|
|
Assert(punk);
|
|
lres = W32->LResultFromObject(IID_IUnknown, wparam, (LPUNKNOWN)punk);
|
|
punk->Release();
|
|
break;
|
|
}
|
|
#endif
|
|
|
|
default:
|
|
def: hr = S_FALSE;
|
|
break;
|
|
}
|
|
|
|
if(plresult)
|
|
*plresult = lres;
|
|
|
|
// TODO: FOR TESTING AIMM
|
|
if (hr == S_FALSE && fHaveAIMM)
|
|
{
|
|
HWND hWnd;
|
|
|
|
TxGetWindow(&hWnd);
|
|
hr = CallAIMMDefaultWndProc(hWnd, msg, wparam, lparam, plresult);
|
|
}
|
|
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 sometning 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
|
|
|
|
// These are rect's are used if we convert the the input parameters if we
|
|
// convert the HDC's mapping mode. The idea here is we avoid changing our
|
|
// clients memory.
|
|
RECTL rcLocalBounds;
|
|
RECTL rcLocalWBounds;
|
|
RECT rcLocalUpdate;
|
|
CCallMgr callmgr(this);
|
|
|
|
START_PROFILING
|
|
|
|
// 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;
|
|
}
|
|
|
|
BOOL fRestore = FALSE;
|
|
|
|
// Force DC in MM_TEXT
|
|
if(GetMapMode(hdcDraw) != MM_TEXT &&
|
|
GetDeviceCaps(hdcDraw, TECHNOLOGY) != DT_METAFILE)
|
|
{
|
|
fRestore = TRUE;
|
|
|
|
// Convert input parameters to new mapping.
|
|
if(lprcBounds)
|
|
{
|
|
rcLocalBounds = *lprcBounds;
|
|
lprcBounds = &rcLocalBounds;
|
|
WinLPtoDP(hdcDraw, (POINT *)lprcBounds, 2);
|
|
}
|
|
|
|
if(lprcWBounds)
|
|
{
|
|
rcLocalWBounds = *lprcWBounds;
|
|
lprcWBounds = &rcLocalWBounds;
|
|
WinLPtoDP(hdcDraw, (POINT *)lprcWBounds, 2);
|
|
}
|
|
|
|
if(lprcUpdate)
|
|
{
|
|
rcLocalUpdate = *lprcUpdate;
|
|
lprcUpdate = &rcLocalUpdate;
|
|
WinLPtoDP(hdcDraw, (POINT *)lprcUpdate, 2);
|
|
}
|
|
// Convert HDC to new mapping
|
|
ConvertDrawDCMapping(hdcDraw);
|
|
}
|
|
|
|
// 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(fRestore) // Put DC back into correct mapping mode
|
|
RestoreDC(hdcDraw, -1);
|
|
|
|
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();
|
|
}
|
|
|
|
|
|
// Get right coordinates for object
|
|
poleobjActive->ResetPosRect();
|
|
|
|
// and put it there!!
|
|
poleobjActive->OnReposition(0, 0);
|
|
}
|
|
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(plMax)
|
|
*plMax = _pdp->GetScrollRange(SB_HORZ);
|
|
|
|
if(plPos)
|
|
*plPos = _pdp->GetXScroll();
|
|
|
|
if(plPage)
|
|
*plPage = _pdp->GetViewWidth();
|
|
|
|
// CDisplay::_fHScrollEnabled may be TRUE when not in-place active
|
|
// because it has a dual meaning: 1) need Horiz scroll bars, and 2)
|
|
// CDisplay::_xScroll is allowed for ES_AUTOHSCROLL even with no
|
|
// horizontal scrollbar. The latter can turn on _fHScrollEnabled 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: _fHScrollEnabled and
|
|
// _fHScrollbarEnabled, 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->IsHScrollEnabled() : 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(plMax)
|
|
*plMax = _pdp->GetScrollRange(SB_VERT);
|
|
|
|
if(plPos)
|
|
{
|
|
*plPos = _pdp->GetYScroll();
|
|
*plPos = _pdp->ConvertYPosToScrollPos(*plPos);
|
|
}
|
|
|
|
if(plPage)
|
|
{
|
|
*plPage = _pdp->GetViewHeight();
|
|
*plPage = _pdp->ConvertYPosToScrollPos(*plPage);
|
|
}
|
|
|
|
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.
|
|
*/
|
|
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 rcClient;
|
|
CDrawInfo di(this);
|
|
START_PROFILING
|
|
|
|
if(FAILED(RectChangeHelper(&di, dwDrawAspect, lindex, pvAspect, ptd,
|
|
hdcDraw, hicTargetDev, &lprcClient, &rcClient)))
|
|
{
|
|
return E_INVALIDARG;
|
|
}
|
|
|
|
// Set the cursor
|
|
CTxtSelection * const psel = GetSel();
|
|
HCURSOR hcurNew = _hcurArrow; // Default using system arrow
|
|
POINT pt = {x, y};
|
|
BOOL fInLink = FALSE;
|
|
|
|
if(PtInRect(&rcClient, pt))
|
|
{
|
|
// Find out what the cursor is pointing at
|
|
_pdp->CpFromPoint(pt, lprcClient, 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(pt.x, pt.y), &fInLink))
|
|
{
|
|
return NOERROR;
|
|
}
|
|
hcurNew = _hcurHand;
|
|
}
|
|
else if(Hit != HT_Nothing && Hit != HT_OutlineSymbol && Hit != HT_BulletArea)
|
|
{
|
|
if(!psel || !psel->PointInSel(pt, lprcClient) || _fDisableDrag)
|
|
{
|
|
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(hdcDraw) // Release DC if we got it
|
|
_pdp->ResetDC();
|
|
|
|
_pdp->ReleaseDrawInfo();
|
|
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");
|
|
|
|
RECT rcClient;
|
|
CCallMgr callmgr(this);
|
|
CDrawInfo di(this);
|
|
|
|
START_PROFILING
|
|
|
|
if (FAILED(RectChangeHelper(&di, dwDrawAspect, lindex, pvAspect, ptd,
|
|
hdcDraw, hicTargetDev, &lprcClient, &rcClient)))
|
|
{
|
|
return E_INVALIDARG;
|
|
}
|
|
|
|
HRESULT hr;
|
|
POINT pt = {x, y};
|
|
|
|
if(!_fTransparent)
|
|
{
|
|
*pHitResult = TXTHITRESULT_HIT;
|
|
hr = S_OK;
|
|
}
|
|
else
|
|
hr = _pdp->TransparentHitTest(hdcDraw, lprcClient, pt, pHitResult);
|
|
|
|
// Release DC if we got it
|
|
if(hdcDraw)
|
|
_pdp->ResetDC();
|
|
|
|
_pdp->ReleaseDrawInfo();
|
|
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");
|
|
|
|
RECT rcView;
|
|
HDC hdc;
|
|
BOOL fSucceeded = TRUE;
|
|
CCallMgr callmgr(this);
|
|
|
|
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);
|
|
|
|
// Compute view rect from passsed in client rect
|
|
_pdp->GetViewRect(rcView, prcClient);
|
|
|
|
// 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->GetViewWidth())
|
|
{
|
|
// 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->GetXCaretReally();
|
|
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]
|
|
{
|
|
#ifndef PEGASUS
|
|
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 ||
|
|
dwMode != TXTNS_FITTOCONTENT && dwMode != TXTNS_ROUNDTOLINE ||
|
|
!pwidth || !pheight)
|
|
{
|
|
// 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;
|
|
}
|
|
|
|
// Assume that we need to change mapping modes. Note that we need to be
|
|
// in MM_TEXT because our measuring assumes this is so.
|
|
BOOL fRestore = FALSE;
|
|
|
|
// Convenient place to put height & width for converting them to
|
|
// device units.
|
|
POINT pt;
|
|
pt.x = *pwidth;
|
|
pt.y = *pheight;
|
|
|
|
// WARNING: From this point on we expect to execute this routine clear
|
|
// through so that the DC state can be reset if we set it and because
|
|
// we reset the extents so that the zoom factor can be calculated
|
|
// appropriately for this call. Therefore, be very careful about
|
|
// any return statements you might want to add.
|
|
|
|
// force DC in MM_TEXT
|
|
if(GetMapMode(hdcDraw) != MM_TEXT &&
|
|
GetDeviceCaps(hdcDraw, TECHNOLOGY) != DT_METAFILE)
|
|
{
|
|
WinLPtoDP(hdcDraw, &pt, 1); // Convert to device units
|
|
fRestore = TRUE; // Remember that DC got converted
|
|
ConvertDrawDCMapping(hdcDraw);
|
|
}
|
|
|
|
// 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(fRestore) // Put DC back into correct
|
|
RestoreDC(hdcDraw, -1); // mapping mode
|
|
|
|
if(SUCCEEDED(hr)) // Set return values if this worked
|
|
{
|
|
if(fRestore)
|
|
{
|
|
// Convert return value back to input logical units if we
|
|
// converted them to use them.
|
|
DPtoLP(hdcDraw, &pt, 1);
|
|
}
|
|
*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;
|
|
#else
|
|
return 0;
|
|
#endif
|
|
}
|
|
|
|
/*
|
|
* 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 PEGASUS
|
|
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:
|
|
* · The password character changed,
|
|
* · 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 (pdwWidth, pdwHeight)
|
|
*
|
|
* @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 *pdwWidth, //@parm Where to put width (in client coords)
|
|
DWORD *pdwHeight) //@parm Where to put height (in client coords)
|
|
{
|
|
TRACEBEGIN(TRCSUBSYSTS, TRCSCOPEEXTERN, "CTxtEdit::TxGetCachedSize");
|
|
|
|
return _pdp->GetCachedSize(pdwHeight, pdwWidth);
|
|
}
|
|
|
|
// 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;
|
|
}
|