/* * @doc EXTERNAL * * @module TEXTSERV.CPP -- Text Services Implementation | * * Original Author: * Rick Sailor * * History: * 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 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 * S_FALSE Message was not processed. Typically indicates that caller * should process message, maybe by calling DefWindowProc * S_MSG_KEYIGNORED Message processed, but no action was taken * E_OUTOFMEMORY * * @comm * Note that two return values are passed back from this function. *

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 *

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: * * TXTHITRESULT_NOHIT Hit was outside client rectangle. * 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 * E_FAIL - could not activate object due to error. * * @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 * */ 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 * * */ 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 * */ 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 * E_INVALIDARG - invalid BSTR pointer passed in. * E_OUTOFMEMORY - could not allocate memory for copy of the text * * @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 * E_FAIL - text could not be updated. * * @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 * */ 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 * E_FAIL - There is no selection * E_INVALIDARG - Input argument is invalid * * @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 * E_INVALIDARG * E_FAIL Unable to determine correct size * E_OUTOFMEMORY * * @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. * *

and

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 * E_OUTOFMEMORY - Could not create drop target * * @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: * * TXTBIT_RICHTEXT * TXTBIT_MULTILINE * TXTBIT_READONLY * TXTBIT_SHOWACCELERATOR * TXTBIT_USEPASSWORD * TXTBIT_HIDESELECTION * TXTBIT_SAVESELECTION * TXTBIT_AUTOWORDSEL * TXTBIT_AUTOSIZE * TXTBIT_VERTICAL * TXTBIT_SELECTIONBAR * TXTBIT_WORDWRAP * * TXTBIT_CLIENTRECTCHANGE * TXTBIT_VIEWINSETCHANGE * TXTBIT_BACKSTYLECHANGE * TXTBIT_MAXLENGTHCHANGE * TXTBIT_SCROLLBARCHANGE * TXTBIT_CHARFORMATCHANGE * TXTBIT_PARAFORMATCHANGE * TXTBIT_ALLOWBEEP * TXTBIT_EXTENTCHANGE * * 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: * #define TXTBACK_TRANSPARENT 0 * #define TXTBACK_SOLID 1 * * 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 * WS_VSCROLL // control has vertical scrollbar * ES_AUTOVSCROLL // auto-scroll horizontally * ES_AUTOVSCROLL // auto-scroll vertically * ES_DISABLENOSCROLL // scrollbar should be disabled when scrolling * impossible * * 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. * E_INVALIDARG - An invalid argument was passed in. * E_OUTOFMEMORY - Memory for text services object could not be allocated. * 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; }