/* * @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-2001, Microsoft Corporation. All rights reserved. */ #include "_common.h" #include "_edit.h" #include "_dispprt.h" #include "_dispml.h" #include "_dispsl.h" #include "_select.h" #include "_text.h" #include "_runptr.h" #include "_font.h" #include "_measure.h" #include "_render.h" #include "_m_undo.h" #include "_antievt.h" #include "_rtext.h" #include "_urlsup.h" #include "_magelln.h" #ifndef NOLINESERVICES #include "_ols.h" #endif #include "_clasfyc.h" #include "_tomfmt.h" #ifndef OBJID_NATIVEOM #define OBJID_NATIVEOM 0xFFFFFFF0 #endif #ifndef NOPRIVATEMESSAGE #include "_MSREMSG.H" #include "_dxfrobj.h" #endif #ifndef NOACCESSIBILITY #include "oleacc.h" #endif // By turning on the PROFILE_TS compiler directive, you tell IceCap2.0 // to turn on profiling for only ITextServices API's. Typically only // used during profiling work. //#define PROFILE_TS #ifdef PROFILE_TS #include class CapProfile { public: CapProfile() { StartCAP(); } ~CapProfile() { StopCAP(); } }; #define START_PROFILING CapProfile capprf; #else #define START_PROFILING #endif //PROFILE_TS ASSERTDATA // Macros to get mouse coordinates out of a message // need to cast to SHORT first for sign extension #define MOUSEX ((INT)(SHORT)LOWORD(lparam)) #define MOUSEY ((INT)(SHORT)HIWORD(lparam)) LONG ValidateTextRange(TEXTRANGE *pstrg); BOOL g_OLSBusy = 0; // Helper function in edit.cpp LONG GetECDefaultHeightAndWidth( ITextServices *pts, HDC hdc, LONG lZoomNumerator, LONG lZoomDenominator, LONG yPixelsPerInch, LONG *pxAveWidth, LONG *pxOverhang, LONG *pxUnderhang); // if there's an active object being dragged around, on WM_PAINT we always // try to reposition it to there it should be. A not-so-well-behaved object // my generate another WM_PAINT message in response to that, even if it actually // did not move. So we limit our number of attempts to reposition it and reset // this counter every time a mouse moves. // The corresponding field is declared as :2, so don't try to bump it up // without allocating more bits!! #define MAX_ACTIVE_OBJ_POS_TRIES (3) // Interchange horizontal and vertical commands WORD InterchangeScrollCode(WORD wCode) { switch(wCode) { case SB_BOTTOM: return SB_TOP; case SB_LINEDOWN: return SB_LINEUP; case SB_LINEUP: return SB_LINEDOWN; case SB_PAGEDOWN: return SB_PAGEUP; case SB_PAGEUP: return SB_PAGEDOWN; case SB_TOP: return SB_BOTTOM; default: return wCode; } } ///////////////////////////// Helper Functions /////////////////////////////////// /* * BOOL CTxtEdit::LoadMsgFilter(msg, wparam, lparam) * * @func * Check if we should load the IME message filter * * @rdesc * TRUE - Load it * FALSE - Don't load */ BOOL CTxtEdit::LoadMsgFilter( UINT msg, //@parm Message ID WPARAM wparam, //@parm Message wparam LPARAM lparam) //@parm Message lparam { //TRACEBEGIN(TRCSUBSYSTS, TRCSCOPEINTERN, "CTxtEdit::LoadMsgFilter"); // For the first ever message, we want to check if // our client has created AIMM object for current thread #ifndef NOFEPROCESSING if (!_fCheckAIMM) { DWORD dwThreadId; DWORD dwLoadActiveInput = 0; _fCheckAIMM = 1; #ifndef NOPRIVATEMESSAGE if (!_f10Mode) // Don't check if 1.0 mode { if (FindAtomA("_CTF_PROCESS_ATOM_")) // Is process using Cicero? dwLoadActiveInput = SES_USECTF; if (FindAtomA("_AIMM12_PROCESS_ATOM_")) // Is process using Aimm 1.2? dwLoadActiveInput = SES_USEAIMM12; // Yes, this will override SES_USECTF. else if (dwThreadId = GetCurrentThreadId()) { char szBuf[20]; sprintf(szBuf, "AIMM:%08x", dwThreadId); if (FindAtomA(szBuf)) // Is thread using Aimm 1.1? dwLoadActiveInput = SES_USEAIMM11; // Yes, load Aimm 1.1 } if (!dwLoadActiveInput) // Process is not using anything... { if (W32->fUseCTF()) // Ini file say use Cicero dwLoadActiveInput = SES_USECTF; else if (W32->fUseAimm()) // Ini file say use Aimm 1.2 dwLoadActiveInput = SES_USEAIMM12; } if (dwLoadActiveInput) { HWND hWnd = NULL; TxGetWindow( &hWnd ); if (hWnd) { if (_fInOurHost) PostMessage(hWnd, EM_SETUIM, dwLoadActiveInput, dwLoadActiveInput); else { LRESULT lResult; TxSendMessage(EM_SETUIM, dwLoadActiveInput, dwLoadActiveInput, &lResult); } } } } #endif } switch (msg) { case WM_KEYDOWN: case WM_SYSKEYDOWN: if ( (WORD) wparam == VK_PROCESSKEY ) return TRUE; break; case WM_INPUTLANGCHANGE: if (IsFELCID((WORD)(lparam))) return TRUE; break; case EM_SETEDITSTYLE: if ((lparam & (SES_USEAIMM | SES_NOIME | SES_USECTF | SES_CTFALLOWEMBED | SES_CTFALLOWSMARTTAG | SES_CTFALLOWPROOFING)) || (wparam & (SES_USEAIMM | SES_NOIME | SES_USECTF | SES_CTFALLOWEMBED | SES_CTFALLOWSMARTTAG | SES_CTFALLOWPROOFING))) return TRUE; break; case EM_RECONVERSION: case WM_IME_NOTIFY: case WM_IME_REQUEST: case WM_IME_STARTCOMPOSITION: case EM_GETIMEOPTIONS: case EM_SETIMEOPTIONS: case EM_SETIMECOLOR: case EM_GETIMECOLOR: case WM_IME_CHAR: #ifndef NOPRIVATEMESSAGE case EM_SETUIM: #endif case EM_SETIMEMODEBIAS: case EM_GETIMEMODEBIAS: case EM_GETCTFMODEBIAS: case EM_SETCTFMODEBIAS: case EM_GETCTFOPENSTATUS: case EM_SETCTFOPENSTATUS: case EM_GETIMECOMPTEXT: case EM_ISIME: case EM_GETIMEPROPERTY: return TRUE; case EM_SETLANGOPTIONS: if (lparam & (IMF_IMEALWAYSSENDNOTIFY | IMF_IMECANCELCOMPLETE)) return TRUE; break; default: if (msg) { if (msg == MSIMEReconvertMsg || msg == MSIMEDocFeedMsg || msg == MSIMEQueryPositionMsg) return TRUE; } break; } #endif return FALSE; } /* * CTxtEdit::FormatAndPrint (hdcDraw, hicTargetDev, ptd, lprcBounds, * lprcWBounds) * @mfunc * Format and Print data in control * * @rdesc * S_OK - everything worked * E_FAIL - unexpected failure occurred */ HRESULT CTxtEdit::FormatAndPrint( HDC hdcDraw, //@parm HDC to draw on HDC hicTargetDev, //@parm Input information context if any DVTARGETDEVICE *ptd, //@parm Device target information RECT *lprcBounds, //@parm Rectangle to measure RECT *lprcWBounds) //@parm Metafile information { TRACEBEGIN(TRCSUBSYSTS, TRCSCOPEINTERN, "CTxtEdit::FormatAndPrint"); // Put client rectangle in format structure FORMATRANGE fr; fr.rc = *lprcBounds; // Get number of device units per inch LONG xPerInch; LONG yPerInch; if (NULL == lprcWBounds) { xPerInch = GetDeviceCaps(hdcDraw, LOGPIXELSX); yPerInch = GetDeviceCaps(hdcDraw, LOGPIXELSY); } else { //Forms ^3 draws using screen resolution, while OLE specifies HIMETRIC xPerInch = fInOurHost() ? 2540 : W32->GetXPerInchScreenDC(); yPerInch = fInOurHost() ? 2540 : W32->GetYPerInchScreenDC(); SetWindowOrgEx(hdcDraw, lprcWBounds->left, lprcWBounds->top, NULL); SetWindowExtEx(hdcDraw, lprcWBounds->right, lprcWBounds->bottom, NULL); } // Convert rectangle into TWIPS fr.rc.left = MulDiv(fr.rc.left, LX_PER_INCH, xPerInch); fr.rc.top = MulDiv(fr.rc.top, LY_PER_INCH, yPerInch); fr.rc.right = MulDiv(fr.rc.right, LX_PER_INCH, xPerInch); fr.rc.bottom = MulDiv(fr.rc.bottom, LY_PER_INCH, yPerInch); // Use message based printing code to do our printing for us fr.hdc = hdcDraw; fr.hdcTarget = hicTargetDev; fr.rcPage = fr.rc; fr.chrg.cpMin = _pdp->GetFirstVisibleCp(); fr.chrg.cpMost = -1; // Assume this is all going to work HRESULT hr = S_OK; SPrintControl prtcon; prtcon._fDoPrint = TRUE; prtcon._fPrintFromDraw = TRUE; // Print control if(OnFormatRange(&fr, prtcon, TRUE) == -1) { // For some reason the control could not be printed hr = E_FAIL; } return hr; } /* * CTxtEdit::SetText (pstr, flags, CodePage, publdr, plres) * * @mfunc Sets the text in the document, clearing out any existing text * * @rdesc HRESULT */ HRESULT CTxtEdit::SetText( LPCWSTR pstr, //@parm Text to set DWORD flags, //@parm 0 or more ST_xxx's LONG CodePage, //@parm CodePage IUndoBuilder *publdr, //@parm Optional place to put undo events LRESULT * plres) //@parm Optional place to return cch added { CCallMgr callmgr(this); BOOL fSel = flags & ST_SELECTION; BOOL fSetTextMax = TRUE; CTxtRange rg(this, 0, -GetTextLength()); // Select whole story CTxtRange * prg = &rg; LRESULT lres = 0; CFreezeDisplay fd(_pdp); CCharFormat CF; BOOL fSetCF = FALSE; BOOL fInputString = FALSE; // Initialize to no input string // NOTE: WM_SETTEXT is the only message using flags == ST_CHECKPROTECTION. // This is sent in via ANSIWndProc(). Do we need another flag to indicate // WM_SETTEXT or is this check good enough? This only affect 1.0 mode. BOOL f10WM_SETTEXT = flags & ST_10WM_SETTEXT; if(plres) *plres = 0; if(fSel) // Set selected text { if(!_psel) { Beep(); return E_FAIL; } // Bug fix: 6498 - we need to know if scroll position is at bottom // before inserting text if (Get10Mode()) { LONG nMin, nMax, nPos, nPage; BOOL nEnable; TxGetVScroll(&nMin, &nMax, &nPos, &nPage, &nEnable); if (nEnable) _psel->SetAutoVScroll((nMax - nPage - 3) <= nPos); } prg = _psel; } else { _qwCharFlags &= FRTL | FDIGITSHAPE; // No chars, so kill char flags if (!IsRich()) { // Deleting all text from Plain text, we want to // go back to the -1 format prg->Set_iCF(-1); prg->SetUseiFormat(TRUE); } else _qwCharFlags |= FBELOWX40; // For final EOP } if (flags & ST_CHECKPROTECTION && IsProtectedRange(WM_SETTEXT, 0, (LPARAM)pstr, prg)) { return E_ACCESSDENIED; } // 1.0 COMPATABILITY // 1.0 didn't scroll to selection if text is inserted via EM_REPLACESEL // and fHideSelection is FALSE; BOOL fUpdateCaret = !(Get10Mode() && (flags & ST_10REPLACESEL) && fHideSelection() && !_psel->GetAutoVScroll()); if(!(flags & ST_KEEPUNDO)) { if(IsRich() && !fSel) { if (f10WM_SETTEXT) { // If pstr is empty string, retain format at end of current text. // If pstr is not empty string, retain format at cp = 1. // Note: prg->_rpCF is already at SetRun(0,0) CFormatRunPtr rp(prg->_rpCF); if (!pstr || *(LPBYTE)pstr == '\0') { LONG cchAdjusted = GetAdjustedTextLength() - 1; if (cchAdjusted > 0) rp.Move(cchAdjusted); } CF = *(GetCharFormat(rp.GetFormat())); fSetCF = TRUE; prg->SetText(NULL); // delete all the text first } // SetText causing all formatting to return to the default. We use // the notification system to remove the formatting. This is // particularly important for the final EOP which cannot be deleted. // Notify every interested party that they should dump their formatting _nm.NotifyPreReplaceRange(NULL, CONVERT_TO_PLAIN, 0, 0, 0, 0); // Tell document to dump its format runs _story.DeleteFormatRuns(); if (fSetCF) prg->SetCharFormat(&CF, 0, NULL, CFM_ALL, 0); } publdr = NULL; if(_pundo) _pundo->ClearAll(); if(_predo) _predo->ClearAll(); // If we are re-entered, there may be anti-events higher up the // chain. Grab the undo builder and clear things away if necessary. CGenUndoBuilder undobldr(this, 0); undobldr.Discard(); } if(publdr) publdr->StopGroupTyping(); // Need to reinit zoomin variables if entire text is being replaced if (!fSel) InitDocInfo(); else if(_psel->GetCch()) // If insert into selection, need to { // insert an EOP if selection ends CPFRunPtr rp(*_psel); // at a table row delimiter if(_psel->GetCch() < 0) rp.Move(-_psel->GetCch()); if(rp.IsTableRowDelimiter()) _psel->InsertEOP(publdr, 0); } LONG lStreamFormat = IsRich() && IsRTF((LPSTR)pstr, 10) ? SF_RTF : 0; if(pstr && *(LPSTR)pstr && (CodePage != 1200 || lStreamFormat || *pstr < 128 && fSel && !*(pstr+1))) { LONG cch = strlen((LPSTR)pstr); // REMARK: little endian dependence DWORD ch = *(LPBYTE)pstr; // for CodePage = 1200 cases fInputString = TRUE; if(ch < 128 && fSel && cch == 1) { lres = 1; fSetTextMax = FALSE; TxSetMaxToMaxText(1); if(ch == CR) InsertEOP(0, FALSE, publdr); else _psel->PutChar(ch, 0, publdr); } else if(cch == 2 && ch == CR && *((LPSTR)pstr + 1) == LF) { lres = 2; fSetTextMax = FALSE; TxSetMaxToMaxText(2); InsertEOP(0, FALSE, publdr); } else { READHGLOBAL rhg = {(LPSTR)pstr, cch}; EDITSTREAM es = {(DWORD_PTR)&rhg, S_OK, ReadHGlobal}; HCURSOR hcur = NULL; // Want wait cursor to display sooner bool fSetCursor = rhg.cbLeft > NUMPASTECHARSWAITCURSOR; if(fSetCursor) hcur = TxSetCursor(LoadCursor(NULL, IDC_WAIT)); if (CodePage <= 0) { if (Get10Mode()) { LONG iFormat = _psel->GetiFormat(); const CCharFormat *pCF = GetCharFormat(iFormat); CodePage = CodePageFromCharRep(pCF->_iCharRep); } else CodePage = (CodePage == 0) ? GetACP() : GetDefaultCodePage(EM_SETTEXTEX); } if(!lStreamFormat) lStreamFormat = SF_TEXT; lStreamFormat |= SF_USECODEPAGE | (CodePage << 16); if(fSel) lStreamFormat |= SFF_SELECTION; lres = _ldte.LoadFromEs(prg, lStreamFormat, &es, FALSE, publdr); if(fSetCursor) TxSetCursor(hcur); if(es.dwError != NOERROR) return (HRESULT)es.dwError; } } else { // 9052: Don't delete all if 4 (ST_NEWCHARS) is passed in EM_SETTEXTEX DWORD dwFlags = (flags & 4) ? RR_ITMZ_UNICODEBIDI | RR_NEW_CHARS : RR_ITMZ_UNICODEBIDI; if (CodePage != 1200 && pstr && !*(LPSTR)pstr) pstr = NULL; if(pstr && *pstr) fInputString = TRUE; lres = prg->CleanseAndReplaceRange(-1, pstr, FALSE, publdr, NULL, NULL, dwFlags); } if(!lres && fInputString) { // There was an input string but for some reason there was no update. return E_FAIL; } if (_fOutlineView) { // Outline view must have formatting. _psel->Check_rpPF(); } if(_psel) { if(fSel) _psel->Update(fUpdateCaret); else { // Setting the text means a new document so if there is a selection // turn it into an insertion point at the beginning of the document. _psel->ClearPrevSel(); _psel->Set(0, 0); // Since the text is being completely replaced and all formatting // is being lost, let's go back to the default format for the // selection. if (!f10WM_SETTEXT) _psel->Set_iCF(-1); else if (fSetCF) _psel->SetCharFormat(&CF, 0, NULL, CFM_ALL, 0); if(_fFocus || _psel->IsParaRTL()) { // Update caret to reflect new postion _psel->UpdateCaret(fUpdateCaret); } } } // If we've replaced the entire document, the control isn't // really "modified" anymore. This is necessary to match // the Windows MLE behavior. However, since RichEdit 1.0 // did _not_ do this (they left fModified to be TRUE), we // only do this for RichEdit 2.0 and later. if(!Get10Mode() && !publdr && !fSel) _fModified = FALSE; _fSaved = FALSE; // ITextDocument isn't Saved // Adjust text limit if necessary if (fSetTextMax) TxSetMaxToMaxText(); if(plres) *plres = fSel ? lres : 1; return S_OK; } /////////////////////////// ITextServices Methods //////////////////////////////// // External IME Message Filter Interface factory #ifndef NOFEPROCESSING void CreateIMEMessageFilter(ITextMsgFilter **ppNewFilter); #endif /* * @doc EXTERNAL * * CTxtEdit::TxSendMessage (msg, wparam, lparam, plresult) * * @mfunc * Used by window host to forward messages sent to its window to the * text services. * * @rdesc * NOERROR Message was processed, and some action taken * 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; } #ifndef NOFEPROCESSING if (_pMsgFilter) { PassMsg: hr = _pMsgFilter->HandleMessage(&msg, &wparam, &lparam, &lres); if (hr == S_OK) // Message has been handled. { if(plresult) *plresult = lres; return S_OK; } hr = S_OK; // Reset } else if (LoadMsgFilter(msg, wparam, lparam)) { HWND hwnd = NULL; if (_fInOurHost) { // If not in Forms^3 we can get the window from our host. // For Forms^3 we will use NULL for the desktop Window and pray TxGetWindow( &hwnd ); } ITextMsgFilter *pNewFilter = NULL; CreateIMEMessageFilter(&pNewFilter); if (pNewFilter) { pNewFilter->AttachDocument( hwnd, (ITextDocument2 *) this, (ITextServices *) this ); AttachMsgFilter(pNewFilter); goto PassMsg; } } #endif START_PROFILING IUndoBuilder * publdr; CGenUndoBuilder undobldr(this, UB_AUTOCOMMIT, &publdr); switch(msg) { case EM_CANPASTE: // we don't check for protection here, as RichEdit 1.0 // doesn't lres = _ldte.CanPaste(NULL, (CLIPFORMAT) wparam, RECO_PASTE); break; case EM_CANUNDO: if(_pundo) lres = _pundo->CanUndo(); break; case EM_CANREDO: if(_predo) lres = _predo->CanUndo(); break; case EM_GETUNDONAME: if(_pundo) lres = _pundo->GetNameIDFromAE((void*)wparam); break; case EM_GETREDONAME: if(_predo) lres = _predo->GetNameIDFromAE((void*)wparam); break; case EM_STOPGROUPTYPING: if(_pundo) { // we'll only stop group typing iff wparam // is zero (meaning stop regardless) _or_ if // wparam matches the merge anti event. // // This feature allows clients to say that only // a specific anti-event should close out it's // "fuzzy" state. Note that currently, only the // merge anti-event has this fuzzy state. if(!wparam || (IAntiEvent *)wparam == _pundo->GetMergeAntiEvent()) _pundo->StopGroupTyping(); } break; case WM_UNICHAR: // Unambiguous Unicode character if(wparam == NOTACHAR) { lres = TRUE; // Tell caller we understand msg break; } // Else fall thru to WM_CHAR case WM_CHAR: if(GetKeyboardFlags() & (ALTNUMPAD | HOTEURO)) { if (GetKeyboardFlags() & ALTNUMPAD) { if (GetKeyboardFlags() & ALT0 && GetCharFormat(-1)->_iCharRep == MAC_INDEX && GetKeyboardCharRep(0) == ANSI_INDEX) { WCHAR ch; UnicodeFromMbcs(&ch, 1, (char *)&wparam, 1, 10000); wparam = ch; SetKeyPadNumber(ch); ResetKeyboardFlag(ALTNUMPAD | ALT0); } #ifndef NOANSIWINDOWS else { CW32System::WM_CHAR_INFO wmci; wmci._fAccumulate = FALSE; W32->AnsiFilter(msg, wparam, lparam, (void *)&wmci); } #endif } else // (GetKeyboardFlags() & HOTEURO) case { // We have handled the Euro, just eat this WM_CHAR ResetKeyboardFlag(HOTEURO); break; } } // Fall thru to WM_IME_CHAR case WM_IME_CHAR: // 2 byte character, usually FE. lres = hr = OnTxChar((DWORD)wparam, (DWORD)lparam, publdr); ResetKeyboardFlag(HOTEURO); break; case WM_USER + 39: // For backward compat with NT 3.51 case EM_CHARFROMPOS: hr = TxCharFromPos((LPPOINT)lparam, &lres); break; #ifdef WM_INPUTLANGCHANGE case WM_INPUTLANGCHANGE: if (_fSingleCodePage) { // See if the charset for the specified keyboard is supported by // the single code page we support. If we don't have a _pDocInfo, // assume the code page is the system code page. We will always // support the ANSI charset, as all code pages contain at least // a large portion of this charset (the ASCII block). wparam = (!wparam || wparam == GetCharSet(_pDocInfo ? _pDocInfo->_wCpg : GetSystemDefaultCodePage())); } goto update_kbd; case WM_INPUTLANGCHANGEREQUEST: // If the SingleCodePage option is set, then we must have a // "good" code page to go to; if not, just eat this message. // // This will prevent folks from typing French and Greek // on the same edit control, which is useful for certain // kinds of backward compatibility scenarios. // // HACK ALERT! the documentation on WM_INPUTLANGCHANGEREQUEST // is wrong. It turns out that _only_ the low bit of wparam // indicates whether or not the new keyboard can be considered // as the same code page. if (_fSingleCodePage && !(wparam & 1)) { // The lowest bit check is not reliable in some platforms e.g. Viet OSR2 // since it doesnt allow English kbd to match system charset (bug #6365). wparam = PRIMARYLANGID(LOWORD(lparam)) == LANG_ENGLISH && IN_RANGE (SUBLANG_ENGLISH_US, SUBLANGID(LOWORD(lparam)), SUBLANG_ENGLISH_UK); } update_kbd: if(!_fSingleCodePage || (wparam & 1)) { WORD wKLCurrent = LOWORD(GetKeyboardLayout(0)); // Update our idea of current keyboard layout W32->RefreshKeyboardLayout(); if(GetKeyboardFlags() & CTRL && GetKeyboardFlags() & SHIFT) SetKeyboardFlag(LETAFTERSHIFT); if( wKLCurrent == LOWORD(lparam) || // No change in keyboard GetSel()->CheckChangeFont((HKL)lparam, CharRepFromLID(LOWORD(lparam)))) hr = S_FALSE; // cause default window to allow kb switch. } break; #endif case WM_CLEAR: OnClear(publdr); break; case WM_CONTEXTMENU: hr = OnContextMenu(lparam); break; case WM_COPY: case WM_CUT: lres = hr = CutOrCopySelection(msg, wparam, lparam, publdr); break; case WM_RENDERFORMAT: lres = hr = _ldte.RenderClipboardFormat(wparam); break; case WM_RENDERALLFORMATS: lres = hr = _ldte.RenderAllClipboardFormats(); break; case WM_DESTROYCLIPBOARD: lres = hr = _ldte.DestroyClipboard(); break; case EM_DISPLAYBAND: if (fInplaceActive()) { { CLock lock; if (g_OLSBusy) { hr = OLE_E_INVALIDRECT; break; } } OnDisplayBand((const RECT *) lparam, FALSE); lres = 1; } else hr = OLE_E_INVALIDRECT; break; #ifdef WM_DROPFILES case WM_DROPFILES: OnDropFiles((HANDLE) wparam); break; #endif case EM_EMPTYUNDOBUFFER: ClearUndo(publdr); break; case WM_ERASEBKGND: lres = 1; // We handle background erase during painting break; case EM_EXGETSEL: // Has cp output parameter OnExGetSel((CHARRANGE *)lparam); break; case EM_FINDTEXT: // Has cp input/output parms case EM_FINDTEXTW: // Has cp input/output parms case EM_FINDTEXTEX: // Has cp input/output parms case EM_FINDTEXTEXW: // Has cp input/output parms lres = OnFindText(msg, (DWORD)wparam, (FINDTEXTEX *)lparam); break; case EM_FINDWORDBREAK: // Has cp input/output parms hr = TxFindWordBreak((INT)wparam, (LONG)lparam, &lres); break; case EM_FORMATRANGE: // Has cp input/output parms if(fInplaceActive()) { { CLock lock; if (g_OLSBusy) { hr = OLE_E_INVALIDRECT; break; } } SPrintControl prtcon; prtcon._fDoPrint = (wparam) ? TRUE : FALSE; lres = OnFormatRange((FORMATRANGE *) lparam, prtcon); } else hr = OLE_E_INVALIDRECT; break; case EM_GETTYPOGRAPHYOPTIONS: lres = _bTypography; break; case EM_GETBIDIOPTIONS: if((Get10Mode() || !wparam) && lparam && ((BIDIOPTIONS *)lparam)->cbSize == sizeof(BIDIOPTIONS)) { ((BIDIOPTIONS *)lparam)->wMask = BOM_NEUTRALOVERRIDE | BOM_CONTEXTREADING | BOM_CONTEXTALIGNMENT; ((BIDIOPTIONS *)lparam)->wEffects = (_fNeutralOverride ? BOE_NEUTRALOVERRIDE : 0) | (_nContextDir == CTX_NONE ? 0 : BOE_CONTEXTREADING) | (_nContextAlign == CTX_NONE ? 0 : BOE_CONTEXTALIGNMENT); } break; case EM_GETCHARFORMAT: lres = OnGetCharFormat((CHARFORMAT2 *)lparam, wparam); break; case EM_GETCODEPAGE: lres = GetDefaultCodePage((UINT)wparam); break; case EM_GETFIRSTVISIBLELINE: if (fInplaceActive()) lres = _pdp->GetFirstVisibleLine(); else hr = OLE_E_INVALIDRECT; break; case EM_GETLIMITTEXT: // Has cp output parameter (sort of) lres = TxGetMaxLength(); // Ignore unless testing screams break; case EM_GETLINE: if(fInplaceActive()) { lres = _pdp->GetLineText((LONG)wparam, (TCHAR *)lparam, (LONG) (*(WORD *) lparam)); } else hr = OLE_E_INVALIDRECT; break; case EM_GETLINECOUNT: hr = TxGetLineCount(&lres); break; case EM_GETMODIFY: // RichEdit 1.0 returned -1 if _fModified lres = -(LONG)_fModified; // is TRUE (go figure). So for backward break; // compatibility, we do too :-( case EM_GETOLEINTERFACE: if(lparam) { #ifndef NOFEPROCESSING if (wparam == 0x065737777) // 'AIMM' W32->GetAimmObject((IUnknown **)(lparam)); else #endif { *(IRichEditOle **)lparam = (IRichEditOle *)this; AddRef(); } } lres = TRUE; break; case EM_GETSCROLLPOS: { POINT *point = (POINT *)lparam; point->x = _pdp->GetUpScroll(); point->y = _pdp->GetVpScroll(); point->y = _pdp->ConvertVPosToScrollPos(point->y); lres = 1; } break; case EM_SETOLECALLBACK: hr = E_FAIL; if(lparam) { pobjmgr = GetObjectMgr(); if(pobjmgr) { pobjmgr->SetRECallback((IRichEditOleCallback *)lparam); lres = TRUE; hr = NOERROR; } } break; case EM_GETPAGE: lres = -1; // Signal page not available if(_pdp) { LONG i; hr = _pdp->GetPage(&i, (DWORD)wparam, (CHARRANGE *)lparam); if(hr == NOERROR) lres = i; } break; case EM_GETPARAFORMAT: lres = OnGetParaFormat((PARAFORMAT2 *)lparam, wparam); break; case EM_GETSEL: // Has cp output parameter lres = OnGetSel((LONG*)wparam, (LONG*)lparam); break; case EM_GETSELTEXT: lres = OnGetSelText((TCHAR *)lparam); break; case WM_GETTEXT: { GETTEXTEX gt; gt.cb = wparam * 2; gt.flags = GT_USECRLF; gt.codepage = 1200; gt.lpDefaultChar = NULL; gt.lpUsedDefChar = NULL; lres = GetTextEx(>, (TCHAR *)lparam); } break; case WM_GETTEXTLENGTH: // Has cp output parameter { GETTEXTLENGTHEX gtl; gtl.flags = GTL_NUMCHARS | GTL_PRECISE | GTL_USECRLF; gtl.codepage = 1200; lres = GetTextLengthEx(>l); } break; case EM_GETTEXTEX: lres = GetTextEx((GETTEXTEX *)wparam, (TCHAR *)lparam); break; case EM_GETTEXTLENGTHEX: // Has cp output parameter lres = GetTextLengthEx((GETTEXTLENGTHEX *)wparam); break; case EM_GETTEXTRANGE: // Has cp input parameter { TEXTRANGE * const ptr = (TEXTRANGE *)lparam; LONG cch = ValidateTextRange(ptr); // Only copy if there's something to copy and destination is valid if(cch) { LONG cpMin = GetCpFromAcp(ptr->chrg.cpMin); if(cch < 0) // Get text character count cch = GetTextLength(); // because caller wants it all else // + 1 is for terminating 0 cch = GetCpFromAcp(ptr->chrg.cpMost) - cpMin + 1; if(!IsBadWritePtr(ptr->lpstrText, cch * sizeof(TCHAR))) lres = GetTextRange(cpMin, cch, ptr->lpstrText); } } break; case EM_GETVIEWKIND: GetViewKind(&lres); break; #ifndef NOWORDBREAKPROC case EM_GETWORDBREAKPROC: // Client can only use either WordBreakProc or ExWordBreakProc // Return NULL if ExWordBreakProc is being used. if (!_fExWordBreakProc) lres = (LRESULT) _pfnWB; break; case EM_GETWORDBREAKPROCEX: // Return ExWordBreakProc if it is being used. if (_fExWordBreakProc) lres = (LRESULT) _pfnWB; break; #endif case EM_GETZOOM: if(wparam && lparam) { *(unsigned *)wparam = GetZoomNumerator(); *(unsigned *)lparam = GetZoomDenominator(); lres = 1; } break; case EM_HIDESELECTION: if (Get10Mode() && lparam) _fHideSelection = !!wparam; if(!lparam || !_fFocus) lres = OnHideSelectionChange((BOOL)wparam); break; case WM_HSCROLL: if (IsUVerticalTflow(_pdp->GetTflow())) { WORD wCode = LOWORD(wparam); wCode = InterchangeScrollCode(wCode); LONG vpPos = HIWORD(wparam); //In vertical displays the scrollbar position needs to be swapped. if (_pdp->GetTflow() == tflowSW && (wCode == SB_THUMBTRACK || wCode == SB_THUMBPOSITION)) { LONG vpMax, vpPage; TxGetHScroll(NULL, &vpMax, NULL, &vpPage, NULL); vpPos = vpMax - vpPos - vpPage; vpPos = max(vpPos, 0); } hr = _pdp->VScroll(wCode, vpPos); } else { _pdp->UScroll(LOWORD(wparam), HIWORD(wparam)); hr = 0; } break; case WM_KEYDOWN: hr = OnTxKeyDown((WORD) wparam, (DWORD) lparam, publdr); break; case WM_KEYUP: if(wparam == VK_APPS) HandleKbdContextMenu(); else // Else don't say we processed hr = S_FALSE; // message W32->_fLRMorRLM = 0; if(wparam == VK_CONTROL || wparam == VK_SHIFT) { // If a BiDi keyboard is installed, no strong-context behavior, // both a Ctrl and a Shift key are pressed, no letter has been // typed after the Ctrl and Shift keys have been pressed, and // ReadOnly/Protected tests allow, then the selected paragraphs // are set to RTL/LTR direction for the right/left Shift key, // respectively. The keyboard and caret are also matched to this // direction, and an alignment notification is sent. // ReadOnly/Protected tests is removed for backward compatibility. DWORD dwFlags = GetKeyboardFlags(); if (IsBiDiKbdInstalled() && !IsStrongContext(_nContextDir) && !IsStrongContext(_nContextAlign) && (dwFlags & CTRL) && (dwFlags & SHIFT) && !(dwFlags & LETAFTERSHIFT) /* && IsntProtectedOrReadOnly(WM_KEYUP, wparam, lparam) */ ) { CParaFormat PF; PF._wEffects = (dwFlags & RSHIFT) ? PFE_RTLPARA : 0; OnSetParaFormat(0, &PF, publdr, PFM_RTLPARA, PFM2_PARAFORMAT); TxNotify(PF._wEffects ? EN_ALIGNRTL : EN_ALIGNLTR, 0); } if(wparam == VK_CONTROL) lparam = (HIWORD(lparam) & KF_EXTENDED) ? RCTRL : LCTRL; else { lparam = (LOBYTE(HIWORD(lparam)) == 0x36) ? RSHIFT : LSHIFT; if(GetKeyState(VK_SHIFT) >= 0) // Ensure both shifts are off lparam = SHIFT; // (potential Win95 problem) } ResetKeyboardFlag(lparam | LETAFTERSHIFT | HOTEURO); } else if(wparam == VK_MENU) ResetKeyboardFlag((HIWORD(lparam) & KF_EXTENDED) ? (RALT | HOTEURO) : (LALT | HOTEURO)); break; case WM_KILLFOCUS: lres = OnKillFocus(); break; case WM_LBUTTONDBLCLK: hr = OnTxLButtonDblClk(MOUSEX, MOUSEY, (WORD) wparam); break; case WM_LBUTTONDOWN: if(_fEatLeftDown) { TxSetFocus(); _fEatLeftDown = FALSE; } else hr = OnTxLButtonDown(MOUSEX, MOUSEY, (WORD) wparam); break; case WM_LBUTTONUP: hr = OnTxLButtonUp(MOUSEX, MOUSEY, (WORD) wparam, LB_RELEASECAPTURE | LB_FLUSHNOTIFY); break; #if !defined(NOMAGELLAN) case WM_MBUTTONDBLCLK: // Magellan zmouse scroll case WM_NCMBUTTONDOWN: // support commandeers middle case WM_MBUTTONDOWN: // button. OnTxMButtonDown(MOUSEX, MOUSEY, (WORD) wparam); break; case WM_MBUTTONUP: OnTxMButtonUp(MOUSEX, MOUSEY, (WORD) wparam); break; case WM_MOUSEWHEEL: // Magellan zmouse scroll n lines. lres = HandleMouseWheel(wparam, lparam); break; #endif case EM_LINEFROMCHAR: // Has cp input parameter lparam = wparam; // Fall thru to EM_EXLINEFROMCHAR case EM_EXLINEFROMCHAR: // Has cp input parameter hr = TxLineFromCp((LONG)lparam, &lres); break; case EM_LINEINDEX: // Has cp output parameter hr = TxLineIndex((LONG)wparam, &lres); break; case EM_LINELENGTH: // Has cp input/output parameters hr = TxLineLength((LONG)wparam, &lres); break; case EM_LINESCROLL: // Has cp input parameter (cch) // Documentation says the line to scroll to should be relative to the current top line. // Richedit 2.0 based it on an absolute position. We're breaking richedit 2.0 compatibility // to go back to the documentation specification and to match what riched 1.0 originally // did hr = TxLineScroll((LONG)lparam, (LONG)wparam);// but not curr impl lres = _pdp->IsMultiLine(); break; #ifdef MA_ACTIVATE case WM_MOUSEACTIVATE: lres = MA_ACTIVATE; // If the window that currently has focus is part of our "application", // then don't eat the mouse click. Otherwise, if it's from another // app, the user is probably trying to swap apps, so eat the mouse // down message and let our host app get a chance to come to the // foreground. if (!(IsChild((HWND)wparam, GetFocus()) || (wparam && (HWND)wparam == GetFocus()))) { _fEatLeftDown = TRUE; } hr = S_FALSE; // pass WM_MOUSEACTIVATE message to DefWindProc break; #endif case WM_MOUSEMOVE: // We reset the "number of tries to put an active object // in place" count here _cActiveObjPosTries = MAX_ACTIVE_OBJ_POS_TRIES; hr = OnTxMouseMove(MOUSEX, MOUSEY, (WORD)wparam, publdr); break; case EM_OUTLINE: { CFreezeDisplay cfd(_pdp); if(wparam == EMO_GETVIEWMODE) { hr = GetViewKind(&lres); break; } CTxtSelection * psel = GetSelNC(); if(!_pdp->IsMultiLine() || !IsRich() || !psel) // Control must be rich, break; // multiline and active if(wparam == EMO_ENTER || wparam == EMO_EXIT) { hr = SetViewKind(wparam == EMO_ENTER ? VM_OUTLINE : VM_NORMAL); lres = !hr; break; } if(!IsInOutlineView() || !IsntProtectedOrReadOnly(msg, wparam, lparam)) break; CTxtRange rg(*psel); switch(wparam) { case EMO_PROMOTE: hr = rg.Promote(lparam, publdr); psel->Update_iFormat(-1); psel->Update(FALSE); break; case EMO_EXPAND: hr = rg.ExpandOutline((short)LOWORD(lparam), HIWORD(lparam) == EMO_EXPANDDOCUMENT); break; case EMO_MOVESELECTION: hr = MoveSelection(lparam, publdr); psel->Update(TRUE); break; default: // TraceMessage("Unknown outline function received\r\n"); break; }; lres = !hr; _fModified = TRUE; } break; case WM_PASTE: case EM_PASTESPECIAL: if(IsntProtectedOrReadOnly(msg, wparam, lparam)) { CTxtSelection *psel = GetSel(); hr = PasteDataObjectToRange(NULL, psel, (CLIPFORMAT) wparam, (REPASTESPECIAL *)lparam, publdr, PDOR_NONE); } break; case WM_USER + 38: // For backward compat with NT 3.51 case EM_POSFROMCHAR: // Has cp input parameter // RichEdit 2.x used wparam instead of lparam for the cp and ignored // wparam, unlike RE 1.0 and the Win32 documentation (sigh!). We fix // this, but are compatible with RE 2.x for cp's whose values // correspond to invalid write ptr's. if(IsBadWritePtr((LPPOINT)wparam, sizeof(POINT))) { // Invalid write ptr, so assume incorrect RE 2.0 params // TODO: enable following Assert when msgtest gets updated //AssertSz(FALSE, // "EM_POSFROMCHAR: wparam is illegal ptr, assuming cp value"); POINT pt; hr = TxPosFromChar((LONG)wparam, &pt); lres = SUCCEEDED(hr) ? MAKELONG(pt.x, pt.y) : -1; } else hr = TxPosFromChar((LONG)lparam, (LPPOINT)wparam); break; #ifndef NORBUTTON case WM_RBUTTONDBLCLK: case WM_RBUTTONDOWN: case WM_RBUTTONUP: // Give client a chance to handle these messages, // if we are over a link if(HandleLinkNotification(msg, wparam, lparam)) break; if(msg == WM_RBUTTONUP) hr = OnTxRButtonUp(MOUSEX, MOUSEY, (WORD) wparam, RB_DEFAULT); else if( msg == WM_RBUTTONDOWN) hr = OnTxRButtonDown(MOUSEX, MOUSEY, (WORD) wparam); break; #endif case EM_INSERTTABLE: lres = hr = OnInsertTable((TABLEROWPARMS *)wparam, (TABLECELLPARMS *)lparam, publdr); break; case EM_REPLACESEL: wparam = wparam ? ST_CHECKPROTECTION | ST_SELECTION | ST_KEEPUNDO : ST_CHECKPROTECTION | ST_SELECTION; hr = SetText((LPTSTR)lparam, wparam, 1200, publdr, &lres); break; case EM_REQUESTRESIZE: hr = _pdp->RequestResize(); break; case EM_SCROLL: // TxVScroll returns the number of lines scrolled; // this info should be returned in lres lres = _pdp->VScroll((WORD)wparam, 0); break; case EM_SCROLLCARET: OnScrollCaret(); break; case EM_SELECTIONTYPE: { SELCHANGE selchg; GetSel()->SetSelectionInfo(&selchg); lres = selchg.seltyp; } break; case EM_SETTYPOGRAPHYOPTIONS: // Don't allow typography options for password & accelerator instances hr = OnSetTypographyOptions(wparam, lparam); lres = (hr == S_OK); break; case EM_SETBIDIOPTIONS: if((Get10Mode() || !wparam) && lparam && !IsRich()) { WORD wMask = ((BIDIOPTIONS *)lparam)->wMask; WORD wEffects = (_fNeutralOverride ? BOE_NEUTRALOVERRIDE : 0) | (_nContextDir == CTX_NONE ? 0 : BOE_CONTEXTREADING) | (_nContextAlign == CTX_NONE ? 0 : BOE_CONTEXTALIGNMENT); wEffects &= ~wMask; wEffects |= (wMask & ((BIDIOPTIONS *)lparam)->wEffects); if (_fNeutralOverride != !!(wEffects & BOE_NEUTRALOVERRIDE)) { _fNeutralOverride = !_fNeutralOverride; if (!_pdp->IsPrinter()) // Refresh display { _pdp->InvalidateRecalc(); TxInvalidate(); } } _nContextDir = (WORD)((wEffects & BOE_CONTEXTREADING) ? CTX_NEUTRAL : CTX_NONE); _nContextAlign = (WORD)((wEffects & BOE_CONTEXTALIGNMENT) ? CTX_NEUTRAL : CTX_NONE); if(_nContextDir != CTX_NONE || _nContextAlign != CTX_NONE) { SetContextDirection(TRUE); Assert(_nContextDir != CTX_NONE || _nContextAlign != CTX_NONE); } } break; case WM_SETFOCUS: hr = OnSetFocus(); break; case EM_SETFONTSIZE: lres = OnSetFontSize(LONG(wparam), (DWORD)lparam, publdr); break; case EM_SETMODIFY: _fModified = wparam != 0; #ifdef LATER if (!_fModified) ObFreezeFrames(); #endif // LATER break; case EM_SETSCROLLPOS: { POINT *pPoint = (POINT*)lparam; _pdp->ScrollView(pPoint->x, pPoint->y, FALSE, TRUE); lres = 1; } break; case EM_EXSETSEL: // EM_EXSETSEL duplicates the functionality of the 32-bit EM_SETSEL // and exists purely for backward compatibility with Win16. We just // repackage the params and fall thru to EM_SETSEL wparam = (WPARAM)((CHARRANGE *)lparam)->cpMin; lparam = (LPARAM)((CHARRANGE *)lparam)->cpMost; // FALL-THROUGH to EM_SETSEL!!! case EM_SETSEL: lres = OnSetSel((LONG)wparam, (LONG)lparam); break; // INCREDIBLY EVIL HACK ALERT!!!!! Win95's dialog manager doesn't even // pretend to be 32 bits despite the best attempts of our marketing dudes. // WM_USER + 1 is the old Win3.0 EM_SETSEL in which the selection range // was packed into the lparam. // // Sometimes (like tabbing through a dialog), Win95 will send us the 16 // bit EM_SETSEL message, so process it here. case (WM_USER + 1): lres = OnSetSel(LOWORD(lparam), HIWORD(lparam)); break; case EM_SETTARGETDEVICE: // Keep width sane so that LXtoDX works OK at least for displays // Note that 0x7fffff = 485 feet! This keeps LXtoDX working provided // _xPerInch < 257 (it's typically 96 for displays). For more // generality, we'd need to use 64-bit arithmetic (see LXtoDX). lparam = min(lparam, (LPARAM)0x7fffff); lres = _pdp->SetMainTargetDC((HDC)wparam, (LONG)lparam); break; case EM_SETTEXTEX: hr = SetText((LPTSTR)lparam, ((SETTEXTEX *)wparam)->flags, ((SETTEXTEX *)wparam)->codepage, publdr, &lres); break; case WM_SETTEXT: hr = SetText((LPTSTR)lparam, ST_CHECKPROTECTION, wparam ? wparam : 1200, publdr, &lres); break; case EM_SETVIEWKIND: hr = SetViewKind(wparam); break; #ifndef NOWORDBREAKPROC case EM_SETWORDBREAKPROC: _fExWordBreakProc = 0; _pfnWB = (EDITWORDBREAKPROC) lparam; break; case EM_SETWORDBREAKPROCEX: // We don't support this API in 2.0 and greater because we pass // UNICODE text to the callback function. Therefore there // are no benefits to this API. Exists for 1.0 backward // compatibility only. if (Get10Mode()) { _fExWordBreakProc = 1; // This is a bit deceiving, but lparam is a EDITWORDBREAKPROCEX but the compiler // will generate an error if you try to type cast the l-value _pfnWB = (EDITWORDBREAKPROC) lparam; } break; #endif case WM_SYSCHAR: lres = hr = OnTxSysChar((WORD)wparam, (DWORD)lparam, publdr); if(hr == S_OK) break; goto def; case WM_SYSKEYUP: if(IN_RANGE(VK_SHIFT, wparam, VK_MENU)) ResetKeyboardFlag(GetKbdFlags((WORD)wparam, (DWORD)lparam)); if (IN_RANGE(VK_NUMPAD0, wparam, VK_NUMPAD9) || wparam == VK_CLEAR || wparam == VK_INSERT || IN_RANGE(VK_PRIOR, wparam, VK_DOWN)) { // Collect AltNumPad number to word around NT 4 bug and // generalize to any Unicode value (in decimal, ugh!) const static BYTE VkeyNumbers[] = {VK_NUMPAD9, VK_NUMPAD3, VK_NUMPAD1, VK_NUMPAD7, VK_NUMPAD4, VK_NUMPAD8, VK_NUMPAD6, VK_NUMPAD2, 0, 0, 0, 0, VK_NUMPAD0}; // Flag Alt NumPad char typed to SetKeyboardFlag(ALTNUMPAD); // distinguish hiANSI from lead if(!IN_RANGE(VK_NUMPAD0, wparam, VK_NUMPAD9)) // byte in Win3.1 IME { // Collect AltNumPad number if(wparam == VK_CLEAR) // NumLock not active: translate wparam = VK_NUMPAD5; // to digit codes else wparam = VkeyNumbers[wparam - VK_PRIOR]; } DWORD dwNum = GetKeyPadNumber(); if(!dwNum && wparam == VK_NUMPAD0) SetKeyboardFlag(ALT0); // Flag that 0 is first digit SetKeyPadNumber(10*dwNum + wparam - VK_NUMPAD0); } goto def; case WM_SYSKEYDOWN: if(OnTxSysKeyDown(wparam, lparam, publdr) == S_OK) { lres = TRUE; break; } goto def; case WM_TIMER: OnTxTimer((UINT)wparam); goto def; case EM_UNDO: case WM_UNDO: if (!_fReadOnly) { hr = PopAndExecuteAntiEvent(_pundo, (void*)wparam); if(hr == NOERROR) lres = TRUE; } break; case EM_REDO: if (!_fReadOnly) { hr = PopAndExecuteAntiEvent(_predo, (void*)wparam); if(hr == NOERROR) lres = TRUE; } break; case EM_SETUNDOLIMIT: lres = HandleSetUndoLimit((DWORD)wparam); break; case WM_VSCROLL: // TxVScroll returns the number of lines scrolled; // WM_VSCROLL doesn't care about that info however. Assert(lres == 0); Assert(hr == NOERROR); if (IsUVerticalTflow(_pdp->GetTflow())) _pdp->UScroll(LOWORD(wparam), HIWORD(wparam)); else _pdp->VScroll(LOWORD(wparam), HIWORD(wparam)); break; case EM_GETHYPHENATEINFO: { HYPHENATEINFO *phyphinfo = (HYPHENATEINFO*) wparam; if (phyphinfo->cbSize >= sizeof(HYPHENATEINFO)) { phyphinfo->pfnHyphenate = _pfnHyphenate; phyphinfo->dxHyphenateZone = _dulHyphenateZone; } else hr = E_INVALIDARG; } break; case EM_SETHYPHENATEINFO: { HYPHENATEINFO *phyphinfo = (HYPHENATEINFO*) wparam; if (phyphinfo->cbSize >= sizeof(HYPHENATEINFO)) { BOOL fRedraw = FALSE; if (phyphinfo->pfnHyphenate != _pfnHyphenate || _pfnHyphenate && _dulHyphenateZone != phyphinfo->dxHyphenateZone) fRedraw = TRUE; _pfnHyphenate = phyphinfo->pfnHyphenate; _dulHyphenateZone = _pfnHyphenate ? phyphinfo->dxHyphenateZone : 0; if (fRedraw) _pdp->UpdateView(); } else hr = E_INVALIDARG; } break; case EM_GETAUTOCORRECTPROC: { if (_pDocInfo) lres = (LRESULT) _pDocInfo->_pfnAutoCorrect; } break; case EM_SETAUTOCORRECTPROC: { CDocInfo *pDocInfo = GetDocInfo(); if (pDocInfo) pDocInfo->_pfnAutoCorrect = (AutoCorrectProc) wparam; else; lres = TRUE; } break; // Old stuff that's no longer supported case EM_FMTLINES: // Controls returning CRCRLFs for soft // line breaks in EM_GETTEXT. Could // implement case WM_GETFONT: // Can support but have to hang onto a // default HFONT. CCcs has an _hfont, but // need to be sure default font is in // cache at time of return #ifdef EM_GETHANDLE case EM_GETHANDLE: // Not supported by Win95 32-bit MLE either case EM_SETHANDLE: // Not supported by Win95 32-bit MLE either #endif #ifdef DEBUG TRACEINFOSZ("Old message that is no longer supported."); #endif break; case EM_SETTABSTOPS: { // this message only works for multi-line edit controls if(!_pdp->IsMultiLine()) break; // perform some validation checks Assert(lparam || !wparam); LPDWORD prgdwdlgCoord = (LPDWORD)lparam; if (wparam && (!prgdwdlgCoord || !(*prgdwdlgCoord))) break; AssertSz(wparam <= MAX_TAB_STOPS, "Tab stop count beyond maximum allowed"); if (wparam > MAX_TAB_STOPS) wparam = MAX_TAB_STOPS; PARAFORMAT2 pf; ZeroMemory(&pf, sizeof(PARAFORMAT2)); pf.cbSize = sizeof(PARAFORMAT2); // contains the average width for the default font LONG lAvgWidth; //Average char width based on default font HDC hdc = _phost->TxGetDC(); GetECDefaultHeightAndWidth(this, hdc, 1, 1, W32->GetYPerInchScreenDC(), &lAvgWidth, NULL, NULL); _phost->TxReleaseDC(hdc); Assert(lAvgWidth); // According to documentation wparam == 1 means the tab settings // will be set at incremental positions *prgdwdlgCoord and wparam == 0 // the tab settings will be set at the default incremental position 32 (dialog coord) long lTab = (wparam) ? *prgdwdlgCoord : 32; long nCt = (wparam <= 1) ? MAX_TAB_STOPS : (signed)wparam; for (int i = 0; i < nCt; i++) { long lval; lval = (wparam <= 1) ? ((i+1) * lTab) : *prgdwdlgCoord; pf.rgxTabs[i] = MulDiv(MulDiv(lval, lAvgWidth, 4), 1440, W32->GetXPerInchScreenDC()); if((unsigned)pf.rgxTabs[i] > 0xFFFFFF) // Keep in range pf.rgxTabs[i] = 0xFFFFFF; prgdwdlgCoord++; } // Set the default paragraph formatting pf.cTabCount = nCt; pf.dwMask = PFM_TABSTOPS; CParaFormat PF; PF.Set(&pf); // Need to turn off group typing just like the selection would. if (publdr) publdr->StopGroupTyping(); lres = OnSetParaFormat(SPF_SETDEFAULT, &PF, publdr, PFM_TABSTOPS, PFM2_PARAFORMAT); GetTabsCache()->Release(PF._iTabs); break; } case EM_SETCHARFORMAT: { CHARFORMAT2 *pCF2 = (CHARFORMAT2 *)lparam; UINT CodePage = 1200; DWORD dwMask = pCF2->dwMask; DWORD dwMask2 = 0; if(!IsValidCharFormatW(pCF2)) { if(!IsValidCharFormatA((CHARFORMAT2A *)lparam)) break; if(dwMask & CFM_FACE) // Need to convert to Unicode CodePage = GetDefaultCodePage(EM_SETCHARFORMAT); } if(dwMask & CFM_CHARSET && CharRepFromCharSet(pCF2->bCharSet) < 0) dwMask &= ~CFM_CHARSET; if(wparam & (SCF_ASSOCIATEFONT | SCF_ASSOCIATEFONT2)) { lres = OnSetAssociateFont(pCF2, (DWORD)wparam); break; } if(Get10Mode() && (dwMask & CFM_SIZE) && (pCF2->yHeight <= 0)) { // 1.0 has a hack where if the height is being set and it is // negative, then the height field is ignored. dwMask &= ~CFM_SIZE; } if (pCF2->cbSize == sizeof(CHARFORMATW) || pCF2->cbSize == sizeof(CHARFORMATA)) { // Restrict specifications to CHARFORMAT parameters. If the // host isn't our Windows host, we allow this to include the // CHARFORMAT2 disabled effect, since Forms^3 wanted that effect // but wasn't willing to use CHARFORMAT2 (even tho they asked // for it...) dwMask &= fInOurHost() ? CFM_ALL : (CFM_ALL | CFM_DISABLED); dwMask2 = CFM2_CHARFORMAT; // Tell callees that CHARFORMAT } // was used CCharFormat CF; // Transfer external CHARFORMAT(2) CF.Set(pCF2, CodePage); // parms to internal CCharFormat lres = OnSetCharFormat(wparam, &CF, publdr, dwMask, dwMask2); break; } case WM_SETFONT: lres = OnSetFont((HFONT)wparam); break; case EM_SETPAGE: if(_pdp) hr = _pdp->SetPage(wparam); break; case EM_SETPARAFORMAT: { PARAFORMAT2 *pPF2 = (PARAFORMAT2 *)lparam; if(!IsValidParaFormat(pPF2)) break; DWORD dwMask = pPF2->dwMask; // Two more things to validate: (1) We don't let an applications set // up tables and (2) Tabs coming from applications must be valid. if(dwMask & (PFM_TABLE | PFM_TABLEROWDELIMITER | PFM_OUTLINELEVEL | PFM_COLLAPSED)) { // Trying to set up a table or outline view break; } if ((dwMask & PFM_TABSTOPS) && (pPF2->cTabCount != 0)) { // Make sure all submitted tabstops make sense. int iMax = min(MAX_TAB_STOPS, pPF2->cTabCount); for (int i = 0; i < iMax; i++) { // Make sure that tab stops make sense - make sure alignment // is valid. if (GetTabAlign(pPF2->rgxTabs[i]) > tomAlignBar) { // Invalid alignment. break; } } if (i != iMax) { // Found error in validation loop so we are done. break; } } DWORD dwMask2 = 0; if(pPF2->cbSize == sizeof(PARAFORMAT)) { dwMask &= PFM_ALL; // Restrict to PARAFORMAT parms dwMask2 = PFM2_PARAFORMAT; // Tell callees that } // PARAFORMAT was used CParaFormat PF; // Transfer external PARAFORMAT(2) PF.Set(pPF2); // parms to internal CParaFormat lres = OnSetParaFormat(wparam, &PF, publdr, dwMask, dwMask2); GetTabsCache()->Release(PF._iTabs); break; } case EM_SETZOOM: if ((unsigned)(wparam | lparam) < 65536 && (!(wparam | lparam) || (LONG)wparam < (lparam << 6) && lparam < (LONG)(wparam << 6))) { // Only get here if // 1) 0 <= wparam <= 65535 and 0 <= lparam <= 65535, and // 2) either wparam = lparam = 0 (which turns off zooming by this // message) or 1/64 < (zoom factor given by wparam/lparam) < 64. SetZoomNumerator(wparam); SetZoomDenominator(lparam); _pdp->UpdateView(); lres = 1; } break; case EM_STREAMIN: case EM_STREAMOUT: { CTxtRange rg(this, 0, -GetTextLength()); CTxtRange * prg = &rg; // Default whole doc wparam = W32->ValidateStreamWparam(wparam); if(wparam & SFF_SELECTION) // Save to current selection { prg = (CTxtRange *)GetSel(); AssertSz(prg, "EM_STREAMIN/OUT: requested selection doesn't exist"); } else if(msg == EM_STREAMIN) { // If we are not streaming into the selection, then we are // "loading" the entire file; this is not an undo-able operation, // so set the undo builder to NULL and get rid of the current // undo stacks publdr = NULL; ClearUndo(&undobldr); // Clear away the file info if necessary if(!(wparam & SFF_KEEPDOCINFO)) CloseFile(FALSE); } if(msg == EM_STREAMIN) { // If we are going to be loading an entire file, we only // want to check "normal' protection; we can ignore the // fIsDBCS protection. This does mean that somebody // can do an "insert file" and break apart a DBCS combo, // but we'll have to live with that. Outlook uses // RTF streaming in many different places, so the strong // fIsDBCS protection breaks them. if ((_dwEventMask & ENM_PROTECTED) && prg->IsProtected(CHKPROT_EITHER) == PROTECTED_ASK && QueryUseProtection(prg, msg, wparam, lparam)) { Beep(); Assert(lres == 0); break; } // Freeze the display before loading CFreezeDisplay fd(_pdp); lres = _ldte.LoadFromEs(prg, wparam, (EDITSTREAM *)lparam, FALSE, publdr); if (_fOutlineView) { // Outline view must have formatting. _psel->Check_rpPF(); } if (_fFocus) { // Update caret but delay till display is thawed and do so only // if we have the focus. If we do this all the time we get wierd // scrolling effects such as scrolling to the beginning of a // document when the focus is set. See bug #1649 for repro of // wierd effects. _pdp->SaveUpdateCaret(TRUE); } } else lres = _ldte.SaveToEs (prg, wparam, (EDITSTREAM *)lparam); break; } #ifdef WM_SYSCOLORCHANGE case WM_SYSCOLORCHANGE: #ifndef NODRAFTMODE if (_fDraftMode) { W32->InitSysParams(TRUE); _pdp->InvalidateRecalc(); } #endif TxInvalidate(); break; #endif // debug stuff #if defined(DEBUG) && !defined(NOFULLDEBUG) case EM_DBGPED: OnDumpPed(); break; #endif // DEBUG case EM_SETEVENTMASK: lres = _dwEventMask; // Set up to return value before _dwEventMask = (DWORD)lparam; // the change if (lparam & ENM_REQUESTRESIZE) { // We need to update the display just in case it changes. _pdp->UpdateView(); } break; case EM_GETEVENTMASK: lres = _dwEventMask; break; #ifdef EM_GETTHUMB case EM_GETTHUMB: LONG Pos; BOOL fIsEnabled; if (TxGetVScroll(NULL, NULL, &Pos, NULL, &fIsEnabled) == S_OK && fIsEnabled) { lres = Pos; } break; #endif case EM_SETLANGOPTIONS: _fAutoFont = (lparam & IMF_AUTOFONT) != 0; _fAutoKeyboard = (lparam & IMF_AUTOKEYBOARD) != 0; _fAutoFontSizeAdjust = (lparam & IMF_AUTOFONTSIZEADJUST) != 0; _fDualFont = (lparam & IMF_DUALFONT) != 0; _fUIFont = (lparam & IMF_UIFONTS) != 0; lres = 1; break; case EM_GETLANGOPTIONS: if(_fAutoFont) lres |= IMF_AUTOFONT; if(_fAutoKeyboard) lres |= IMF_AUTOKEYBOARD; if(_fAutoFontSizeAdjust) lres |= IMF_AUTOFONTSIZEADJUST; if(_fDualFont) lres |= IMF_DUALFONT; if(_fUIFont) lres |= IMF_UIFONTS; break; case EM_SETEDITSTYLE: if (!Get10Mode()) // Not support in 1.0 mode { BOOL fForceRepaint = FALSE; DWORD dwEditStyle = _dwEditStyle & ~lparam; // Kill current flag values // Change following mask to give the largest SES_xxx defined) dwEditStyle |= wparam & lparam & (SES_CTFALLOWPROOFING*2 - 1); // Or in new values // Certain bits aren't switchable dwEditStyle |= (_fSystemEditMode ? SES_EMULATESYSEDIT : 0); _dwEditStyle = dwEditStyle; // There are certain things which we won't allow user to reset, ie SES_EMULATESYSEDIT. // So reset everything and except for the SES_EMULATESYSEDIT if(dwEditStyle & SES_EMULATESYSEDIT) { if(SUCCEEDED(HandleSetTextMode(TM_SINGLELEVELUNDO | TM_PLAINTEXT))) { // SES_EMULATESYSEDIT implies SES_BEEPONMAXTEXT _fSystemEditBeep = TRUE; } else _fSystemEditMode = FALSE; } #ifndef NODRAFTMODE // Repaint and recalc if draft mode is turned on or off if (lparam & SES_DRAFTMODE) fForceRepaint = TRUE; #endif if (fForceRepaint || (lparam & SES_USEATFONT)) { _pdp->InvalidateRecalc(); TxInvalidate(); } if(dwEditStyle & SES_BIDI) OrCharFlags(FRTL, publdr); _fLowerCase = !_fUpperCase && (dwEditStyle & SES_LOWERCASE); } // Fall thru to EM_GETEDITSTYLE // to return _bEditStyle case EM_GETEDITSTYLE: if (!Get10Mode()) // Not support in 1.0 mode lres |= _dwEditStyle; // Some EditStyles have been filled in Cmsgflt break; case EM_SETPAGEROTATE: lres = HandleSetTextFlow(wparam); break; case EM_GETPAGEROTATE: lres = _pdp->GetTflow(); break; case EM_SETTEXTMODE: // 1.0 mode does not supported EM_SETTEXTMODE if (!Get10Mode()) lres = HandleSetTextMode(wparam); break; case EM_GETTEXTMODE: lres = IsRich() ? TM_RICHTEXT : TM_PLAINTEXT; lres |= (_pundo && ((CUndoStack *)_pundo)->GetSingleLevelMode()) ? TM_SINGLELEVELUNDO : TM_MULTILEVELUNDO; lres |= _fSingleCodePage ? TM_SINGLECODEPAGE : TM_MULTICODEPAGE; break; case EM_LIMITTEXT: lparam = wparam; // Intentionally fall through. These messages are duplicates. But // Win9x manages to convert wparam = 0x3FFFFFFF to 0xFFFFFFFF. No // such problem exists with EM_EXLIMITTEXT. case EM_EXLIMITTEXT: // Has cp input parameter (sort of) if(!lparam) // We ignore translation between { // acp and cp // 0 means set the control to the maximum size. However, because // 1.0 set this to 64K will keep this the same value so as not to // surprise anyone. Apps are free to set the value to be above 64K. lparam = (LPARAM)cResetTextMax; } if (Get10Mode()) { // 1.0 used a signed variable to hold the length of the string. So // if lparam is negative then just set lparam to zero to emulate // 1.0 behavior if ((LONG)lparam < 0) lparam = 0; } _cchTextMost = (LONG)lparam; break; case EM_AUTOURLDETECT: if(lparam || (wparam | 1) != 1) { hr = lres = E_INVALIDARG; break; } if(wparam == TRUE && !_pdetecturl) { _pdetecturl = new CDetectURL(this); if(!_pdetecturl) hr = lres = E_OUTOFMEMORY; } else if(!wparam && _pdetecturl) { delete _pdetecturl; _pdetecturl = NULL; } break; case EM_GETAUTOURLDETECT: Assert(lres == 0 && hr == NOERROR); if(_pdetecturl) lres = TRUE; break; case WM_SIZE: // We reset the "number of tries to put an active object // in place" count here _cActiveObjPosTries = MAX_ACTIVE_OBJ_POS_TRIES; hr = S_FALSE; break; case WM_SETTINGCHANGE: // System parameters have changed. We need to update them. // Note : Since we don't protect access to system parameters // with locks, it may be possible for some instances to not // see the changes immediately lres = 0; W32->InitSysParams(TRUE); #ifndef NODRAFTMODE if (_fDraftMode) { _pdp->InvalidateRecalc(); TxInvalidate(); } #endif #ifndef NOCOMPLEXSCRIPTS if (W32->GetDigitSubstitutionMode() != DIGITS_NOTIMPL) OrCharFlags(FRTL, publdr); #endif break; case EM_CONVPOSITION: if (wparam) lres = GetCpFromAcp(lparam); else lres = GetAcpFromCp(lparam); break; #ifndef NOPRIVATEMESSAGE case EM_INSERTOBJ: { // This message supports Cicero InsertEmbedded int cpMin = ((CHARRANGE *)wparam)->cpMin; int cpMost = ((CHARRANGE *)wparam)->cpMost; CTxtRange rg(this, cpMin, cpMin - cpMost); REPASTESPECIAL rps; // @parm Special paste info rps.dwAspect = DVASPECT_CONTENT; hr = S_FALSE; if (!rg.WriteAccessDenied()) hr = _ldte.CreateOleObjFromDataObj((IDataObject *)lparam, &rg, &rps, iEmbObj, publdr); } break;; case EM_SETCALLBACK: // Setup message filter callback _pMsgCallBack = (CMsgCallBack *)lparam; break; case EM_SETUPNOTIFY: if (!_pMsgNotify) _pMsgNotify = new CTextNotify(this); if (_pMsgNotify) { if (wparam == 0) _pMsgNotify->Remove((ITxNotify *)lparam); else _pMsgNotify->Add((ITxNotify *)lparam); } break; case EM_GETDOCFLAGS: lres = 0; if (_fReadOnly) lres |= GDF_READONLY; if (_fOverstrike) lres |= GDF_OVERTYPE; if (_fSingleCodePage) lres |= GDF_SINGLECPG; if (_fRich) lres |= GDF_RICHTEXT; lres &= wparam; break; case EM_GETPARATXTFLOW: { CTxtPara *pTxtPara = (CTxtPara *)lparam; lres = pTxtPara->_PF.IsRtlPara(); break; } #endif #ifndef NOACCESSIBILITY case WM_GETOBJECT: { IUnknown* punk = NULL; lres = 0; if (lparam == OBJID_NATIVEOM) { QueryInterface(IID_IUnknown, (void**)&punk); // Need to expose Tom interdface } else if (lparam == OBJID_CLIENT && _fInOurHost) { HWND hwnd = NULL; TxGetWindow( &hwnd ); if (hwnd) W32->CreateStdAccessibleProxyW(hwnd, L"RichEdit", OBJID_CLIENT, IID_IAccessible, (void**)&punk); } if (punk) { lres = W32->LResultFromObject(IID_IUnknown, wparam, (LPUNKNOWN)punk); punk->Release(); } break; } #endif default: def: hr = S_FALSE; break; } if(plresult) *plresult = lres; #ifndef NOFEPROCESSING if (hr == S_FALSE && _pMsgFilter && _pMsgCallBack) { HWND hWnd; TxGetWindow(&hWnd); hr = _pMsgCallBack->HandlePostMessage(hWnd, msg, wparam, lparam, plresult); } #endif return hr; } /* * CTxtEdit::TxDraw (dwDrawAspect, lindex, pvAspect, ptd, hdcDraw, * hicTargetDev, lprcBounds, lprcWBounds, lprcUpdate, * pfnContinue, dwContinue) * * @mfunc Draws the text services object * * @rdesc HRESULT (typically S_OK). * * @comm * * This method renders the Text Services. It accepts the same parameters * as the corresponding IViewObject::Draw method in OLE, with the extra *

parameter. It can be used while the host is inactive * or active (in-place). * * If dwDrawAspect is DVASPECT_CONTENT, this method should render a screen * image of the text content to the hdcDraw device context. The hicTargetDev * and ptd parameters give information on the target device context if any * (usually a printer). * * The lprcClient parameter gives the rectangle to render to, also called * "client rectangle". This rectangle represents the position and extents * of the entire image of the Text Services to be drawn. It is expressed in * the logical coordinate system of hdcDraw. This parameter can only be NULL * if the control is active. In that case, Text Services should render the * in-place active view (which client rectangle can be obtained by calling * TxGetClientRect on the host). * * The lprcUpdate parameter, if not NULL, gives the rectangle to update * inside that client rectangle. It is given in the logical coordinate system * of hdcDraw. If NULL, the entire client rectangle should be painted. * * Text Services should render with the appropriate zooming factor, which * can be obtained from the client rect and the native size given by * ITextHost::TxGetExtent. For more information, see ITextHost::TxGetExtent. * * If the drawing aspect is DVASPECT_DOCPRINT, the TxDraw method can assume * that it is rendering to the printer. In that case, hdcDraw is the printer * device context. TxDraw should still render the lprcBounds rectangle, * starting at the current scrolling position. TS can make optimization for * rendering to the printer (like not painting the background color if white) * and certain screen specific elements (such as the selection) should not be * rendered. * * General comments on OLE hosts and TxDraw (and TxSetCursor, TxQueryHitPoint): * * OLE hosts can call the TxDraw method at any time with any rendering DC or * client rectangle. All an inactive OLE object has on a permanent basis is * a himetric extent. It gets the rectangle in which to render only via the * IViewObject::Draw call and this rectangle is valid only for the scope of * that method. In fact, the same control can be rendered consecutively in * different rectangles and different DCs for example because it is displayed * simultaneously in different views on the screen. * * The client rectangle and DC passed to TxDraw should normally not be cached. * However, this would force Text Services to recalc lines for every single * draw, which would lead to terrible performance. So it is likely that Text * Services will actually cache some information computed for a specific * client rectangle and DC (such as the line breaks for example). On the * next call to TxDraw, however, the validity of the cached information * should be checked before it gets used, and updated information should be * regenerated if necessary. * * When the control is in-place active, the problem is even more complex * since TxDraw can still be called to render other views than the in-place * active one. In other words, the client rectangle passed to TxDraw may * not be the same as the active view one (passed to OnTxInPlaceActivate * and obtained via TxGetClientRect on the host).The the host specifies * what view they wish to display based on the lViewId parameter. If the * value for lViewId is TXTVIEW_ACTIVE, the view referred to is the inplace * active view. TXTVIEW_INACTIVE means some other view such as a print * preview or even printing itself. It is important to note that * TXTVIEW_INACTIVE views may not have scroll bars. * * The same comments apply to TxSetCursor and TxQueryHitPoint, discussed * in the following sections. */ HRESULT CTxtEdit::TxDraw( DWORD dwDrawAspect, //@parm Draw aspect LONG lindex, //@parm Currently unused void * pvAspect, //@parm Info for drawing optimizations (OCX 96) DVTARGETDEVICE *ptd, //@parm Info on target device HDC hdcDraw, //@parm Rendering device context HDC hicTargetDev, //@parm Target information context LPCRECTL lprcBounds, //@parm Bounding (client) rectangle LPCRECTL lprcWBounds, //@parm Clipping rect for metafiles LPRECT lprcUpdate, //@parm Dirty rectangle inside lprcBounds BOOL (CALLBACK * pfnContinue) (DWORD), //@parm Callback for interupting // long display (currently unused) DWORD dwContinue, //@parm Parameter to pass to pfnContinue function LONG lViewId) //@parm View identifier { TRACEBEGIN(TRCSUBSYSTS, TRCSCOPEEXTERN, "CTxtEdit::TxDraw"); HRESULT hr; // JMO : FUTURE : We should do something about reentrant draws sometime. // If we do that may procide a simpler fix for RAID bug 7212. #if !defined(NOMAGELLAN) CMagellanBMPStateWrap bmpOff(*this, hdcDraw); #endif CCallMgr callmgr(this); START_PROFILING { CLock lock; if (g_OLSBusy) return E_UNEXPECTED; } // If the display is frozen, don't let ourselves draw. This is a pretty // hoaky re-entrancy check. // FUTURE (alexgo/ricksa): be better about this. if(TXTVIEW_ACTIVE == lViewId && _pdp->IsFrozen()) { _pdp->SetNeedRedisplayOnThaw(TRUE); TRACEINFOSZ("Forcing a redisplay on thaw"); return E_UNEXPECTED; } if(dwDrawAspect != DVASPECT_CONTENT && dwDrawAspect != DVASPECT_DOCPRINT) { // We don't support the aspect requested return DV_E_DVASPECT; } if(!lprcBounds && !_fInPlaceActive || hicTargetDev && !ptd) { // If we are not inplace active we must have a client rectangle return E_INVALIDARG; } HDC hicLocal = NULL; // Did they give us a ptd without a hic? if(!hicTargetDev && ptd) { // Create and information context for the device information // since it wasn't supplied. hicLocal = CreateIC( (TCHAR *)((BYTE *) ptd + ptd->tdDriverNameOffset), (TCHAR *)((BYTE *) ptd + ptd->tdDeviceNameOffset), (TCHAR *)((BYTE *) ptd + ptd->tdPortNameOffset), (DEVMODE *)((BYTE *) ptd + ptd->tdExtDevmodeOffset)); if(!hicLocal) return E_FAIL; // Couldn't create it hicTargetDev = hicLocal; } AssertSz(GetMapMode(hdcDraw) == MM_TEXT || GetDeviceCaps(hdcDraw, TECHNOLOGY) == DT_METAFILE, "RichEdit requires MM_TEXT."); // REVIEW (keithcu) Clients do (and should) use MM_TEXT // Preallocate the memory so the set cannnot fail and we don't // have to use the heap. Note that all clean up is handled // outside of this object. Also note that we don't assign any // information here because we may not use this structure. If // recursion is happening we will use the top level structure. CDrawInfo di(this); _pdp->SetDrawInfo( &di, dwDrawAspect, lindex, pvAspect, ptd, hicTargetDev); // We use our main display object if we are the active view (which is // indicate by the supplied client rectangle) or if the object is // inactive and the ptd is NULL. We assume that the ptd being NULL means // that the display request is for the screen and not for a print or // print preview. if(TXTVIEW_ACTIVE == lViewId || !ptd) { hr = S_FALSE; // The main display object draws active views and tries to draw // inactive views if the control is not active. if (!lprcWBounds && ( fInplaceActive() && TXTVIEW_ACTIVE == lViewId || !fInplaceActive() && TXTVIEW_INACTIVE == lViewId)) { hr = _pdp->Draw(hdcDraw, hicTargetDev, // We aren't interruptable (RECT *)lprcBounds, // drawing to screen, so (RECT *)lprcWBounds, // why pretend? lprcUpdate, NULL, 0); } if(S_FALSE == hr) { // This is an inactive view for which the cached state // does not match the input request so we make a special // object to do the drawing. CDisplay *pdp = _pdp->Clone(); if(pdp) { // Force recalc - this tells Draw to draw no matter what pdp->InvalidateRecalc(); hr = pdp->Draw(hdcDraw, hicTargetDev, // Do the draw (RECT *)lprcBounds, (RECT *)lprcWBounds, lprcUpdate, NULL, 0); } delete pdp; } } else { // Make a copy so that we can update it RECT rcForPrint = *((RECT *)lprcBounds); // We want data both formatted and printed hr = FormatAndPrint(hdcDraw, hicTargetDev, ptd, &rcForPrint, (RECT*)lprcWBounds); struct SPrintControl prtcon; // This call to OnFormatRange simply cleans up printer object OnFormatRange(NULL, prtcon); } _pdp->ReleaseDrawInfo(); if(hicLocal) // Clean up information context DeleteDC(hicLocal); // if we created one // An active OLE object might have been dragged/scrolled away // from where it belongs. We need to put it back. // The _cActiveObjPosTries guards us from an indefinite looop here // (OnReposition may post another paint message, and so on) // We only do this when we were notified of a position or size change COleObject* poleobjActive; if (HasObjects() && _cActiveObjPosTries && (poleobjActive = GetObjectMgr()->GetInPlaceActiveObject())) { // Reduce number of tries _cActiveObjPosTries--; // BUG FIX 6073 // Only fetch the extent if the object view size or position // has changed // Get new object size (we might have resized it, // and we don't want to lose that!!) if (poleobjActive->GetViewChanged()) { poleobjActive->FetchObjectExtents(); poleobjActive->ResetViewChanged(); } // and put it there!! poleobjActive->OnReposition(); } return hr; } /* * CTxtEdit::TxGetHScroll (plMin, plMax, plPos, plPage, pfEnabled) * * @mfunc * Get horizontal scroll bar state information * * @rdesc * HRESULT = S_OK */ HRESULT CTxtEdit::TxGetHScroll( LONG *plMin, //@parm Minimum scroll position LONG *plMax, //@parm Maximum scroll position LONG *plPos, //@parm Current scroll position LONG *plPage, //@parm View width in pixels BOOL *pfEnabled) //@parm Whether horizonatl scrolling is enabled. { TRACEBEGIN(TRCSUBSYSTS, TRCSCOPEEXTERN, "CTxtEdit::TxGetHScroll"); START_PROFILING if(plMin) *plMin = 0; if (IsUVerticalTflow(_pdp->GetTflow())) { if(plMax) *plMax = _pdp->GetScrollRange(SB_VERT); if(plPage) *plPage = _pdp->ConvertVPosToScrollPos(_pdp->GetDvpView()); if(plPos) { *plPos = _pdp->ConvertVPosToScrollPos(_pdp->GetVpScroll()); if (_pdp->GetTflow() == tflowSW) *plPos = *plMax - *plPos - *plPage; *plPos = max(*plPos, 0); } if(pfEnabled) *pfEnabled = _pdp->IsVScrollEnabled(); } else { if(plMax) *plMax = _pdp->GetScrollRange(SB_HORZ); if(plPos) *plPos = _pdp->GetUpScroll(); if(plPage) *plPage = _pdp->GetDupView(); // CDisplay::_fUScrollEnabled may be TRUE when not in-place active // because it has a dual meaning: 1) need Horiz scroll bars, and 2) // CDisplay::_upScroll is allowed for ES_AUTOHSCROLL even with no // horizontal scrollbar. The latter can turn on _fUScrollEnabled when // the control is active and when the control goes inactive, it stays // on, so we say it's off to keep Forms^3 from displaying a horizontal // scroll bar. We probably should have two flags: _fUScrollEnabled and // _fUScrollbarEnabled, but for now, we stick with one. No such problem // for vertical case, since vertical scrolling always uses a scrollbar. if(pfEnabled) *pfEnabled = _fInPlaceActive ? _pdp->IsUScrollEnabled() : 0; } return S_OK; } /* * CTxtEdit::TxGetVScroll (plMin, plMax, plPos, plPage, pfEnabled) * * @mfunc * Get vertical scroll bar state information * * @rdesc * HRESULT = S_OK */ HRESULT CTxtEdit::TxGetVScroll( LONG *plMin, //@parm Minimum scroll position LONG *plMax, //@parm Maximum scroll position LONG *plPos, //@parm Current scroll position LONG *plPage, //@parm Height of view in pixels BOOL *pfEnabled) //@parm Whether vertical scroll bar is enabled. { TRACEBEGIN(TRCSUBSYSTS, TRCSCOPEEXTERN, "CTxtEdit::TxGetVScroll"); if(plMin) *plMin = 0; if (IsUVerticalTflow(_pdp->GetTflow())) { if(plMax) *plMax = _pdp->GetScrollRange(SB_HORZ); if(plPos) *plPos = _pdp->GetUpScroll(); if(plPage) *plPage = _pdp->GetDupView(); if(pfEnabled) *pfEnabled = _fInPlaceActive ? _pdp->IsUScrollEnabled() : 0; } else { if(plMax) *plMax = _pdp->GetScrollRange(SB_VERT); if(plPos) *plPos = _pdp->ConvertVPosToScrollPos(_pdp->GetVpScroll()); if(plPage) *plPage = _pdp->ConvertVPosToScrollPos(_pdp->GetDvpView()); if(pfEnabled) *pfEnabled = _pdp->IsVScrollEnabled(); } return S_OK; } /* * CTxtEdit::OnTxSetCursor (dwDrawAspect, lindex, pvAspect, ptd, hdcDraw, * hicTargetDev, lprcClient, x, y) * @mfunc * Notification for text services to set the cursor * * @rdesc * HRESULT = FAILED(RectChangeHelper()) ? E_INVALIDARG : S_OK * * @comm * Text Services may remeasure as a result of this call in * order to determine the correct cursor. The correct * cursor will be set via ITextHost::TxSetCursor * * More details: * * The lprcClient parameter is the client rectangle of the view of the * control over which the mouse cursor is. It is in device coordinates * of the containing window in the same way the WM_SIZE message is. This * may not be the view that was rendered last. Furthermore, if the control * is in-place active, this may not be the view currently being active. * As a consequence, Text Services should check this rectangle against * its current caches values and determine whether recalcing the lines * is necessary or not. The zoom factor should be included in this * computation. * * This method should only be called for screen views of the control. * Therefore the DC is not passed in but should be assumed to be a screen * DC. * * The x and y parameters hold the cursor position in the same coordinate * system as lprcClient, i.e., the client coordinates of the containing * window. */ //REVIEW (keithcu) Do people really pass rectangles different from those //returned from TxGetClientRect? I'd be surprised if that happens, and if it did //who cares if we display the wrong cursor?? HRESULT CTxtEdit::OnTxSetCursor ( DWORD dwDrawAspect, //@parm Draw aspect LONG lindex, //@parm Currently unused void * pvAspect, //@parm Info for drawing optimizations (OCX 96) DVTARGETDEVICE *ptd, //@parm Info on target device HDC hdcDraw, //@parm Rendering device context HDC hicTargetDev, //@parm Target information context LPCRECT lprcClient, //@parm Control's client rectangle INT x, //@parm x position of cursor INT y) //@parm y position of cursor { TRACEBEGIN(TRCSUBSYSTS, TRCSCOPEEXTERN, "CTxtEdit::OnTxSetCursor"); CCallMgr callmgr(this); BOOL fText = FALSE; HITTEST Hit; RECT rcxyClient; BOOL fGotDC = FALSE; START_PROFILING if (_fInPlaceActive) TxGetClientRect(&rcxyClient); else if (lprcClient) rcxyClient = *lprcClient; else return E_INVALIDARG; if (!_pdp->IsValid()) { HDC hdc = GetDC(NULL); _pdp->SetDC(hdc); fGotDC = TRUE; } // Set the cursor CTxtSelection * const psel = GetSel(); HCURSOR hcurNew = _hcurArrow; // Default using system arrow POINT ptxy = {x, y}; POINTUV pt; RECTUV rcClient; BOOL fInLink = FALSE; _pdp->RectuvFromRect(rcClient, rcxyClient); _pdp->PointuvFromPoint(pt, ptxy); if(PtInRect(&rcxyClient, ptxy)) { // Find out what the cursor is pointing at _pdp->CpFromPoint(pt, &rcClient, NULL, NULL, FALSE, &Hit); if(Hit == HT_LeftOfText) hcurNew = _hcurSelBar; // This is a bit strange, but RichEdit 1.0 does this--give client a // chance to handle cursor itself if we are over a link. else if(Hit == HT_Link) { if(HandleLinkNotification(WM_SETCURSOR, 0, MAKELPARAM(ptxy.x, ptxy.y), &fInLink)) { return NOERROR; } hcurNew = _hcurHand; } else if(Hit != HT_Nothing && Hit != HT_OutlineSymbol && Hit != HT_BulletArea) { if(!psel || !psel->PointInSel(pt, &rcClient, Hit) || _fDisableDrag) { if (IsUVerticalTflow(_pdp->GetTflow())) hcurNew = (Hit == HT_Italic) ? _hcurVItalic : _hcurVIBeam; else hcurNew = (Hit == HT_Italic) ? _hcurItalic : _hcurIBeam; fText = TRUE; } // If we have an object manager and if there is a selected object, // check for hits on the frame handles. if(_pobjmgr) { COleObject *pobjselect = _pobjmgr->GetSingleSelect(); if(pobjselect) { // Handle hits on frame handles. LPTSTR idcur = pobjselect->CheckForHandleHit(pt); HCURSOR hcurObj = W32->GetSizeCursor(idcur); if(hcurObj) hcurNew = hcurObj; } } } } _phost->TxSetCursor(hcurNew, fText); // Tell host to set cursor if (fGotDC) { HDC hdc = _pdp->GetDC(); ::ReleaseDC(NULL, hdc); _pdp->SetDC(NULL); } return S_OK; } /* * CTxtEdit::TxQueryHitPoint (dwDrawAspect, lindex, pvAspect, ptd, hdcDraw, * hicTargetDev, lprcClient, x, y, pHitResult) * @mfunc * Returns whether point is within text services rectangle * * @rdesc * HRESULT * * @comm * This method allows the host to implement transparent hit-testing * on text. * * The lprcClient parameter is the client rectangle in device coordinates * of the view on which hit testing is performed. * * The pt parameter hold the position of the cursor in the same * coordinate system as the lprcClient rectangle (the client * coordinates of the containing window). * * Same general comments about client rectangle and DC as for * TxSetCursor apply. * * pHitResult returns one of the following values: * * 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"); RECTUV rcClient; RECT rcxyClient; CCallMgr callmgr(this); START_PROFILING if (_fInPlaceActive) TxGetClientRect(&rcxyClient); else if (lprcClient) rcxyClient = *lprcClient; else return E_INVALIDARG; HRESULT hr; POINT ptxy = {x, y}; POINTUV pt; _pdp->PointuvFromPoint(pt, ptxy); _pdp->RectuvFromRect(rcClient, rcxyClient); if(!_fTransparent) { *pHitResult = TXTHITRESULT_HIT; hr = S_OK; } else hr = _pdp->TransparentHitTest(hdcDraw, &rcxyClient, pt, pHitResult); return hr; } /* * CTxtEdit::OnTxInPlaceActivate (prcClient) * * @mfunc * Notifies text services that this control is inplace active * * @rdesc * S_OK - successfully activated object * 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"); RECTUV rcView; HDC hdc; BOOL fSucceeded = TRUE; CCallMgr callmgr(this); RECTUV rcClient; START_PROFILING // Needs to set here for further TxGetDC() to work _fInPlaceActive = TRUE; // Set rendering DC to be the screen hdc = TxGetDC(); if(!hdc) goto err; // Tell display that it is active _pdp->SetActiveFlag(TRUE); _pdp->SetDC(hdc); //REVIEW (keithcu) I removed prcClient usage here because it appears that //clients pass in wrong rectangles to OnTxInPlaceActivate. That is quite //scary--do they pass in wrong rectangles to other places? (We could see //weird results when not in-place active. If (as the comment says) the prcClient //should be the same as what would be gotten from the host, we will now just fetch //the value from the host rather than look at what is passed down. #if 1 prcClient = 0; #else if (prcClient) _pdp->RectuvFromRect(rcClient, *prcClient); //Verify the rectangle passed in is the same as what we'd fetch from //getting it from the client #ifdef DEBUG { RECT rcDebug; TxGetClientRect(&rcDebug); AssertSz(rcDebug.right - rcDebug.left == prcClient->right - prcClient->left && rcDebug.bottom - rcDebug.top == prcClient->bottom - prcClient->top, "CLIENT BUG: Inconsistent rectangles between ITextServices::" "OnTxInPlaceActivate(RECT*) and ITextHost::TxGetClientRect(RECT*)"); } #endif #endif // Compute view rect from passed in client rect _pdp->GetViewRect(rcView, prcClient ? &rcClient : 0); // Recalc/update view _pdp->RecalcView(rcView); // Get selection. Otherwise, if SetFocus is called later without // selection, then the Selection state is not set correctly. GetSel(); if(_pdp->GetDupView()) { // Get selection if we can if(_psel) // Set the caret _psel->Update(FALSE); else // Couldn't create selection, fSucceeded = FALSE; // so fail activation } // Release the DC TxReleaseDC(hdc); _pdp->SetDC(NULL); // If getting the selection worked we are home free if(fSucceeded) return S_OK; err: _fInPlaceActive = FALSE; return E_FAIL; } /* * CTxtEdit::OnTxInPlaceDeactivate() * * @mfunc Notifies text services that this is no longer in place active. * * @rdesc S_OK * * @comm See OnTxInPlaceActivate for a detailed description of * activation/deactivation. * * @xref * */ 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->GetUpCaretReally(); return S_OK; } /* * CTxtEdit::TxGetBaseLinePos(pBaseLinePos) * * @mfunc Get the base line position of the first visible line, in pixels, * relative the TS client rectangle. Needed for aligning controls on their * baselines. * * @rdesc HRESULT = E_NOTIMPL */ HRESULT CTxtEdit::TxGetBaseLinePos( LONG *pBaseLinePos) //@parm Where to return baseline position { TRACEBEGIN(TRCSUBSYSTS, TRCSCOPEEXTERN, "CTxtEdit::TxGetBaseLinePos"); return E_NOTIMPL; } /* * CTxtEdit::TxGetNaturalSize (dwAspect, hdcDraw, hicTargetDev, ptd, dwMode, * psizelExtent, pwidth, pheight) * * @mfunc Allow control to be resized so it fits content appropriately * * @rdesc S_OK * 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] { TRACEBEGIN(TRCSUBSYSTS, TRCSCOPEEXTERN, "CTxtEdit::TxGetNaturalSize"); HRESULT hr; CCallMgr callmgr(this); START_PROFILING if(dwAspect != DVASPECT_CONTENT && dwAspect != DVASPECT_DOCPRINT) { // We don't support the aspect requested return DV_E_DVASPECT; } if (hicTargetDev && !ptd || !pwidth || !pheight || !IN_RANGE(TXTNS_FITTOCONTENT2, dwMode, TXTNS_ROUNDTOLINE)) { // Either and information context is provided without the device // target or the mode is not valid or the width was not provided // or the height was not provided. In short, the input parameters // are not valid so tell the caller. return E_INVALIDARG; } if(!psizelExtent->cy) { // No extent for control, so just return 0 *pwidth = 0; *pheight = 0; return S_OK; } HDC hicLocal = NULL; // Did they give us a ptd without a hic? if(!hicTargetDev && ptd) { // Create and information context for the device information // since it wasn't supplied. hicLocal = CreateIC( (TCHAR *)((BYTE *) ptd + ptd->tdDriverNameOffset), (TCHAR *)((BYTE *) ptd + ptd->tdDeviceNameOffset), (TCHAR *)((BYTE *) ptd + ptd->tdPortNameOffset), (DEVMODE *)((BYTE *) ptd + ptd->tdExtDevmodeOffset)); if(!hicLocal) return E_FAIL; // Couldn't create it hicTargetDev = hicLocal; } // Convenient place to put height & width for converting them to // device units. POINT pt; pt.x = *pwidth; pt.y = *pheight; AssertSz(GetMapMode(hdcDraw) == MM_TEXT || GetDeviceCaps(hdcDraw, TECHNOLOGY) == DT_METAFILE, "RichEdit requires MM_TEXT."); // REVIEW (keithcu) Clients do (and should) use MM_TEXT // Set the extent information needed for zooming _pdp->SetTempZoomDenominator(psizelExtent->cy); if(TXTNS_ROUNDTOLINE == dwMode) { // Round to fit simply calculates the hr = _pdp->RoundToLine(hdcDraw, pt.x, &pt.y); } else { // Get natural size for entire presentation // Allocate memory for the draw information CDrawInfo di(this); // Set up the drawing parameters _pdp->SetDrawInfo( &di, dwAspect, -1, NULL, ptd, hicTargetDev); // Set the Draw DC _pdp->SetDC(hdcDraw); // Tell display to figure size needed for this display hr = _pdp->GetNaturalSize(hdcDraw, hicTargetDev, dwMode, &pt.x, &pt.y); _pdp->ResetDC(); // Restore state _pdp->ReleaseDrawInfo(); } if(SUCCEEDED(hr)) // Set return values if this worked { *pwidth = pt.x; // Update return values *pheight = pt.y; } if(hicLocal) // Clean up info context DeleteDC(hicLocal); // if we created one _pdp->ResetTempZoomDenominator(); // Reset temporary zoom factor return hr; } /* * CTxtEdit::TxGetDropTarget (ppDropTarget) * * @mfunc Get the drop target for the text control * * @rdesc * S_OK - Got drop target successfully * 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 NODRAGDROP TRACEBEGIN(TRCSUBSYSTS, TRCSCOPEEXTERN, "CTxtEdit::TxGetDropTarget"); HRESULT hr; CCallMgr callmgr(this); START_PROFILING hr = _ldte.GetDropTarget(ppDropTarget); if(hr == NOERROR) (*ppDropTarget)->AddRef(); return hr; #else return 0; #endif } /* * CTxtEdit::OnTxPropertyBitsChange (dwMask, dwBits) * * @mfunc Set properties that can be represented by bits. * * @rdesc HRESULT * * @comm The following property bits are understood: * * 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 (pdup, pdvp) * * @mfunc * Returns the cached drawing size (if any) that text services * is using. Typically, this will be the size of the last client * rect used in TxDraw, TxSetCursor, etc., although it is not * guaranteed to be. * * @rdesc * HRESULT * * @comm * This information is provided to allow the host to potentially * perform various optimizations, amongst other things. */ HRESULT CTxtEdit::TxGetCachedSize( DWORD *pdupClient, //@parm Where to put width (in client coords) DWORD *pdvpClient) //@parm Where to put height (in client coords) { TRACEBEGIN(TRCSUBSYSTS, TRCSCOPEEXTERN, "CTxtEdit::TxGetCachedSize"); return _pdp->GetCachedSize((long*) pdupClient, (long*) pdvpClient); } // Forward declaration of initialization helper. // These really should be in some header file. But which? // Currently the definitions are in dxfrobj.cpp and font.cpp void RegisterFETCs(); void InitFontCache(); /* * CreateTextServices (punkOuter, phost, ppserv) * * @func * Create an instance of the RichEdit Engine. This engine supports the * ITextServices and Microsoft Text Object Model (TOM) interfaces. * * @rdesc * S_OK - New text services instance created successfully. * 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; }