editec.c File Reference

#include "precomp.h"

Go to the source code of this file.

Classes
struct	EditMenuItemState
Defines
#define	umin(a, b)   ((unsigned)(a) < (unsigned)(b) ? (unsigned)(a) : (unsigned)(b))
#define	umax(a, b)   ((unsigned)(a) > (unsigned)(b) ? (unsigned)(a) : (unsigned)(b))
#define	UNICODE_CARRIAGERETURN   ((WCHAR)0x0d)
#define	UNICODE_LINEFEED   ((WCHAR)0x0a)
#define	UNICODE_TAB   ((WCHAR)0x09)
#define	ID_IMEOPENCLOSE   10001
#define	ID_SOFTKBDOPENCLOSE   10002
#define	ID_RECONVERTSTRING   10003
Functions
ICH	ECFindTabA (LPSTR lpstr, ICH cch)
ICH	ECFindTabW (LPWSTR lpstr, ICH cch)
PSTR	ECLock (PED ped)
void	ECUnlock (PED ped)
UINT	GetActualNegA (HDC hdc, PED ped, int x, LPSTR lpstring, ICH ichString, int nCount, LPSTRIPINFO NegAInfo)
BOOL	ECIsAncestorActive (HWND hwnd)
BOOL	ECSetIMEMenu (HMENU hMenu, HWND hwnd, EditMenuItemState state)
void	ECInOutReconversionMode (PED ped, BOOL fIn)
BOOL NEAR	ECDoIMEMenuCommand (PED ped, int cmd, HWND hwnd)
void	ECMenu (HWND hwnd, PED ped, LPPOINT pt)
void	ECClearText (PED ped)
void	ECCutText (PED ped)
int	ECGetModKeys (int keyMods)
UINT	ECTabTheTextOut (HDC hdc, int xClipStPos, int xClipEndPos, int xStart, int y, LPSTR lpstring, int nCount, ICH ichString, PED ped, int iTabOrigin, BOOL fDraw, LPSTRIPINFO NegCInfoForStrip)
ICH	ECCchInWidth (PED ped, HDC hdc, LPSTR lpText, ICH cch, int width, BOOL fForward)
HBRUSH	ECGetBrush (PED ped, HDC hdc)
void	NextWordCallBack (PED ped, ICH ichStart, BOOL fLeft, ICH *pichMin, ICH *pichMax)
void	NextWordLpkCallBack (PED ped, ICH ichStart, BOOL fLeft, ICH *pichMin, ICH *pichMax)
void	ECWord (PED ped, ICH ichStart, BOOL fLeft, ICH *pichMin, ICH *pichMax)
void	ECSaveUndo (PUNDO pundoFrom, PUNDO pundoTo, BOOL fClear)
void	ECEmptyUndo (PUNDO pundo)
void	ECMergeUndoInsertInfo (PUNDO pundo, ICH ichInsert, ICH cchInsert)\
BOOL	ECInsertText (PED ped, LPSTR lpText, ICH *pcchInsert)
ICH	ECDeleteText (PED ped)
void	ECNotifyParent (PED ped, int notificationCode)
void	ECSetEditClip (PED ped, HDC hdc, BOOL fLeftMargin)
HDC	ECGetEditDC (PED ped, BOOL fFastDC)
void	ECReleaseEditDC (PED ped, HDC hdc, BOOL fFastDC)
void	ECResetTextInfo (PED ped)
BOOL	ECSetText (PED ped, LPSTR lpstr)
void	ECInvalidateClient (PED ped, BOOL fErase)
ICH	ECCopy (PED ped)
LRESULT	EditWndProcA (HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
LRESULT	EditWndProcW (HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
LRESULT	EditWndProcWorker (PWND pwnd, UINT message, WPARAM wParam, LPARAM lParam, DWORD fAnsi)
LRESULT	EditWndProc (PWND pwnd, UINT message, WPARAM wParam, LPARAM lParam)
void	ECFindXORblks (LPBLOCK lpOldBlk, LPBLOCK lpNewBlk, LPBLOCK lpBlk1, LPBLOCK lpBlk2)
BOOL	ECCalcChangeSelection (PED ped, ICH ichOldMinSel, ICH ichOldMaxSel, LPBLOCK OldBlk, LPBLOCK NewBlk)
HBRUSH	ECGetControlBrush (PED ped, HDC hdc, LONG message)
UINT WINAPI	QueryFontAssocStatus (void)
int	ECGetDBCSVector (PED ped, HDC hdc, BYTE CharSet)
LPSTR	ECAnsiNext (PED ped, LPSTR lpCurrent)
LPSTR	ECAnsiPrev (PED ped, LPSTR lpBase, LPSTR lpStr)
ICH	ECNextIch (PED ped, LPSTR pStart, ICH ichCurrent)
ICH	ECPrevIch (PED ped, LPSTR pStart, ICH ichCurrent)
BOOL	ECIsDBCSLeadByte (PED ped, BYTE cch)
WORD	DbcsCombine (HWND hwnd, WORD ch)
ICH	ECAdjustIch (PED ped, LPSTR lpstr, ICH ch)
ICH FAR PASCAL	ECAdjustIchNext (PED ped, LPSTR lpstr, ICH ch)
void	ECUpdateFormat (PED ped, DWORD dwStyle, DWORD dwExStyle)
Variables
LOOKASIDE	EditLookaside
UINT	fFontAssocStatus = 0xffff

---

Define Documentation

#define ID_IMEOPENCLOSE   10001

Definition at line 31 of file editec.c. Referenced by ECDoIMEMenuCommand(), and ECSetIMEMenu().

#define ID_RECONVERTSTRING   10003

Definition at line 33 of file editec.c. Referenced by ECDoIMEMenuCommand(), and ECSetIMEMenu().

#define ID_SOFTKBDOPENCLOSE   10002

Definition at line 32 of file editec.c. Referenced by ECDoIMEMenuCommand(), and ECSetIMEMenu().

#define umax (  a, b   )     ((unsigned)(a) > (unsigned)(b) ? (unsigned)(a) : (unsigned)(b))

Definition at line 23 of file editec.c. Referenced by ECCchInWidth().

#define umin (  a, b   )     ((unsigned)(a) < (unsigned)(b) ? (unsigned)(a) : (unsigned)(b))

Definition at line 22 of file editec.c.

#define UNICODE_CARRIAGERETURN   ((WCHAR)0x0d)

Definition at line 25 of file editec.c.

#define UNICODE_LINEFEED   ((WCHAR)0x0a)

Definition at line 26 of file editec.c.

#define UNICODE_TAB   ((WCHAR)0x09)

Definition at line 27 of file editec.c.

---

Function Documentation

WORD DbcsCombine (  HWND  hwnd, WORD  ch )

Definition at line 4109 of file editec.c. References msg. Referenced by ComboBoxDBCharHandler(), MLChar(), SLChar(), and xxxLBoxCtlCharInput(). { MSG msg; int i = 10; /* loop counter to avoid the infinite loop */ while (!PeekMessageA(&msg, hwnd, WM_CHAR, WM_CHAR, PM_REMOVE)) { if (--i == 0) return 0; Sleep(1); } return (WORD)ch | ((WORD)(msg.wParam) << 8); }

ICH ECAdjustIch (  PED  ped, LPSTR  lpstr, ICH  ch )

Definition at line 4133 of file editec.c. References ECIsDBCSLeadByte(), tagED::fAnsi, tagED::fDBCS, and ICH. Referenced by ECAdjustIchNext(), ECCchInWidth(), ECInsertText(), MLBuildchLines(), MLDrawText(), MLInsertText(), MLMouseToIch(), MLSetSelection(), SLChangeSelection(), SLDrawText(), SLMouseToIch(), and SLScrollText(). { ICH newch = ch; if (!ped->fAnsi || !ped->fDBCS || newch == 0) return ( ch ); if (!ECIsDBCSLeadByte(ped,lpstr[--newch])) return ( ch ); // previous char is SBCS while(1) { if (!ECIsDBCSLeadByte(ped,lpstr[newch])) { newch++; break; } if (newch) newch--; else break; } return ((ch - newch) & 1) ? ch-1 : ch; }

ICH FAR PASCAL ECAdjustIchNext (  PED  ped, LPSTR  lpstr, ICH  ch )

Definition at line 4162 of file editec.c. References ECAdjustIch(), ECAnsiNext(), FAR, and ICH. Referenced by MLDrawText(), and SLScrollText(). { ICH ichNew = ECAdjustIch(ped,lpstr,ch); LPSTR lpnew = lpstr+ichNew; // if ch > ichNew then ECAdjustIch adjusted ich. if (ch > ichNew) lpnew = ECAnsiNext(ped, lpnew); return (ICH)(lpnew-lpstr); }

LPSTR ECAnsiNext (  PED  ped, LPSTR  lpCurrent )

Definition at line 3926 of file editec.c. References ECIsDBCSLeadByte(), and TRUE. Referenced by ECAdjustIchNext(), ECWord(), and SLDrawLine(). { return lpCurrent+((ECIsDBCSLeadByte(ped,*lpCurrent)==TRUE) ? 2 : 1); }

LPSTR ECAnsiPrev (  PED  ped, LPSTR  lpBase, LPSTR  lpStr )

Definition at line 3938 of file editec.c. References ECIsDBCSLeadByte(), and tagED::fDBCS. Referenced by ECWord(), MLBuildchLines(), and SLDrawLine(). { LPSTR lpCurrent = lpStr -1; if (!ped->fDBCS) return lpCurrent; // just return ( lpStr - 1 ) if (lpBase >= lpCurrent) return lpBase; if (ECIsDBCSLeadByte(ped, *lpCurrent)) // this check makes things faster return (lpCurrent - 1); // 92/04/04 takaok do { lpCurrent--; if (!ECIsDBCSLeadByte(ped, *lpCurrent)) { lpCurrent++; break; } } while(lpCurrent != lpBase); return lpStr - (((lpStr - lpCurrent) & 1) ? 1 : 2); }

BOOL ECCalcChangeSelection (  PED  ped, ICH  ichOldMinSel, ICH  ichOldMaxSel, LPBLOCK  OldBlk, LPBLOCK  NewBlk )

Definition at line 3692 of file editec.c. References BLOCK, BOOL, ECFindXORblks(), tagBLOCK::EndPos, FALSE, tagED::ichMaxSel, tagED::ichMinSel, max, min, tagBLOCK::StPos, and TRUE. Referenced by MLChangeSelection(), and SLChangeSelection(). { BLOCK Blk[2]; int iBlkCount = 0; Blk[0].StPos = Blk[0].EndPos = Blk[1].StPos = Blk[1].EndPos = 0xFFFFFFFF; /* * Check if the Old selection block existed */ if (ichOldMinSel != ichOldMaxSel) { /* * Yes! Old block existed. */ Blk[0].StPos = OldBlk->StPos; Blk[0].EndPos = OldBlk->EndPos; iBlkCount++; } /* * Check if the new Selection block exists */ if (ped->ichMinSel != ped->ichMaxSel) { /* * Yes! New block exists */ Blk[1].StPos = NewBlk->StPos; Blk[1].EndPos = NewBlk->EndPos; iBlkCount++; } /* * If both the blocks exist find the XOR of them */ if (iBlkCount == 2) { /* * Check if both blocks start at the same character position */ if (ichOldMinSel == ped->ichMinSel) { /* * Check if they end at the same character position */ if (ichOldMaxSel == ped->ichMaxSel) return FALSE; /* Nothing changes */ Blk[0].StPos = min(NewBlk -> EndPos, OldBlk -> EndPos); Blk[0].EndPos = max(NewBlk -> EndPos, OldBlk -> EndPos); Blk[1].StPos = 0xFFFFFFFF; } else { if (ichOldMaxSel == ped->ichMaxSel) { Blk[0].StPos = min(NewBlk->StPos, OldBlk->StPos); Blk[0].EndPos = max(NewBlk->StPos, OldBlk->StPos); Blk[1].StPos = 0xFFFFFFFF; } else { ECFindXORblks(OldBlk, NewBlk, &Blk[0], &Blk[1]); } } } RtlCopyMemory(OldBlk, &Blk[0], sizeof(BLOCK)); RtlCopyMemory(NewBlk, &Blk[1], sizeof(BLOCK)); return TRUE; /* Yup , There is something to paint */ }

ICH ECCchInWidth (  PED  ped, HDC  hdc, LPSTR  lpText, ICH  cch, int  width, BOOL  fForward )

Definition at line 1281 of file editec.c. References tagED::aveCharWidth, tagED::cbChar, tagED::charPasswordChar, tagED::cPasswordCharWidth, ECAdjustIch(), ECT_CALC, ECTabTheTextOut(), tagED::fAnsi, tagED::fDBCS, tagED::fNonPropFont, tagED::fSingle, ICH, MAXLINELENGTH, NULL, umax, and umin. Referenced by MLBuildchLines(), MLMouseToIch(), SLCalcXOffsetSpecial(), SLDrawText(), SLInsertText(), SLMouseToIch(), and SLScrollText(). { int stringExtent; int cchhigh; int cchnew = 0; int cchlow = 0; SIZE size; LPSTR lpStart; if ((width <= 0) || !cch) return (0); /* * Optimize nonproportional fonts for single line ec since they don't have * tabs. */ // // Change optimize condition for fixed pitch font // if (ped->fNonPropFont && ped->fSingle && !ped->fDBCS) { return (ECAdjustIch( ped, lpText, umin(width/ped->aveCharWidth,(int)cch))); } /* * Check if password hidden chars are being used. */ if (ped->charPasswordChar) { return (umin(width / ped->cPasswordCharWidth, (int)cch)); } /* * ALWAYS RESTRICT TO AT MOST MAXLINELENGTH to avoid overflow... */ cch = umin(MAXLINELENGTH, cch); cchhigh = cch + 1; while (cchlow < cchhigh - 1) { cchnew = umax((cchhigh - cchlow) / 2, 1) + cchlow; lpStart = lpText; /* * If we want to figure out how many fit starting at the end and moving * backwards, make sure we move to the appropriate position in the * string before calculating the text extent. */ if (!fForward) lpStart += (cch - cchnew)*ped->cbChar; if (ped->fSingle) { if (ped->fAnsi) GetTextExtentPointA(hdc, (LPSTR)lpStart, cchnew, &size); else GetTextExtentPointW(hdc, (LPWSTR)lpStart, cchnew, &size); stringExtent = size.cx; } else { stringExtent = ECTabTheTextOut(hdc, 0, 0, 0, 0, lpStart, cchnew, 0, ped, 0, ECT_CALC, NULL ); } if (stringExtent > width) { cchhigh = cchnew; } else { cchlow = cchnew; } } // // Call ECAdjustIch ( generic case ) // cchlow = ECAdjustIch( ped, lpText, cchlow ); return (cchlow); }

void ECClearText (  PED  ped  )

Definition at line 692 of file editec.c. References tagED::fReadOnly, tagED::fSingle, tagED::hwnd, tagED::ichMaxSel, tagED::ichMinSel, L, MLEditWndProc(), and SLEditWndProc(). Referenced by ECCutText(), and EditWndProc(). { if (!ped->fReadOnly && (ped->ichMinSel < ped->ichMaxSel)) { if (ped->fSingle) SLEditWndProc(ped->hwnd, ped, WM_CHAR, VK_BACK, 0L ); else MLEditWndProc(ped->hwnd, ped, WM_CHAR, VK_BACK, 0L ); } }

ICH ECCopy (  PED  ped  )

Definition at line 2703 of file editec.c. References tagED::cbChar, tagED::charPasswordChar, CI_16BIT, ECLock(), ECUnlock(), tagED::fAnsi, FAR, GetClientInfo, tagED::hwnd, ICH, tagED::ichMaxSel, tagED::ichMinSel, LHND, NtUserCloseClipboard(), NtUserEmptyClipboard(), NtUserMessageBeep, OpenClipboard(), pfnWowEmptyClipBoard, SetClipboardData(), UserGlobalAlloc, USERGLOBALLOCK, and USERGLOBALUNLOCK. Referenced by EditWndProc(). { HANDLE hData; char *pchSel; char FAR *lpchClip; ICH cbData; /* * Don't allow copies from password style controls */ if (ped->charPasswordChar) { NtUserMessageBeep(0); return 0; } cbData = (ped->ichMaxSel - ped->ichMinSel) * ped->cbChar; if (!cbData) return 0; if (!OpenClipboard(ped->hwnd)) return 0; NtUserEmptyClipboard(); /* * If we just called EmptyClipboard in the context of a 16 bit * app then we also have to tell WOW to nix its 16 handle copy of * clipboard data. WOW does its own clipboard caching because * some 16 bit apps use clipboard data even after the clipboard * has been emptied. See the note in the server code. * * Note: this is the only place where EmptyClipboard is called * for a 16 bit app not going through WOW. If we added others * we might want to move this into EmptyClipboard and have two * versions. */ if (GetClientInfo()->CI_flags & CI_16BIT) { pfnWowEmptyClipBoard(); } /* * +1 for the terminating NULL */ if (!(hData = UserGlobalAlloc(LHND, (LONG)(cbData + ped->cbChar)))) { NtUserCloseClipboard(); return (0); } USERGLOBALLOCK(hData, lpchClip); UserAssert(lpchClip); pchSel = ECLock(ped); pchSel = pchSel + (ped->ichMinSel * ped->cbChar); RtlCopyMemory(lpchClip, pchSel, cbData); if (ped->fAnsi) *(lpchClip + cbData) = 0; else *(LPWSTR)(lpchClip + cbData) = (WCHAR)0; ECUnlock(ped); USERGLOBALUNLOCK(hData); SetClipboardData( ped->fAnsi ? CF_TEXT : CF_UNICODETEXT, hData); NtUserCloseClipboard(); return (cbData); }

void ECCutText (  PED  ped  )

Definition at line 712 of file editec.c. References ECClearText(), tagED::fReadOnly, tagED::hwnd, tagED::ichMaxSel, tagED::ichMinSel, L, and SendMessage(). Referenced by EditWndProc(). { // Cut selection--IE, remove and copy to clipboard, or if no selection, // delete (clear) character left. if (!ped->fReadOnly && (ped->ichMinSel < ped->ichMaxSel) && SendMessage(ped->hwnd, WM_COPY, 0, 0L)) { // If copy was successful, delete the copied text by sending a // backspace message which will redraw the text and take care of // notifying the parent of changes. ECClearText(ped); } }

ICH ECDeleteText (  PED  ped  )

Definition at line 2293 of file editec.c. References tagED::cbChar, tagED::cch, tagED::cchAlloc, CCHALLOCEXTRA, DWORD, ECEmptyUndo(), ECGetEditDC(), ECLock(), ECReleaseEditDC(), ECUnlock(), tagLPKEDITCALLOUT::EditAdjustCaret, tagED::fDirty, tagED::hInstance, tagED::hText, ICH, tagED::ichCaret, tagED::ichMaxSel, tagED::ichMinSel, LHND, LOCALREALLOC, LOCALSIZE, NULL, tagED::pLpkEditCallout, Pundo, TRUE, UNDO_DELETE, UNDO_INSERT, UNDO_NONE, UserGlobalAlloc, and UserGlobalReAlloc. Referenced by ECImeComposition(), EditWndProc(), MLDeleteText(), SLChar(), SLPaste(), SLReplaceSel(), and SLUndo(). { PSTR pedText; ICH cchDelete; LPSTR lpDeleteSaveBuffer; HANDLE hDeletedText; DWORD bufferOffset; cchDelete = ped->ichMaxSel - ped->ichMinSel; if (!cchDelete) return (0); /* * Ok, now lets delete the text. */ pedText = ECLock(ped); /* * Adjust UNDO fields so that we can undo this delete... */ if (ped->undoType == UNDO_NONE) { UNDODELETEFROMSCRATCH: if (ped->hDeletedText = UserGlobalAlloc(GPTR, (LONG)((cchDelete+1)*ped->cbChar))) { ped->undoType = UNDO_DELETE; ped->ichDeleted = ped->ichMinSel; ped->cchDeleted = cchDelete; lpDeleteSaveBuffer = ped->hDeletedText; RtlCopyMemory(lpDeleteSaveBuffer, pedText + ped->ichMinSel*ped->cbChar, cchDelete*ped->cbChar); lpDeleteSaveBuffer[cchDelete*ped->cbChar] = 0; } } else if (ped->undoType & UNDO_INSERT) { UNDODELETE: ECEmptyUndo(Pundo(ped)); ped->ichInsStart = ped->ichInsEnd = 0xFFFFFFFF; ped->ichDeleted = 0xFFFFFFFF; ped->cchDeleted = 0; goto UNDODELETEFROMSCRATCH; } else if (ped->undoType == UNDO_DELETE) { if (ped->ichDeleted == ped->ichMaxSel) { /* * Copy deleted text to front of undo buffer */ hDeletedText = UserGlobalReAlloc(ped->hDeletedText, (LONG)(cchDelete + ped->cchDeleted + 1)*ped->cbChar, GHND); if (!hDeletedText) goto UNDODELETE; bufferOffset = 0; ped->ichDeleted = ped->ichMinSel; } else if (ped->ichDeleted == ped->ichMinSel) { /* * Copy deleted text to end of undo buffer */ hDeletedText = UserGlobalReAlloc(ped->hDeletedText, (LONG)(cchDelete + ped->cchDeleted + 1)*ped->cbChar, GHND); if (!hDeletedText) goto UNDODELETE; bufferOffset = ped->cchDeleted*ped->cbChar; } else { /* * Clear the current UNDO delete and add the new one since the deletes aren't contiguous. */ goto UNDODELETE; } ped->hDeletedText = hDeletedText; lpDeleteSaveBuffer = (LPSTR)hDeletedText; if (!bufferOffset) { /* * Move text in delete buffer up so that we can insert the next * text at the head of the buffer. */ RtlMoveMemory(lpDeleteSaveBuffer + cchDelete*ped->cbChar, lpDeleteSaveBuffer, ped->cchDeleted*ped->cbChar); } RtlCopyMemory(lpDeleteSaveBuffer + bufferOffset, pedText + ped->ichMinSel*ped->cbChar, cchDelete*ped->cbChar); lpDeleteSaveBuffer[(ped->cchDeleted + cchDelete)*ped->cbChar] = 0; ped->cchDeleted += cchDelete; } if (ped->ichMaxSel != ped->cch) { /* * We are deleting text from the middle of the buffer so we have to shift text to the left. */ RtlMoveMemory(pedText + ped->ichMinSel*ped->cbChar, pedText + ped->ichMaxSel*ped->cbChar, (ped->cch - ped->ichMaxSel)*ped->cbChar); } if (ped->cchAlloc - ped->cch > CCHALLOCEXTRA) { /* * Free some memory since we deleted a lot */ LOCALREALLOC(ped->hText, (DWORD)(ped->cch + (CCHALLOCEXTRA / 2))*ped->cbChar, LHND, ped->hInstance, NULL); ped->cchAlloc = LOCALSIZE(ped->hText, ped->hInstance) / ped->cbChar; } ped->cch -= cchDelete; if (ped->pLpkEditCallout) { HDC hdc; hdc = ECGetEditDC (ped, TRUE); ped->ichMinSel = ped->pLpkEditCallout->EditAdjustCaret (ped, hdc, pedText, ped->ichMinSel); ECReleaseEditDC (ped, hdc, TRUE); } ped->ichCaret = ped->ichMaxSel = ped->ichMinSel; ECUnlock(ped); /* * Set dirty bit */ ped->fDirty = TRUE; return (cchDelete); }

BOOL NEAR ECDoIMEMenuCommand (  PED  ped, int  cmd, HWND  hwnd )

Definition at line 423 of file editec.c. References BOOL, tagED::cbChar, DWORD, ECImmSetCompositionWindow(), ECInOutReconversionMode(), ECLock(), ECUnlock(), FALSE, tagED::fAnsi, fpImmEnumInputContext, fpImmGetContext, fpImmGetConversionStatus, fpImmGetOpenStatus, fpImmReleaseContext, fpImmSetCompositionStringA, fpImmSetCompositionStringW, fpImmSetOpenStatus, tagED::ichMaxSel, tagED::ichMinSel, ID_IMEOPENCLOSE, ID_RECONVERTSTRING, ID_SOFTKBDOPENCLOSE, L, lpDest, NULL, SyncSoftKbdState(), TRUE, UserLocalAlloc, and UserLocalFree. Referenced by ECMenu(). { HIMC hIMC; // early out switch (cmd) { case ID_IMEOPENCLOSE: case ID_SOFTKBDOPENCLOSE: case ID_RECONVERTSTRING: break; default: return FALSE; } // everybody needs hIMC, so get it here hIMC = fpImmGetContext(hwnd); if (hIMC == NULL) { // indicate to caller, that no further command processing needed return TRUE; } switch (cmd) { case ID_IMEOPENCLOSE: { // switch IME Open/Close status BOOL fOpen = fpImmGetOpenStatus(hIMC); fpImmSetOpenStatus(hIMC, !fOpen); } break; case ID_SOFTKBDOPENCLOSE: { DWORD fdwConversion; if (fpImmGetConversionStatus(hIMC, &fdwConversion, NULL)) { // // Toggle soft keyboard Open/Close status // fpImmEnumInputContext(0, SyncSoftKbdState, (fdwConversion & IME_CMODE_SOFTKBD) != IME_CMODE_SOFTKBD); } } break; case ID_RECONVERTSTRING: { DWORD dwStrLen; // holds TCHAR count of recionversion string DWORD cbLen; // holds BYTE SIZE of reconversion string DWORD dwSize; LPRECONVERTSTRING lpRCS; // pass current selection to IME for reconversion dwStrLen = ped->ichMaxSel - ped->ichMinSel; cbLen = dwStrLen * ped->cbChar; dwSize = cbLen + sizeof(RECONVERTSTRING) + 8; lpRCS = (LPRECONVERTSTRING)UserLocalAlloc(0, dwSize); if (lpRCS) { LPBYTE pText; pText = ECLock(ped); if (pText != NULL) { LPBYTE lpDest; BOOL (WINAPI* fpSetCompositionStringAW)(HIMC, DWORD, LPCVOID, DWORD, LPCVOID, DWORD); lpRCS->dwSize = dwSize; lpRCS->dwVersion = 0; lpRCS->dwStrLen = lpRCS->dwCompStrLen = lpRCS->dwTargetStrLen = dwStrLen; lpRCS->dwStrOffset = sizeof(RECONVERTSTRING); lpRCS->dwCompStrOffset = lpRCS->dwTargetStrOffset = 0; lpDest = (LPBYTE)lpRCS + sizeof(RECONVERTSTRING); RtlCopyMemory(lpDest, pText + ped->ichMinSel * ped->cbChar, cbLen); if (ped->fAnsi) { LPBYTE psz = (LPBYTE)lpDest; psz[cbLen] = '\0'; fpSetCompositionStringAW = fpImmSetCompositionStringA; } else { LPWSTR pwsz = (LPWSTR)lpDest; pwsz[dwStrLen] = L'\0'; fpSetCompositionStringAW = fpImmSetCompositionStringW; } ECUnlock(ped); UserAssert(fpSetCompositionStringAW != NULL); ECInOutReconversionMode(ped, TRUE); ECImmSetCompositionWindow(ped, 0, 0); // x and y will be overriden anyway fpSetCompositionStringAW(hIMC, SCS_SETRECONVERTSTRING, lpRCS, dwSize, NULL, 0); } // pText UserLocalFree(lpRCS); } } break; default: // should never reach here. RIPMSG1(RIP_ERROR, "ECDoIMEMenuCommand: unknown command id %d; should never reach here.", cmd); return FALSE; } UserAssert(hIMC != NULL); fpImmReleaseContext(hwnd, hIMC); return TRUE; }

void ECEmptyUndo (  PUNDO  pundo  )

Definition at line 1977 of file editec.c. References tagUNDO::hDeletedText, and UserGlobalFree. Referenced by ECDeleteText(), ECResetTextInfo(), EditWndProc(), MLEditWndProc(), MLInsertText(), MLPasteText(), MLReplaceSel(), SLEditWndProc(), and SLReplaceSel(). { if (pundo->hDeletedText) UserGlobalFree(pundo->hDeletedText); RtlZeroMemory(pundo, sizeof(UNDO) ); }

ICH ECFindTabA (  LPSTR  lpstr, ICH  cch )

Definition at line 1371 of file editec.c. References ICH. Referenced by ECTabTheTextOut(). { LPSTR copylpstr = lpstr; if (!cch) return 0; while (*lpstr != VK_TAB) { lpstr++; if (--cch == 0) break; } return ((ICH)(lpstr - copylpstr)); }

ICH ECFindTabW (  LPWSTR  lpstr, ICH  cch )

Definition at line 1388 of file editec.c. References ICH. Referenced by ECTabTheTextOut(). { LPWSTR copylpstr = lpstr; if (!cch) return 0; while (*lpstr != VK_TAB) { lpstr++; if (--cch == 0) break; } return ((ICH)(lpstr - copylpstr)); }

void ECFindXORblks (  LPBLOCK  lpOldBlk, LPBLOCK  lpNewBlk, LPBLOCK  lpBlk1, LPBLOCK  lpBlk2 )

Definition at line 3652 of file editec.c. References tagBLOCK::EndPos, LPBLOCK, max, min, and tagBLOCK::StPos. Referenced by ECCalcChangeSelection(). { if (lpOldBlk->StPos >= lpNewBlk->StPos) { lpBlk1->StPos = lpNewBlk->StPos; lpBlk1->EndPos = min(lpOldBlk->StPos, lpNewBlk->EndPos); } else { lpBlk1->StPos = lpOldBlk->StPos; lpBlk1->EndPos = min(lpNewBlk->StPos, lpOldBlk->EndPos); } if (lpOldBlk->EndPos <= lpNewBlk->EndPos) { lpBlk2->StPos = max(lpOldBlk->EndPos, lpNewBlk->StPos); lpBlk2->EndPos = lpNewBlk->EndPos; } else { lpBlk2->StPos = max(lpNewBlk->EndPos, lpOldBlk->StPos); lpBlk2->EndPos = lpOldBlk->EndPos; } }

HBRUSH ECGetBrush (  PED  ped, HDC  hdc )

Definition at line 1412 of file editec.c. References BOOL, DWORD, ECGetControlBrush(), tagED::fDisabled, tagED::fReadOnly, tagED::fSingle, GETAPPVER, GetSysColor(), and VER40. Referenced by MLDrawText(), MLScroll(), SLChangeSelection(), SLDrawLine(), SLDrawText(), SLPaint(), and SLScrollText(). { HBRUSH hbr; BOOL f40Compat; f40Compat = (GETAPPVER() >= VER40); // Get background brush if ((ped->fReadOnly || ped->fDisabled) && f40Compat) { hbr = ECGetControlBrush(ped, hdc, WM_CTLCOLORSTATIC); } else hbr = ECGetControlBrush(ped, hdc, WM_CTLCOLOREDIT); if (ped->fDisabled && (ped->fSingle || f40Compat)) { DWORD rgb; // Change text color rgb = GetSysColor(COLOR_GRAYTEXT); if (rgb != GetBkColor(hdc)) SetTextColor(hdc, rgb); } return(hbr); }

HBRUSH ECGetControlBrush (  PED  ped, HDC  hdc, LONG  message )

Definition at line 3776 of file editec.c. References DefWindowProcWorker(), tagED::fAnsi, GETPTI, tagED::hwnd, NULL, PtiCurrent, REBASEPTR, SendMessageWorker(), tagWND::spwndOwner, tagWND::spwndParent, TestwndPopup, and ValidateHwnd. Referenced by ECGetBrush(). { PWND pwndSend; PWND pwndEdit; pwndEdit = ValidateHwnd(ped->hwnd); if (pwndEdit == (PWND)NULL) return (HBRUSH)0; if ((pwndSend = (TestwndPopup(pwndEdit) ? pwndEdit->spwndOwner : pwndEdit->spwndParent)) == NULL) pwndSend = pwndEdit; else pwndSend = REBASEPTR(pwndEdit, pwndSend); UserAssert(pwndSend); if (PtiCurrent() != GETPTI(pwndSend)) { return (HBRUSH)DefWindowProcWorker(pwndSend, message, (WPARAM)hdc, (LPARAM)pwndEdit, ped->fAnsi); } /* * By using the correct A/W call we avoid a c/s transition * on this SendMessage(). */ return (HBRUSH)SendMessageWorker(pwndSend, message, (WPARAM)hdc, (LPARAM)ped->hwnd, ped->fAnsi); }

int ECGetDBCSVector (  PED  ped, HDC  hdc, BYTE  CharSet )

Definition at line 3820 of file editec.c. References BOOL, BYTE, tagED::DBCSVector, DWORD, FALSE, tagED::fAnsi, FAREAST_CHARSET_BITS, fFontAssocStatus, GetACPCharSet(), QueryFontAssocStatus(), and TRUE. Referenced by ECSetFont(). { BOOL bDBCSCodePage = FALSE; /* * if DEFAUT_CHARSET was passed, we will convert that to Shell charset.. */ if (CharSet == DEFAULT_CHARSET) { CharSet = (BYTE)GetTextCharset(hdc); /* * if CharSet is still DEFAULT_CHARSET, it means gdi has some problem.. * then just return default.. we get charset from CP_ACP.. */ if (CharSet == DEFAULT_CHARSET) { CharSet = (BYTE)GetACPCharSet(); } } switch (CharSet) { case SHIFTJIS_CHARSET: case HANGEUL_CHARSET: case CHINESEBIG5_CHARSET: case GB2312_CHARSET: bDBCSCodePage = TRUE; break; case ANSI_CHARSET: // 0 case SYMBOL_CHARSET: // 2 case OEM_CHARSET: // 255 if (fFontAssocStatus == 0xffff) fFontAssocStatus = QueryFontAssocStatus(); if ((((CharSet + 2) & 0xf) & fFontAssocStatus)) { bDBCSCodePage = TRUE; /* * Bug 117558, etc. * Try to get a meaningful character set for associated font. */ CharSet = (BYTE)GetACPCharSet(); } else { bDBCSCodePage = FALSE; } break; default: bDBCSCodePage = FALSE; } if (bDBCSCodePage) { CHARSETINFO CharsetInfo; DWORD CodePage; CPINFO CPInfo; int lbIX; if (TranslateCharsetInfo((DWORD *)CharSet, &CharsetInfo, TCI_SRCCHARSET)) { CodePage = CharsetInfo.ciACP; } else { CodePage = CP_ACP; } GetCPInfo(CodePage, &CPInfo); for (lbIX=0 ; CPInfo.LeadByte[lbIX] != 0 ; lbIX+=2) { ped->DBCSVector[lbIX ] = CPInfo.LeadByte[lbIX]; ped->DBCSVector[lbIX+1] = CPInfo.LeadByte[lbIX+1]; } ped->DBCSVector[lbIX ] = 0x0; ped->DBCSVector[lbIX+1] = 0x0; } else { ped->DBCSVector[0] = 0x0; ped->DBCSVector[1] = 0x0; } // // Final check: if the font supports DBCS glyphs // // If we've got a font with DBCS glyphs, let's mark PED so. // But since the font's primary charset is the one other than FE, // we can only support UNICODE Edit control. // // a) GDI performs A/W conversion for ANSI apps based on the primary // character set in hDC, so it will break anyway. // b) ANSI applications are only supported on their native system locales: // GetACPCharSet() is expected to return a FE code page. // c) ANSI Edit control requires DBCSVector, which cannot be // initialized without a FE code page. // if (!ped->fAnsi) { FONTSIGNATURE fontSig; GetTextCharsetInfo(hdc, &fontSig, 0); if (fontSig.fsCsb[0] & FAREAST_CHARSET_BITS) { bDBCSCodePage = TRUE; // Since this is UNICODE, we're not } } return bDBCSCodePage; }

HDC ECGetEditDC (  PED  ped, BOOL  fFastDC )

Definition at line 2492 of file editec.c. References BOOL, ECSetEditClip(), tagED::hFont, tagED::hwnd, NtUserGetDC(), NtUserHideCaret(), and tagED::xOffset. Referenced by ECCreate(), ECDeleteText(), ECImeComposition(), ECInsertText(), ECSetCaretHandler(), ECSetPasswordChar(), EditWndProc(), MLBuildchLines(), MLCalcXOffset(), MLDeleteText(), MLEditWndProc(), MLEnsureCaretVisible(), MLInsertText(), MLKeyDown(), MLKillFocus(), MLMouseMotion(), MLMoveSelectionRestricted(), MLScroll(), MLSetFocus(), MLSetSelection(), NextWordLpkCallBack(), SLChar(), SLEditWndProc(), SLInsertText(), SLKeyDown(), SLMouseMotion(), SLMoveSelectionRestricted(), SLPaste(), SLReplaceSel(), SLSetFocus(), and SLSetSelection(). { HDC hdc; if (!fFastDC) NtUserHideCaret(ped->hwnd); if ( hdc = NtUserGetDC(ped->hwnd) ) { ECSetEditClip(ped, hdc, (BOOL)(ped->xOffset == 0)); /* * Select the proper font for this edit control's dc. */ if (ped->hFont) SelectObject(hdc, ped->hFont); } return hdc; }

int ECGetModKeys (  int  keyMods  )

Definition at line 733 of file editec.c. References CTRLDOWN, GetKeyState(), NOMODIFY, and SHFTDOWN. Referenced by MLChar(), MLKeyDown(), and SLKeyDown(). { int scState; scState = 0; if (!keyMods) { if (GetKeyState(VK_CONTROL) < 0) scState |= CTRLDOWN; if (GetKeyState(VK_SHIFT) < 0) scState |= SHFTDOWN; } else if (keyMods != NOMODIFY) scState = keyMods; return scState; }

void ECInOutReconversionMode (  PED  ped, BOOL  fIn )

Definition at line 402 of file editec.c. References FALSE, tagED::fFocus, tagED::fInReconversion, tagED::hwnd, NtUserHideCaret(), NtUserShowCaret(), and TRUE. Referenced by ECDoIMEMenuCommand(), ECImeComposition(), EcImeRequestHandler(), EditWndProc(), MLChar(), MLEditWndProc(), and SLChar(). { UserAssert(fIn == TRUE || fIn == FALSE); if (fIn == ped->fInReconversion) { return; } ped->fInReconversion = fIn; if (ped->fFocus) { (fIn ? NtUserHideCaret: NtUserShowCaret)(ped->hwnd); } return; }

BOOL ECInsertText (  PED  ped, LPSTR  lpText, ICH *  pcchInsert )

Definition at line 2059 of file editec.c. References BOOL, tagED::cbChar, tagED::cch, tagED::cchAlloc, CCHALLOCEXTRA, CharLowerBuffA(), CharLowerBuffW(), tagED::charSet, CharToOemBuffA(), CharToOemBuffW(), CharUpperBuffA(), CharUpperBuffW(), DWORD, ECAdjustIch(), ECGetEditDC(), ECIsDBCSLeadByte(), ECLock(), ECMergeUndoInsertInfo(), ECReleaseEditDC(), ECUnlock(), tagLPKEDITCALLOUT::EditAdjustCaret, tagLPKEDITCALLOUT::EditVerifyText, FALSE, tagED::fAnsi, tagED::fDirty, GETAPPVER, tagED::hInstance, tagED::hText, ICH, tagED::ichCaret, tagED::ichMaxSel, tagED::ichMinSel, INT, IS_DBCS_ENABLED, IsCharLowerA(), IsCharLowerW(), LHND, LOCALREALLOC, LOCALSIZE, OemToCharBuffA(), OemToCharBuffW(), tagED::pLpkEditCallout, Pundo, tagED::pwnd, strlen(), TRUE, UNICODE_CARRIAGERETURN, UNICODE_LINEFEED, UNICODE_TAB, and VER50. Referenced by ECSetText(), MLInsertText(), and SLInsertText(). { PSTR pedText; PSTR pTextBuff; LONG style; HANDLE hTextCopy; DWORD allocamt; // // If the last byte (lpText[cchInsert - 1]) is a DBCS leading byte // we need to adjust it. // *pcchInsert = ECAdjustIch(ped, lpText, *pcchInsert); if (!*pcchInsert) return TRUE; /* * Do we already have enough memory?? */ if (*pcchInsert >= (ped->cchAlloc - ped->cch)) { /* * Allocate what we need plus a little extra. Return FALSE if we are * unsuccessful. */ allocamt = (ped->cch + *pcchInsert) * ped->cbChar; allocamt += CCHALLOCEXTRA; // if (!ped->fSingle) { hTextCopy = LOCALREALLOC(ped->hText, allocamt, LHND, ped->hInstance, &lpText); if (hTextCopy) { ped->hText = hTextCopy; } else { return FALSE; } // } else { // if (!LocalReallocSafe(ped->hText, allocamt, LHND, pped)) // return FALSE; // } ped->cchAlloc = LOCALSIZE(ped->hText, ped->hInstance) / ped->cbChar; } /* * Ok, we got the memory. Now copy the text into the structure */ pedText = ECLock(ped); if (ped->pLpkEditCallout) { HDC hdc; INT iResult; hdc = ECGetEditDC (ped, TRUE); iResult = ped->pLpkEditCallout->EditVerifyText (ped, hdc, pedText, ped->ichCaret, lpText, *pcchInsert); ECReleaseEditDC (ped, hdc, TRUE); if (iResult == 0) { ECUnlock (ped); return TRUE; } } /* * Get a pointer to the place where text is to be inserted */ pTextBuff = pedText + ped->ichCaret * ped->cbChar; if (ped->ichCaret != ped->cch) { /* * We are inserting text into the middle. We have to shift text to the * right before inserting new text. */ memmove(pTextBuff + *pcchInsert * ped->cbChar, pTextBuff, (ped->cch-ped->ichCaret) * ped->cbChar); } /* * Make a copy of the text being inserted in the edit buffer. * Use this copy for doing UPPERCASE/LOWERCASE ANSI/OEM conversions * Fix for Bug #3406 -- 01/29/91 -- SANKAR -- */ memmove(pTextBuff, lpText, *pcchInsert * ped->cbChar); ped->cch += *pcchInsert; /* * Get the control's style */ style = ped->pwnd->style; /* * Do the Upper/Lower conversion */ if (style & ES_LOWERCASE) { if (ped->fAnsi) CharLowerBuffA((LPSTR)pTextBuff, *pcchInsert); else CharLowerBuffW((LPWSTR)pTextBuff, *pcchInsert); } else { if (style & ES_UPPERCASE) { if (ped->fAnsi) { CharUpperBuffA(pTextBuff, *pcchInsert); } else { CharUpperBuffW((LPWSTR)pTextBuff, *pcchInsert); } } } /* * Do the OEM conversion */ if ((style & ES_OEMCONVERT) && // For backward compatibility with NT4, we don't perform OEM conversion // for older apps if the system locale is FarEast. // (!IS_DBCS_ENABLED() || GETAPPVER() >= VER50 || GetOEMCP() != GetACP())) { ICH i; if (ped->fAnsi) { for (i = 0; i < *pcchInsert; i++) { // // We don't need to call CharToOemBuff etc. if the character // is a double byte character. And, calling ECIsDBCSLeadByte is // faster and less complicated because we don't have to deal // with the 2 byte dbcs cases. // if (IS_DBCS_ENABLED() && ECIsDBCSLeadByte(ped, *(lpText+i))) { i++; continue; } // // Windows Bug (Whistler) 35289 // greek has funny rules for casing, so we need to check for it. // for nashville we should be doing something more appropriate // but for now, leave as Win95 golden // if (ped->charSet != GREEK_CHARSET && IsCharLowerA(*(pTextBuff + i))) { CharUpperBuffA(pTextBuff + i, 1); CharToOemBuffA(pTextBuff + i, pTextBuff + i, 1); OemToCharBuffA(pTextBuff + i, pTextBuff + i, 1); CharLowerBuffA(pTextBuff + i, 1); } else { CharToOemBuffA(pTextBuff + i, pTextBuff + i, 1); OemToCharBuffA(pTextBuff + i, pTextBuff + i, 1); } } } else { // // Because 'ch' may become DBCS, and have a space for NULL. // UCHAR ch[4]; LPWSTR lpTextW = (LPWSTR)pTextBuff; for (i = 0; i < *pcchInsert; i++) { if (*(lpTextW + i) == UNICODE_CARRIAGERETURN || *(lpTextW + i) == UNICODE_LINEFEED || *(lpTextW + i) == UNICODE_TAB) { continue; } // // Windows Bug (Whistler) 35289 // greek has funny rules for casing, so we need to check for it. // for nashville we should be doing something more appropriate // but for now, leave as Win95 golden // if (ped->charSet != GREEK_CHARSET && IsCharLowerW(*(lpTextW + i))) { CharUpperBuffW(lpTextW + i, 1); *(LPDWORD)ch = 0; // make sure the null-terminate. CharToOemBuffW(lpTextW + i, ch, 1); // // We assume any SBCS/DBCS character will converted // to 1 Unicode char, Otherwise, we may overwrite // next character... // OemToCharBuffW(ch, lpTextW + i, strlen(ch)); CharLowerBuffW(lpTextW + i, 1); } else { *(LPDWORD)ch = 0; // make sure the null-terminate. CharToOemBuffW(lpTextW + i, ch, 1); // // We assume any SBCS/DBCS character will converted // to 1 Unicode char, Otherwise, we may overwrite // next character... // OemToCharBuffW(ch, lpTextW + i, strlen(ch)); } } } } /* Adjust UNDO fields so that we can undo this insert... */ ECMergeUndoInsertInfo(Pundo(ped), ped->ichCaret, *pcchInsert); ped->ichCaret += *pcchInsert; if (ped->pLpkEditCallout) { HDC hdc; hdc = ECGetEditDC (ped, TRUE); ped->ichCaret = ped->pLpkEditCallout->EditAdjustCaret (ped, hdc, pedText, ped->ichCaret); ECReleaseEditDC (ped, hdc, TRUE); } ped->ichMinSel = ped->ichMaxSel = ped->ichCaret; ECUnlock(ped); /* * Set dirty bit */ ped->fDirty = TRUE; return TRUE; }

void ECInvalidateClient (  PED  ped, BOOL  fErase )

Definition at line 2679 of file editec.c. References _GetClientRect(), tagED::fFlatBorder, tagED::hwnd, InflateRect(), NtUserInvalidateRect(), NULL, tagED::pwnd, and SYSMET. Referenced by ECResetTextInfo(), ECSetMargin(), ECUpdateFormat(), EditWndProc(), and SLUndo(). { if (ped->fFlatBorder) { RECT rcT; _GetClientRect(ped->pwnd, &rcT); InflateRect(&rcT, -SYSMET(CXBORDER), -SYSMET(CYBORDER)); NtUserInvalidateRect(ped->hwnd, &rcT, fErase); } else { NtUserInvalidateRect(ped->hwnd, NULL, fErase); } }

BOOL ECIsAncestorActive (  HWND  hwnd  )

Definition at line 242 of file editec.c. References BOOL, GetParent(), NULL, TestWF, TRUE, ValidateHwnd, WFCHILD, WFCPRESENT, WFFRAMEON, and WFWIN40COMPAT. Referenced by EditWndProc(). { // We want to return TRUE always for top level windows. That's because // of how WM_MOUSEACTIVATE works. If we see the click at all, the // window is active. However, if we reach a child ancestor that has // a caption, return the frame-on style bit. // // Note that calling FlashWindow() will have an effect. If the user // clicks on an edit field in a child window that is flashed off, nothing // will happen unless the window stops flashing and ncactivates first. while (hwnd) { PWND pwnd = ValidateHwnd( hwnd ); // // Bail out if some parent window isn't 4.0 compatible or we've // reached the top. Fixes compatibility problems with 3.x apps, // especially MFC samples. // if (!TestWF(pwnd, WFWIN40COMPAT) || !TestWF(pwnd, WFCHILD)) hwnd = NULL; // to break us out of the loop else if (TestWF(pwnd, WFCPRESENT)) return(TestWF(pwnd, WFFRAMEON) != 0); else hwnd = GetParent(hwnd); } return(TRUE); }

BOOL ECIsDBCSLeadByte (  PED  ped, BYTE  cch )

Definition at line 4083 of file editec.c. References BOOL, tagED::DBCSVector, FALSE, tagED::fAnsi, tagED::fDBCS, and TRUE. Referenced by ECAdjustIch(), ECAnsiNext(), ECAnsiPrev(), ECInsertText(), ECNextIch(), ECPrevIch(), ECTabTheTextOut(), ECWord(), MLBuildchLines(), MLChar(), MLMouseMotion(), SLChar(), SLMouseMotion(), and SLMouseToIch(). { int i; if (!ped->fDBCS || !ped->fAnsi) return (FALSE); for (i = 0; ped->DBCSVector[i]; i += 2) { if ((ped->DBCSVector[i] <= cch) && (ped->DBCSVector[i+1] >= cch)) return (TRUE); } return (FALSE); }

PSTR ECLock (  PED  ped  )

Definition at line 52 of file editec.c. References tagED::cbChar, tagED::cch, FALSE, tagED::fEncoded, tagED::hInstance, tagED::hText, tagED::iLockLevel, LOCALLOCK, RtlRunDecodeUnicodeString(), tagED::seed, and USHORT. Referenced by ECCopy(), ECDeleteText(), ECDoIMEMenuCommand(), ECGetText(), EcImeRequestHandler(), ECInsertText(), ECNextIch(), ECPrevIch(), ECSetCaretHandler(), ECWord(), HanjaKeyHandler(), MLBuildchLines(), MLCalcXOffset(), MLDrawText(), MLEditWndProc(), MLGetLine(), MLIchToXYPos(), MLIchToYPos(), MLInsertCrCrLf(), MLInsertText(), MLKeyDown(), MLLine(), MLMouseMotion(), MLMouseToIch(), MLMoveSelection(), MLMoveSelectionRestricted(), MLSetHandle(), MLSetSelection(), MLStripCrCrLf(), MLUpdateiCaretLine(), NextWordCallBack(), NextWordLpkCallBack(), SLCalcStringWidth(), SLCalcXOffsetSpecial(), SLChangeSelection(), SLDrawLine(), SLDrawText(), SLGetClipRect(), SLIchToLeftXPos(), SLInsertText(), SLMouseMotion(), SLMouseToIch(), SLMoveSelectionRestricted(), and SLScrollText(). { PSTR ptext = LOCALLOCK(ped->hText, ped->hInstance); ped->iLockLevel++; /* * If this is the first lock of the text and the text is encoded * decode the text. */ //RIPMSG2(RIP_VERBOSE, "lock : %d '%10s'\n", ped->iLockLevel, ptext); if (ped->iLockLevel == 1 && ped->fEncoded) { /* * rtlrundecode can't handle zero length strings */ if (ped->cch != 0) { STRING string; string.Length = string.MaximumLength = (USHORT)(ped->cch * ped->cbChar); string.Buffer = ptext; RtlRunDecodeUnicodeString(ped->seed, (PUNICODE_STRING)&string); //RIPMSG1(RIP_VERBOSE, "Decoding: '%10s'\n", ptext); } ped->fEncoded = FALSE; } return ptext; }

void ECMenu (  HWND  hwnd, PED  ped, LPPOINT  pt )

Definition at line 548 of file editec.c. References tagED::cch, tagED::charPasswordChar, ECDoIMEMenuCommand(), ECSetIMEMenu(), tagLPKEDITCALLOUT::EditProcessMenu, tagLPKEDITCALLOUT::EditSetMenu, EnableMenuItem(), FALSE, EditMenuItemState::fDisableCut, EditMenuItemState::fDisablePaste, tagED::fFocus, EditMenuItemState::fIME, EditMenuItemState::fNeedSeparatorBeforeImeMenu, fpImmIsIME, tagED::fReadOnly, GetMenuItemCount(), GetMenuState(), GetSubMenu(), GetWindowRect(), hmodUser, tagED::ichMaxSel, tagED::ichMinSel, ID_CNTX_DISPLAYCTRL, ID_CNTX_INSERTCTRL, ID_CNTX_RTL, ID_EC_PROPERTY_MENU, IS_IME_ENABLED, L, NtUserDeleteMenu(), NtUserDestroyMenu(), NtUserIsClipboardFormatAvailable(), NtUserSetFocus(), NtUserTrackPopupMenuEx(), NULL, tagED::pLpkEditCallout, SendMessage(), THREAD_HKL, TRUE, and UNDO_NONE. Referenced by EditWndProc(). { HMENU hMenu; int cmd = 0; int x; int y; EditMenuItemState state = { FALSE, // fDisableCut TRUE, // fDisablePaste TRUE, // fNeedSeparatorBeforeImeMenu IS_IME_ENABLED() && fpImmIsIME(THREAD_HKL()), // fIME }; // Set focus if we don't have it. if (!ped->fFocus) NtUserSetFocus(hwnd); // Grab the menu from USER's resources... if (!(hMenu = LoadMenu( hmodUser, MAKEINTRESOURCE( ID_EC_PROPERTY_MENU )))) return ; // Undo -- not allowed if we have no saved undo info if (ped->undoType == UNDO_NONE) EnableMenuItem(hMenu, WM_UNDO, MF_BYCOMMAND | MFS_GRAYED); if (ped->fReadOnly || ped->charPasswordChar) { // Cut and Delete -- not allowed if read-only or password state.fDisableCut = TRUE; } else { // Cut, Delete -- not allowed if there's no selection if (ped->ichMinSel == ped->ichMaxSel) state.fDisableCut = TRUE; } // Paste -- not allowed if there's no text on the clipboard // (this works for both OEM and Unicode) // Used to be always disabled for password edits MCostea #221035 if (NtUserIsClipboardFormatAvailable(CF_TEXT)) state.fDisablePaste = FALSE; if (state.fDisableCut) { EnableMenuItem(hMenu, WM_CUT, MF_BYCOMMAND | MFS_GRAYED); EnableMenuItem(hMenu, WM_CLEAR, MF_BYCOMMAND | MFS_GRAYED); } if (state.fDisablePaste) EnableMenuItem(hMenu, WM_PASTE, MF_BYCOMMAND | MFS_GRAYED); // Copy -- not allowed if there's no selection or password ec if ((ped->ichMinSel == ped->ichMaxSel) || (ped->charPasswordChar)) EnableMenuItem(hMenu, WM_COPY, MF_BYCOMMAND | MFS_GRAYED); // Select All -- not allowed if there's no text or if everything is // selected. Latter case takes care of first one. if ((ped->ichMinSel == 0) && (ped->ichMaxSel == ped->cch)) EnableMenuItem(hMenu, EM_SETSEL, MF_BYCOMMAND | MFS_GRAYED); if (ped->pLpkEditCallout) { ped->pLpkEditCallout->EditSetMenu(ped, hMenu); } else { NtUserDeleteMenu(hMenu, ID_CNTX_DISPLAYCTRL, MF_BYCOMMAND); NtUserDeleteMenu(hMenu, ID_CNTX_RTL, MF_BYCOMMAND); NtUserDeleteMenu(hMenu, ID_CNTX_INSERTCTRL, MF_BYCOMMAND); if (state.fIME) { // One separator is left in the menu, // no need to add the one before IME menus state.fNeedSeparatorBeforeImeMenu = FALSE; } else { // Extra separator is left. Remove it. HMENU hmenuSub = GetSubMenu(hMenu, 0); int nItems = GetMenuItemCount(hmenuSub) - 1; UserAssert(nItems >= 0); UserAssert(GetMenuState(hmenuSub, nItems, MF_BYPOSITION) & MF_SEPARATOR); // remove needless separator UserVerify(NtUserDeleteMenu(hmenuSub, nItems, MF_BYPOSITION)); } } // IME specific menu if (state.fIME) { ECSetIMEMenu(hMenu, hwnd, state); } // BOGUS // We position the menu below & to the right of the point clicked on. // Is this cool? I think so. Excel 4.0 does the same thing. It // seems like it would be neat if we could avoid obscuring the // selection. But in actuality, it seems even more awkward to move // the menu out of the way of the selection. The user can't click // and drag that way, and they have to move the mouse a ton. // // We need to use TPM_NONOTIFY because VBRUN100 and VBRUN200 GP-fault // on unexpected menu messages. // /* * if message came via the keyboard then center on the control * We use -1 && -1 here not 0xFFFFFFFF like Win95 becuase we * previously converted the lParam to a point with sign extending. */ if (pt->x == -1 && pt->y == -1) { RECT rc; GetWindowRect(hwnd, &rc); x = rc.left + (rc.right - rc.left) / 2; y = rc.top + (rc.bottom - rc.top) / 2; } else { x = pt->x; y = pt->y; } cmd = NtUserTrackPopupMenuEx(GetSubMenu(hMenu, 0), TPM_NONOTIFY | TPM_LEFTALIGN | TPM_TOPALIGN | TPM_RETURNCMD | TPM_RIGHTBUTTON, x, y, hwnd, NULL); // Free our menu NtUserDestroyMenu(hMenu); if (cmd && (cmd != -1)) { if (ped->pLpkEditCallout && cmd) { ped->pLpkEditCallout->EditProcessMenu(ped, cmd); } if (!state.fIME || !ECDoIMEMenuCommand(ped, cmd, hwnd)) { // if cmd is not IME specific menu, send it. SendMessage(hwnd, cmd, 0, (cmd == EM_SETSEL) ? 0xFFFFFFFF : 0L ); } } }

void ECMergeUndoInsertInfo (  PUNDO  pundo, ICH  ichInsert, ICH  cchInsert )

Definition at line 1996 of file editec.c. References NULL, UNDO_DELETE, UNDO_INSERT, UNDO_NONE, and UserGlobalFree. Referenced by ECInsertText(). { // // If undo buffer is empty, just insert the new info as UNDO_INSERT // if (pundo->undoType == UNDO_NONE) { pundo->undoType = UNDO_INSERT; pundo->ichInsStart = ichInsert; pundo->ichInsEnd = ichInsert+cchInsert; } else if (pundo->undoType & UNDO_INSERT) { // // If there's already some undo insert info, // try to merge the two. // if (pundo->ichInsEnd == ichInsert) // Check they are adjacent. pundo->ichInsEnd += cchInsert; // if so, just concatenate. else { // The new insert is not contiguous with the old one. UNDOINSERT: // // If there is some UNDO_DELETE info already here, check to see // if the new insert takes place at a point different from where // that deletion occurred. // if ((pundo->undoType & UNDO_DELETE) && (pundo->ichDeleted != ichInsert)) { // // User is inserting into a different point; So, let us // forget any UNDO_DELETE info; // if (pundo->hDeletedText) UserGlobalFree(pundo->hDeletedText); pundo->hDeletedText = NULL; pundo->ichDeleted = 0xFFFFFFFF; pundo->undoType &= ~UNDO_DELETE; } // Since the old insert and new insert are not adjacent, let us // forget everything about the old insert and keep just the new // insert info as the UNDO_INSERT. pundo->ichInsStart = ichInsert; pundo->ichInsEnd = ichInsert + cchInsert; pundo->undoType |= UNDO_INSERT; } } else if (pundo->undoType == UNDO_DELETE) { // If there is some Delete Info already present go and handle it. goto UNDOINSERT; } }

ICH ECNextIch (  PED  ped, LPSTR  pStart, ICH  ichCurrent )

Definition at line 3969 of file editec.c. References ECIsDBCSLeadByte(), ECLock(), ECUnlock(), tagED::fAnsi, tagED::fDBCS, and ICH. Referenced by MLBuildchLines(), MLDeleteText(), MLMoveSelection(), and SLKeyDown(). { if (!ped->fDBCS || !ped->fAnsi) { return (ichCurrent + 1); } else { ICH ichRet; LPSTR pText; if (pStart) pText = pStart + ichCurrent; else pText = (LPSTR)ECLock(ped) + ichCurrent; ichRet = ichCurrent + ( ECIsDBCSLeadByte(ped, *pText) ? 2 : 1 ); if (!pStart) ECUnlock(ped); return (ichRet); } }

void ECNotifyParent (  PED  ped, int  notificationCode )

Definition at line 2429 of file editec.c. References DWORD, tagED::hwnd, tagED::hwndParent, PTR_TO_ID, tagED::pwnd, SendMessage(), and tagWND::spmenu. Referenced by ECImeComposition(), ECResetTextInfo(), ECSetText(), EditWndProc(), MLDeleteText(), MLInsertchLine(), MLInsertCrCrLf(), MLInsertText(), MLKillFocus(), MLScroll(), MLSetFocus(), SLChar(), SLInsertText(), SLKeyDown(), SLKillFocus(), SLPaste(), SLReplaceSel(), SLSetFocus(), and SLUndo(). { /* * wParam is NotificationCode (hiword) and WindowID (loword) * lParam is HWND of control sending the message * Windows 95 checks for hwndParent != NULL before sending the message, but * this is surely rare, and SendMessage NULL hwnd does nowt anyway (IanJa) */ SendMessage(ped->hwndParent, WM_COMMAND, (DWORD)MAKELONG(PTR_TO_ID(ped->pwnd->spmenu), notificationCode), (LPARAM)ped->hwnd); }

ICH ECPrevIch (  PED  ped, LPSTR  pStart, ICH  ichCurrent )

Definition at line 4001 of file editec.c. References ECIsDBCSLeadByte(), ECLock(), ECUnlock(), tagED::fAnsi, tagED::fDBCS, ICH, and tagED::pLpkEditCallout. Referenced by MLMoveSelection(), SLChar(), and SLKeyDown(). { LPSTR lpCurrent; LPSTR lpStr; LPSTR lpBase; #ifdef SURROGATE // Handle Unicode surrogates pairs when CSLPK is loaded if (ped->fAnsi || !ped->pLpkEditCallout) // if no surrogate processing required #endif if (!ped->fDBCS || !ped->fAnsi) if ( ichCurrent ) return (ichCurrent - 1); else return (ichCurrent); if (ichCurrent <= 1) return 0; if (pStart) lpBase = pStart; else lpBase = ECLock(ped); #ifdef SURROGATE // Handle characters represented by multiple codepoints if (ped->fAnsi) { // ANSI PrevIch with DBCS support #endif lpStr = lpBase + ichCurrent; lpCurrent = lpStr - 1; if (ECIsDBCSLeadByte(ped,*lpCurrent)) { if (!pStart) ECUnlock(ped); return (ichCurrent - 2); } do { lpCurrent--; if (!ECIsDBCSLeadByte(ped, *lpCurrent)) { lpCurrent++; break; } } while(lpCurrent != lpBase); if (!pStart) ECUnlock(ped); return (ichCurrent - (((lpStr - lpCurrent) & 1) ? 1 : 2)); #ifdef SURROGATE } else { // Unicode PrevIch with surrogate pair support ichCurrent--; if ( (((WCHAR*)lpBase)[ichCurrent] & 0xFC00) == 0xDC00 && (((WCHAR*)lpBase)[ichCurrent-1] & 0xFC00) == 0xD800) { ichCurrent--; } if (!pStart) ECUnlock(ped); return ichCurrent; } #endif }

void ECReleaseEditDC (  PED  ped, HDC  hdc, BOOL  fFastDC )

Definition at line 2524 of file editec.c. References tagED::hwnd, NtUserShowCaret(), and ReleaseDC(). Referenced by ECCreate(), ECDeleteText(), ECImeComposition(), ECInsertText(), ECSetCaretHandler(), ECSetPasswordChar(), EditWndProc(), MLBuildchLines(), MLCalcXOffset(), MLDeleteText(), MLEditWndProc(), MLEnsureCaretVisible(), MLInsertText(), MLKeyDown(), MLKillFocus(), MLMouseMotion(), MLMoveSelectionRestricted(), MLScroll(), MLSetFocus(), MLSetSelection(), NextWordLpkCallBack(), SLChar(), SLEditWndProc(), SLInsertText(), SLKeyDown(), SLMouseMotion(), SLMoveSelectionRestricted(), SLPaste(), SLReplaceSel(), SLSetFocus(), and SLSetSelection(). { /* * Restoring font not necessary */ ReleaseDC(ped->hwnd, hdc); if (!fFastDC) NtUserShowCaret(ped->hwnd); }

void ECResetTextInfo (  PED  ped  )

Definition at line 2547 of file editec.c. References _IsWindowVisible(), BOOL, tagED::cLines, ECEmptyUndo(), ECInvalidateClient(), ECNotifyParent(), FALSE, tagED::fDirty, tagED::fSingle, tagED::fWin31Compat, FWINABLE, HW, tagED::hwnd, tagED::iCaretLine, tagED::ichCaret, tagED::ichLinesOnScreen, tagED::ichMaxSel, tagED::ichMinSel, tagED::ichScreenStart, tagED::listboxHwnd, MLBuildchLines(), MLStripCrCrLf(), NotifyWinEvent(), NULL, Pundo, tagED::pwnd, UpdateWindow(), and tagED::xOffset. Referenced by ECSetText(), and MLSetHandle(). { // // Reset caret, selections, scrolling, and dirty information. // ped->iCaretLine = ped->ichCaret = 0; ped->ichMinSel = ped->ichMaxSel = 0; ped->xOffset = ped->ichScreenStart = 0; ped->fDirty = FALSE; ECEmptyUndo(Pundo(ped)); if (ped->fSingle) { if (!ped->listboxHwnd) ECNotifyParent(ped, EN_UPDATE); } else { #ifdef BOGUS // B#14640 // We don't want to strip soft breaks or anything else from text // that was passed in by the caller. - karlst. MLStripCrCrLf(ped); #endif MLBuildchLines(ped, 0, 0, FALSE, NULL, NULL); } if (_IsWindowVisible(ped->pwnd)) { BOOL fErase; if (ped->fSingle) fErase = FALSE; else fErase = ((ped->ichLinesOnScreen + ped->ichScreenStart) >= ped->cLines); // Always redraw whether or not the insert was successful. We might // have NULL text. Paint() will check the redraw flag for us. ECInvalidateClient(ped, fErase); // BACKWARD COMPAT HACK: RAID expects the text to have been updated, // so we have to do an UpdateWindow here. It moves an edit control // around with fRedraw == FALSE, so it'll never get the paint message // with the control in the right place. if (!ped->fWin31Compat) UpdateWindow(ped->hwnd); } if (ped->fSingle && !ped->listboxHwnd) ECNotifyParent(ped, EN_CHANGE); if (FWINABLE()) { NotifyWinEvent(EVENT_OBJECT_VALUECHANGE, HW(ped->pwnd), OBJID_CLIENT, INDEXID_CONTAINER); } }

void ECSaveUndo (  PUNDO  pundoFrom, PUNDO  pundoTo, BOOL  fClear )

Definition at line 1955 of file editec.c. References PUNDO, and UNDO. Referenced by MLInsertText(), MLReplaceSel(), and SLReplaceSel(). { /* * Save undo data */ RtlCopyMemory(pundoTo, pundoFrom, sizeof(UNDO)); /* * Clear passed in undo buffer */ if (fClear) RtlZeroMemory(pundoFrom, sizeof(UNDO) ); }

void ECSetEditClip (  PED  ped, HDC  hdc, BOOL  fLeftMargin )

Definition at line 2452 of file editec.c. References _GetClientRect(), CopyRect, tagED::fFlatBorder, tagED::fWrap, InflateRect(), IntersectRect(), tagED::pLpkEditCallout, tagED::pwnd, tagED::rcFmt, SYSMET, tagED::wLeftMargin, and tagED::wRightMargin. Referenced by ECGetEditDC(), MLPaint(), MLScroll(), and SLDrawLine(). { RECT rcClient; RECT rcClip; CopyRect(&rcClip, &ped->rcFmt); if (ped->pLpkEditCallout) { // Complex script handling chooses whether to write margins later rcClip.left -= ped->wLeftMargin; rcClip.right += ped->wRightMargin; } else { if (fLeftMargin) /* Should we consider the left margin? */ rcClip.left -= ped->wLeftMargin; if (ped->fWrap) /* Should we consider the right margin? */ rcClip.right += ped->wRightMargin; } /* Set clip rectangle to rectClient intersect rectClip */ /* We must clip for single line edits also. -- B#1360 */ _GetClientRect(ped->pwnd, &rcClient); if (ped->fFlatBorder) InflateRect(&rcClient, -SYSMET(CXBORDER), -SYSMET(CYBORDER)); IntersectRect(&rcClient, &rcClient, &rcClip); IntersectClipRect(hdc,rcClient.left, rcClient.top, rcClient.right, rcClient.bottom); }

BOOL ECSetIMEMenu (  HMENU  hMenu, HWND  hwnd, EditMenuItemState  state )

Definition at line 278 of file editec.c. References BOOL, DWORD, FALSE, EditMenuItemState::fDisableCut, EditMenuItemState::fIME, EditMenuItemState::fNeedSeparatorBeforeImeMenu, fpImmGetContext, fpImmGetConversionStatus, fpImmGetOpenStatus, fpImmGetProperty, fpImmIsIME, fpImmReleaseContext, GetMenuItemCount(), GetSubMenu(), hmodUser, ID_IMEOPENCLOSE, ID_RECONVERTSTRING, ID_SOFTKBDOPENCLOSE, InsertMenuItem(), IS_IME_ENABLED, NtUserDeleteMenu(), NULL, STR_IMECLOSE, STR_IMEOPEN, STR_RECONVERTSTRING, STR_SOFTKBDCLOSE, STR_SOFTKBDOPEN, THREAD_HKL, and TRUE. Referenced by ECMenu(). { MENUITEMINFO mii; HIMC hIMC; HKL hKL; HMENU hmenuSub; WCHAR szRes[32]; int nPrevLastItem; int nItemsAdded = 0; UserAssert(IS_IME_ENABLED() && state.fIME); hKL = THREAD_HKL(); if (!fpImmIsIME(hKL)) return TRUE; hIMC = fpImmGetContext(hwnd); if (hIMC == NULL) { // early out return FALSE; } hmenuSub = GetSubMenu(hMenu, 0); if (hmenuSub == NULL) { return FALSE; } nPrevLastItem = GetMenuItemCount(hmenuSub); if (hIMC) { if (LOWORD(HandleToUlong(hKL)) != 0x412) { // // If Korean, do not show open/close menus // if (fpImmGetOpenStatus(hIMC)) LoadString(hmodUser, STR_IMECLOSE, szRes, sizeof(szRes)); else LoadString(hmodUser, STR_IMEOPEN, szRes, sizeof(szRes)); mii.cbSize = sizeof(MENUITEMINFO); mii.fMask = MIIM_STRING | MIIM_ID; mii.dwTypeData = szRes; mii.cch = 0xffff; mii.wID = ID_IMEOPENCLOSE; InsertMenuItem(hmenuSub, 0xffff, TRUE, &mii); ++nItemsAdded; } if (fpImmGetProperty(hKL, IGP_CONVERSION) & IME_CMODE_SOFTKBD) { DWORD fdwConversion; fpImmGetConversionStatus(hIMC, &fdwConversion, NULL); if (fdwConversion & IME_CMODE_SOFTKBD) LoadString(hmodUser, STR_SOFTKBDCLOSE, szRes, sizeof(szRes)); else LoadString(hmodUser, STR_SOFTKBDOPEN, szRes, sizeof(szRes)); mii.cbSize = sizeof(MENUITEMINFO); mii.fMask = MIIM_STRING | MIIM_ID; mii.dwTypeData = szRes; mii.cch = 0xffff; mii.wID = ID_SOFTKBDOPENCLOSE; InsertMenuItem(hmenuSub, 0xffff, TRUE, &mii); ++nItemsAdded; } if (LOWORD(HandleToUlong(hKL)) != 0x412) { // // If Korean, do not show reconversion menus // DWORD dwSCS = fpImmGetProperty(hKL, IGP_SETCOMPSTR); LoadString(hmodUser, STR_RECONVERTSTRING, szRes, sizeof(szRes)); mii.cbSize = sizeof(MENUITEMINFO); mii.fMask = MIIM_STRING | MIIM_ID | MIIM_STATE; mii.dwTypeData = szRes; mii.fState = 0; mii.cch = 0xffff; mii.wID = ID_RECONVERTSTRING; if (state.fDisableCut || !(dwSCS & SCS_CAP_SETRECONVERTSTRING) || !(dwSCS & SCS_CAP_MAKEREAD)) { mii.fState |= MFS_GRAYED; } InsertMenuItem(hmenuSub, 0xffff, TRUE, &mii); ++nItemsAdded; } } // // Add or remove the menu separator // if (state.fNeedSeparatorBeforeImeMenu && nItemsAdded != 0) { // // If the menu for Middle East has left a separator, // fNeedSeparatorBeforeImeMenu is FALSE. // I.e. we don't need to add more. // mii.cbSize = sizeof(MENUITEMINFO); mii.fMask = MIIM_FTYPE; mii.fType = MFT_SEPARATOR; InsertMenuItem(hmenuSub, nPrevLastItem, TRUE, &mii); } else if (!state.fNeedSeparatorBeforeImeMenu && nItemsAdded == 0) { // // Extra separator is left by ME menus. Remove it. // UserVerify(NtUserDeleteMenu(hmenuSub, nPrevLastItem - 1, MF_BYPOSITION)); } fpImmReleaseContext(hwnd, hIMC); return TRUE; }

BOOL ECSetText (  PED  ped, LPSTR  lpstr )

Definition at line 2612 of file editec.c. References BOOL, tagED::cbChar, tagED::cch, tagED::cchAlloc, CCHALLOCEXTRA, ECInsertText(), ECNotifyParent(), ECResetTextInfo(), FALSE, tagED::fAnsi, tagED::fSingle, tagED::hInstance, tagED::hText, tagED::hwnd, ICH, tagED::ichCaret, IsWindow(), LHND, LOCALREALLOC, LOCALSIZE, min, NULL, StringLength(), and TRUE. Referenced by EditWndProc(), MLCreate(), and SLCreate(). { ICH cchLength; ICH cchSave = ped->cch; ICH ichCaretSave = ped->ichCaret; HWND hwndSave = ped->hwnd; HANDLE hText; ped->cch = ped->ichCaret = 0; ped->cchAlloc = LOCALSIZE(ped->hText, ped->hInstance) / ped->cbChar; if (!lpstr) { hText = LOCALREALLOC(ped->hText, CCHALLOCEXTRA*ped->cbChar, LHND, ped->hInstance, &lpstr); if (hText != NULL) { ped->hText = hText; } else { return FALSE; } } else { cchLength = StringLength(lpstr, ped->fAnsi); #ifdef NEVER // win3.1 does limit single line edit controls to 32K (minus 3) but NT doesn't if (ped->fSingle) { /* * Limit single line edit controls to 32K */ cchLength = min(cchLength, (ICH)(0x7FFD/ped->cbChar)); } #endif /* * Add the text */ if (cchLength && !ECInsertText(ped, lpstr, &cchLength)) { /* * Restore original state and notify parent we ran out of memory. */ ped->cch = cchSave; ped->ichCaret = ichCaretSave; ECNotifyParent(ped, EN_ERRSPACE); return FALSE; } } ped->cchAlloc = LOCALSIZE(ped->hText, ped->hInstance) / ped->cbChar; if (IsWindow(hwndSave)) ECResetTextInfo(ped); return TRUE; }

UINT ECTabTheTextOut (  HDC  hdc, int  xClipStPos, int  xClipEndPos, int  xStart, int  y, LPSTR  lpstring, int  nCount, ICH  ichString, PED  ped, int  iTabOrigin, BOOL  fDraw, LPSTRIPINFO  NegCInfoForStrip )

Definition at line 770 of file editec.c. References tagED::aveCharWidth, BOOL, tagED::cbChar, CHAR_WIDTH_BUFFER_LENGTH, tagED::charOverhang, tagED::charWidthBuffer, ECFindTabA(), ECFindTabW(), ECIsDBCSLeadByte(), ECT_SELECTED, FALSE, tagED::fAnsi, tagED::fDBCS, tagED::fTrueType, GetActualNegA(), STRIPINFO::ichString, INT, L, tagED::lineHeight, STRIPINFO::lpString, max, MAXCLIPENDPOS, MAXLINELENGTH, min, STRIPINFO::nCount, NULL, PINT, tagED::pTabStops, TRUE, UINT, tagED::wMaxNegA, tagED::wMaxNegC, and STRIPINFO::XStartPos. Referenced by ECCchInWidth(), MLDrawText(), and MLGetLineWidth(). { int nTabPositions; // Count of tabstops in tabstop array. LPINT lpintTabStopPositions; // Tab stop positions in pixels. int cch; UINT textextent; int xEnd; int pixeltabstop = 0; int i; int cxCharWidth; RECT rc; BOOL fOpaque; BOOL fFirstPass = TRUE; PINT charWidthBuff; int iTabLength; int nConsecutiveTabs; int xStripStPos; int xStripEndPos; int xEndOfStrip; STRIPINFO RedrawStripInfo; STRIPINFO NegAInfo; LPSTR lpTab; LPWSTR lpwTab; UINT wNegCwidth, wNegAwidth; int xRightmostPoint = xClipStPos; int xTabStartPos; int iSavedBkMode = 0; WCHAR wchar; SIZE size; ABC abc ; // Algorithm: Draw the strip opaquely first. If a tab length is so // small that the portions of text on either side of a tab overlap with // the other, then this will result in some clipping. So, such portion // of the strip is remembered in "RedrawStripInfo" and redrawn // transparently later to compensate the clippings. // NOTE: "RedrawStripInfo" can hold info about just one portion. So, if // more than one portion of the strip needs to be redrawn transparently, // then we "merge" all such portions into a single strip and redraw that // strip at the end. if (fDraw) { // To begin with, let us assume that there is no Negative C for this // strip and initialize the Negative Width Info structure. NegCInfoForStrip->nCount = 0; NegCInfoForStrip->XStartPos = xClipEndPos; // We may not have to redraw any portion of this strip. RedrawStripInfo.nCount = 0; fOpaque = (GetBkMode(hdc) == OPAQUE) || (fDraw == ECT_SELECTED); } #if DBG else { // // Both MLGetLineWidth() and ECCchInWidth() should be clipping // nCount to avoid overflow. // if (nCount > MAXLINELENGTH) RIPMSG0(RIP_WARNING, "ECTabTheTextOut: nCount > MAXLINELENGTH"); } #endif // Let us define the Clip rectangle. rc.left = xClipStPos; rc.right = xClipEndPos; rc.top = y; rc.bottom = y + ped->lineHeight; // Check if anything needs to be drawn. if (!lpstring || !nCount) { if (fDraw) ExtTextOutW(hdc, xClipStPos, y, (fOpaque ? ETO_OPAQUE | ETO_CLIPPED : ETO_CLIPPED), &rc, L"", 0, 0L); return(0L); } // // Starting position // xEnd = xStart; cxCharWidth = ped->aveCharWidth; nTabPositions = (ped->pTabStops ? *(ped->pTabStops) : 0); if (ped->pTabStops) { lpintTabStopPositions = (LPINT)(ped->pTabStops+1); if (nTabPositions == 1) { pixeltabstop = lpintTabStopPositions[0]; if (!pixeltabstop) pixeltabstop = 1; } } else { lpintTabStopPositions = NULL; pixeltabstop = 8*cxCharWidth; } // The first time we will draw the strip Opaquely. If some portions need // to be redrawn , then we will set the mode to TRANSPARENT and // jump to this location to redraw those portions. RedrawStrip: while (nCount) { wNegCwidth = ped->wMaxNegC; // Search for the first TAB in this strip; also compute the extent // of the the strip upto and not including the tab character. // // Note - If the langpack is loaded, there will be no charWidthBuffer. // if (ped->charWidthBuffer) { // Do we have a character width buffer? textextent = 0; cch = nCount; if (ped->fTrueType) { // If so, does it have ABC widths? UINT iRightmostPoint = 0; UINT wCharIndex; PABC pABCwidthBuff; pABCwidthBuff = (PABC) ped->charWidthBuffer; if ( ped->fAnsi ) { for (i = 0; i < nCount; i++) { if (lpstring[i] == VK_TAB) { cch = i; break; } wCharIndex = (UINT)(((unsigned char *)lpstring)[i]); if (wCharIndex < CHAR_WIDTH_BUFFER_LENGTH) { textextent += (UINT)(pABCwidthBuff[wCharIndex].abcA + pABCwidthBuff[wCharIndex].abcB); } else { // not in cache, will ask driver GetCharABCWidthsA(hdc, wCharIndex, wCharIndex, &abc); textextent += abc.abcA + abc.abcB ; } if (textextent > iRightmostPoint) iRightmostPoint = textextent; if (wCharIndex < CHAR_WIDTH_BUFFER_LENGTH) { textextent += pABCwidthBuff[wCharIndex].abcC; } else { // not in cache textextent += abc.abcC; } if (textextent > iRightmostPoint) iRightmostPoint = textextent; } } else { // Unicode for (i = 0; i < nCount; i++) { WCHAR UNALIGNED * lpwstring = (WCHAR UNALIGNED *)lpstring; if (lpwstring[i] == VK_TAB) { cch = i; break; } wCharIndex = lpwstring[i] ; if ( wCharIndex < CHAR_WIDTH_BUFFER_LENGTH ) textextent += pABCwidthBuff[wCharIndex].abcA + pABCwidthBuff[wCharIndex].abcB; else { GetCharABCWidthsW(hdc, wCharIndex, wCharIndex, &abc) ; textextent += abc.abcA + abc.abcB ; } /* * Note that abcC could be negative so we need this * statement here *and* below */ if (textextent > iRightmostPoint) iRightmostPoint = textextent; if ( wCharIndex < CHAR_WIDTH_BUFFER_LENGTH ) textextent += pABCwidthBuff[wCharIndex].abcC; else textextent += abc.abcC ; if (textextent > iRightmostPoint) iRightmostPoint = textextent; } } wNegCwidth = (int)(iRightmostPoint - textextent); } else { // !ped->fTrueType // No! This is not a TrueType font; So, we have only character // width info in this buffer. charWidthBuff = ped->charWidthBuffer; if ( ped->fAnsi ) { // Initially assume no tabs exist in the text so cch=nCount. for (i = 0; i < nCount; i++) { if (lpstring[i] == VK_TAB) { cch = i; break; } // // Call GetTextExtentPoint for dbcs/hankaku characters // if (ped->fDBCS && (i+1 < nCount) && ECIsDBCSLeadByte(ped,lpstring[i])) { GetTextExtentPointA(hdc, &lpstring[i], 2, &size); textextent += size.cx; i++; } else if ((UCHAR)lpstring[i] >= CHAR_WIDTH_BUFFER_LENGTH) { // Skip this GetExtentPoint call for non hankaku code points // Or if the character is in the width cache. GetTextExtentPointA(hdc, &lpstring[i], 1, &size); textextent += size.cx; } else { textextent += (UINT)(charWidthBuff[(UINT)(((unsigned char *)lpstring)[i])]); } } } else { LPWSTR lpwstring = (LPWSTR) lpstring ; INT cchUStart; // start of unicode character count for (i = 0; i < nCount; i++) { if (lpwstring[i] == VK_TAB) { cch = i; break; } wchar = lpwstring[i]; if (wchar >= CHAR_WIDTH_BUFFER_LENGTH) { /* * We have a Unicode character that is not in our * cache, get all the characters outside the cache * before getting the text extent on this part of the * string. */ cchUStart = i; while (wchar >= CHAR_WIDTH_BUFFER_LENGTH && wchar != VK_TAB && i < nCount) { wchar = lpwstring[++i]; } GetTextExtentPointW(hdc, (LPWSTR)lpwstring + cchUStart, i-cchUStart, &size); textextent += size.cx; if (wchar == VK_TAB || i >= nCount) { cch = i; break; } /* * We have a char that is in the cache, fall through. */ } /* * The width of this character is in the cache buffer. */ textextent += ped->charWidthBuffer[wchar]; } } } // fTrueType else. nCount -= cch; } else { // If we don't have a buffer that contains the width info. /* * Gotta call the driver to do our text extent. */ if ( ped->fAnsi ) { cch = (int)ECFindTabA(lpstring, nCount); GetTextExtentPointA(hdc, lpstring, cch, &size) ; } else { cch = (int)ECFindTabW((LPWSTR) lpstring, nCount); GetTextExtentPointW(hdc, (LPWSTR)lpstring, cch, &size); } nCount -= cch; // // Subtruct Overhang for Italic fonts. // textextent = (size.cx - ped->charOverhang); } // // textextent is computed. // xStripStPos = xEnd; xEnd += (int)textextent; xStripEndPos = xEnd; // We will consider the negative widths only if when we draw opaquely. if (fFirstPass && fDraw) { xRightmostPoint = max(xStripEndPos + (int)wNegCwidth, xRightmostPoint); // Check if this strip peeps beyond the clip region. if (xRightmostPoint > xClipEndPos) { if (!NegCInfoForStrip->nCount) { NegCInfoForStrip->lpString = lpstring; NegCInfoForStrip->ichString = ichString; NegCInfoForStrip->nCount = nCount+cch; NegCInfoForStrip->XStartPos = xStripStPos; } } } /* if (fFirstPass && fDraw) */ if ( ped->fAnsi ) lpTab = lpstring + cch; // Possibly Points to a tab character. else lpwTab = ((LPWSTR)lpstring) + cch ; // we must consider all the consecutive tabs and calculate the // the begining of next strip. nConsecutiveTabs = 0; while (nCount && (ped->fAnsi ? (*lpTab == VK_TAB) : (*lpwTab == VK_TAB))) { // Find the next tab position and update the x value. xTabStartPos = xEnd; if (pixeltabstop) xEnd = (((xEnd-iTabOrigin)/pixeltabstop)*pixeltabstop) + pixeltabstop + iTabOrigin; else { for (i = 0; i < nTabPositions; i++) { if (xEnd < (lpintTabStopPositions[i] + iTabOrigin)) { xEnd = (lpintTabStopPositions[i] + iTabOrigin); break; } } // Check if all the tabstops set are exhausted; Then start using // default tab stop positions. if (i == nTabPositions) { pixeltabstop = 8*cxCharWidth; xEnd = ((xEnd - iTabOrigin)/pixeltabstop)*pixeltabstop + pixeltabstop + iTabOrigin; } } if (fFirstPass && fDraw) { xRightmostPoint = max(xEnd, xRightmostPoint); /* Check if this strip peeps beyond the clip region */ if (xRightmostPoint > xClipEndPos) { if (!NegCInfoForStrip->nCount) { NegCInfoForStrip->ichString = ichString + cch + nConsecutiveTabs; NegCInfoForStrip->nCount = nCount; NegCInfoForStrip->lpString = (ped->fAnsi ? lpTab : (LPSTR) lpwTab); NegCInfoForStrip->XStartPos = xTabStartPos; } } } /* if(fFirstPass) */ nConsecutiveTabs++; nCount--; ped->fAnsi ? lpTab++ : (LPSTR) (lpwTab++) ; // Move to the next character. } // while(*lpTab == TAB) // if (fDraw) { if (fFirstPass) { // Is anything remaining to be drawn in this strip? if (!nCount) rc.right = xEnd; // No! We are done. else { // "x" is the effective starting position of next strip. iTabLength = xEnd - xStripEndPos; // Check if there is a possibility of this tab length being too small // compared to the negative A and C widths if any. if ((wNegCwidth + (wNegAwidth = ped->wMaxNegA)) > (UINT)iTabLength) { // Unfortunately, there is a possiblity of an overlap. // Let us find out the actual NegA for the next strip. wNegAwidth = GetActualNegA( hdc, ped, xEnd, lpstring + (cch + nConsecutiveTabs)*ped->cbChar, ichString + cch + nConsecutiveTabs, nCount, &NegAInfo); } // Check if they actually overlap // if ((wNegCwidth + wNegAwidth) <= (UINT)iTabLength) { // No overlap between the strips. This is the ideal situation. rc.right = xEnd - wNegAwidth; } else { // Yes! They overlap. rc.right = xEnd; // See if negative C width is too large compared to tab length. if (wNegCwidth > (UINT)iTabLength) { // Must redraw transparently a part of the current strip later. if (RedrawStripInfo.nCount) { // A previous strip also needs to be redrawn; So, merge this // strip to that strip. RedrawStripInfo.nCount = (ichString - RedrawStripInfo.ichString) + cch; } else { RedrawStripInfo.nCount = cch; RedrawStripInfo.lpString = lpstring; RedrawStripInfo.ichString = ichString; RedrawStripInfo.XStartPos = xStripStPos; } } if (wNegAwidth) { // Must redraw transparently the first part of the next strip later. if (RedrawStripInfo.nCount) { // A previous strip also needs to be redrawn; So, merge this // strip to that strip. RedrawStripInfo.nCount = (NegAInfo.ichString - RedrawStripInfo.ichString) + NegAInfo.nCount; } else RedrawStripInfo = NegAInfo; } } } // else (!nCount) // } // if (fFirstPass) // if (rc.left < xClipEndPos) { if (fFirstPass) { // If this is the end of the strip, then complete the rectangle. if ((!nCount) && (xClipEndPos == MAXCLIPENDPOS)) rc.right = max(rc.right, xClipEndPos); else rc.right = min(rc.right, xClipEndPos); } // Draw the current strip. if (rc.left < rc.right) if ( ped->fAnsi ) ExtTextOutA(hdc, xStripStPos, y, (fFirstPass && fOpaque ? (ETO_OPAQUE | ETO_CLIPPED) : ETO_CLIPPED), (LPRECT)&rc, lpstring, cch, 0L); else ExtTextOutW(hdc, xStripStPos, y, (fFirstPass && fOpaque ? (ETO_OPAQUE | ETO_CLIPPED) : ETO_CLIPPED), (LPRECT)&rc, (LPWSTR)lpstring, cch, 0L); } if (fFirstPass) rc.left = max(rc.right, xClipStPos); ichString += (cch+nConsecutiveTabs); } // if (fDraw) // // Skip over the tab and the characters we just drew. lpstring += (cch + nConsecutiveTabs) * ped->cbChar; } // while (nCount) // xEndOfStrip = xEnd; // check if we need to draw some portions transparently. if (fFirstPass && fDraw && RedrawStripInfo.nCount) { iSavedBkMode = SetBkMode(hdc, TRANSPARENT); fFirstPass = FALSE; nCount = RedrawStripInfo.nCount; rc.left = xClipStPos; rc.right = xClipEndPos; lpstring = RedrawStripInfo.lpString; ichString = RedrawStripInfo.ichString; xEnd = RedrawStripInfo.XStartPos; goto RedrawStrip; // Redraw Transparently. } if (iSavedBkMode) // Did we change the Bk mode? SetBkMode(hdc, iSavedBkMode); // Then, let us set it back! return((UINT)(xEndOfStrip - xStart)); }

void ECUnlock (  PED  ped  )

Definition at line 86 of file editec.c. References tagED::cbChar, tagED::cch, tagED::charPasswordChar, tagED::fEncoded, tagED::hInstance, tagED::hText, tagED::iLockLevel, LOCALLOCK, LOCALUNLOCK, RtlRunEncodeUnicodeString(), tagED::seed, TRUE, and USHORT. Referenced by ECCopy(), ECDeleteText(), ECDoIMEMenuCommand(), ECGetText(), EcImeRequestHandler(), ECInsertText(), ECNextIch(), ECPrevIch(), ECSetCaretHandler(), ECWord(), HanjaKeyHandler(), MLBuildchLines(), MLCalcXOffset(), MLDrawText(), MLEditWndProc(), MLGetLine(), MLIchToXYPos(), MLIchToYPos(), MLInsertCrCrLf(), MLKeyDown(), MLLine(), MLMouseMotion(), MLMouseToIch(), MLMoveSelection(), MLMoveSelectionRestricted(), MLSetHandle(), MLSetSelection(), MLStripCrCrLf(), MLUpdateiCaretLine(), NextWordCallBack(), NextWordLpkCallBack(), SLCalcStringWidth(), SLCalcXOffsetSpecial(), SLChangeSelection(), SLDrawLine(), SLDrawText(), SLGetClipRect(), SLIchToLeftXPos(), SLInsertText(), SLMouseMotion(), SLMouseToIch(), SLMoveSelectionRestricted(), and SLScrollText(). { /* * if we are removing the last lock on the text and the password * character is set then encode the text */ //RIPMSG1(RIP_VERBOSE, "unlock: %d '%10s'\n", ped->iLockLevel, ped->ptext); if (ped->charPasswordChar && ped->iLockLevel == 1 && ped->cch != 0) { UNICODE_STRING string; string.Length = string.MaximumLength = (USHORT)(ped->cch * ped->cbChar); string.Buffer = LOCALLOCK(ped->hText, ped->hInstance); RtlRunEncodeUnicodeString(&(ped->seed), &string); //RIPMSG1(RIP_VERBOSE, "Encoding: '%10s'\n", ped->ptext); ped->fEncoded = TRUE; LOCALUNLOCK(ped->hText, ped->hInstance); } LOCALUNLOCK(ped->hText, ped->hInstance); ped->iLockLevel--; }

void ECUpdateFormat (  PED  ped, DWORD  dwStyle, DWORD  dwExStyle )

Definition at line 4185 of file editec.c. References ECInvalidateClient(), FALSE, tagED::format, tagED::fRtoLReading, tagED::fWrap, MLBuildchLines(), MLScroll(), MLUpdateiCaretLine(), NULL, TRUE, and UINT. Referenced by MLEditWndProc(), and SLEditWndProc(). { UINT fNewRtoLReading; UINT uiNewFormat; // Extract new format and reading order from style fNewRtoLReading = dwExStyle & WS_EX_RTLREADING ? 1 : 0; uiNewFormat = dwStyle & ES_FMTMASK; // WS_EX_RIGHT is ignored unless dwStyle is ES_LEFT if (uiNewFormat == ES_LEFT && dwExStyle & WS_EX_RIGHT) { uiNewFormat = ES_RIGHT; } // Internally ES_LEFT and ES_RIGHT are swapped for RtoLReading order // (Think of them as ES_LEADING and ES_TRAILING) if (fNewRtoLReading) { switch (uiNewFormat) { case ES_LEFT: uiNewFormat = ES_RIGHT; break; case ES_RIGHT: uiNewFormat = ES_LEFT; break; } } // Format change does not cause redisplay by itself ped->format = uiNewFormat; // Refresh display on change of reading order if (fNewRtoLReading != ped->fRtoLReading) { ped->fRtoLReading = fNewRtoLReading; if (ped->fWrap) { // Redo wordwrap MLBuildchLines(ped, 0, 0, FALSE, NULL, NULL); MLUpdateiCaretLine(ped); } else { // Refresh horizontal scrollbar display MLScroll(ped, FALSE, 0xffffffff, 0, TRUE); } ECInvalidateClient(ped, TRUE); } }

void ECWord (  PED  ped, ICH  ichStart, BOOL  fLeft, ICH *  pichMin, ICH *  pichMax )

Definition at line 1552 of file editec.c. References BOOL, tagED::cbChar, tagED::cch, CHAR, tagED::charPasswordChar, ECAnsiNext(), ECAnsiPrev(), ECIsDBCSLeadByte(), ECLock(), ECUnlock(), FALSE, tagED::fAnsi, ICH, ISDELIMETERA, ISDELIMETERW, tagED::lpfnNextWord, min, NextWordCallBack(), NextWordLpkCallBack(), tagED::pLpkEditCallout, TRUE, and UserIsFullWidth(). Referenced by MLBuildchLines(), MLKeyDown(), MLMouseMotion(), SLKeyDown(), and SLMouseMotion(). { BOOL charLocated = FALSE; BOOL spaceLocated = FALSE; if ((!ichStart && fLeft) || (ichStart == ped->cch && !fLeft)) { /* * We are at the beginning of the text (looking left) or we are at end * of text (looking right), no word here */ if (pichMin) *pichMin=0; if (pichMax) *pichMax=0; return; } /* * Don't give out hints about word breaks if password chars are being used, */ if (ped->charPasswordChar) { if (pichMin) *pichMin=0; if (pichMax) *pichMax=ped->cch; return; } if (ped->fAnsi) { PSTR pText; PSTR pWordMinSel; PSTR pWordMaxSel; PSTR pPrevChar; UserAssert(ped->cbChar == sizeof(CHAR)); if (ped->lpfnNextWord) { NextWordCallBack(ped, ichStart, fLeft, pichMin, pichMax); return; } if (ped->pLpkEditCallout) { NextWordLpkCallBack(ped, ichStart, fLeft, pichMin, pichMax); return; } pText = ECLock(ped); pWordMinSel = pWordMaxSel = pText + ichStart; /* * if fLeft: Move pWordMinSel to the left looking for the start of a word. * If we start at a space, we will include spaces in the selection as we * move left untill we find a nonspace character. At that point, we continue * looking left until we find a space. Thus, the selection will consist of * a word with its trailing spaces or, it will consist of any leading at the * beginning of a line of text. */ /* * if !fLeft: (ie. right word) Move pWordMinSel looking for the start of a * word. If the pWordMinSel points to a character, then we move left * looking for a space which will signify the start of the word. If * pWordMinSel points to a space, we look right till we come upon a * character. pMaxWord will look right starting at pMinWord looking for the * end of the word and its trailing spaces. */ if (fLeft || !ISDELIMETERA(*pWordMinSel) && *pWordMinSel != 0x0D) { /* * If we are moving left or if we are moving right and we are not on a * space or a CR (the start of a word), then we was look left for the * start of a word which is either a CR or a character. We do this by * looking left till we find a character (or if CR we stop), then we * continue looking left till we find a space or LF. */ while (pWordMinSel > pText && ((!ISDELIMETERA(*(pWordMinSel - 1)) && *(pWordMinSel - 1) != 0x0A) || !charLocated)) { /* * Treat double byte character as a word ( in ansi pWordMinSel loop ) */ pPrevChar = ECAnsiPrev( ped, pText, pWordMinSel ); /* ** we are looking right ( !fLeft ). ** if current character is a double byte chararacter or ** previous character is a double byte character, we ** are on the beggining of a word. */ if ( !fLeft && ( ISDELIMETERA( *pPrevChar ) || *pPrevChar == 0x0A || ECIsDBCSLeadByte(ped, *pWordMinSel) || pWordMinSel - pPrevChar == 2 ) ) { /* * If we are looking for the start of the word right, then we * stop when we have found it. (needed in case charLocated is * still FALSE) */ break; } if ( pWordMinSel - pPrevChar == 2 ) { /* ** previous character is a double byte character. ** if we are in a word ( charLocated == TRUE ) ** current position is the beginning of the word ** if we are not in a word ( charLocated == FALSE ) ** the previous character is what we looking for. */ if ( ! charLocated ) { pWordMinSel = pPrevChar; } break; } pWordMinSel = pPrevChar; if (!ISDELIMETERA(*pWordMinSel) && *pWordMinSel != 0x0A) { /* * We have found the last char in the word. Continue looking * backwards till we find the first char of the word */ charLocated = TRUE; /* * We will consider a CR the start of a word */ if (*pWordMinSel == 0x0D) break; } } } else { while ((ISDELIMETERA(*pWordMinSel) || *pWordMinSel == 0x0A) && pWordMinSel < pText + ped->cch) pWordMinSel++; } /* * Adjust the initial position of pWordMaxSel ( in ansi ) */ pWordMaxSel = ECAnsiNext(ped, pWordMinSel); pWordMaxSel = min(pWordMaxSel, pText + ped->cch); /* ** If pWordMinSel points a double byte character AND ** pWordMaxSel points non space ** then ** pWordMaxSel points the beggining of next word. */ if ( ( pWordMaxSel - pWordMinSel == 2 ) && ! ISDELIMETERA(*pWordMaxSel) ) goto FastReturnA; if (*pWordMinSel == 0x0D) { if (pWordMinSel > pText && *(pWordMinSel - 1) == 0x0D) /* So that we can treat CRCRLF as one word also. */ pWordMinSel--; else if (*(pWordMinSel + 1) == 0x0D) /* Move MaxSel on to the LF */ pWordMaxSel++; } /* * Check if we have a one character word */ if (ISDELIMETERA(*pWordMaxSel)) spaceLocated = TRUE; /* * Move pWordMaxSel to the right looking for the end of a word and its * trailing spaces. WordMaxSel stops on the first character of the next * word. Thus, we break either at a CR or at the first nonspace char after * a run of spaces or LFs. */ while ((pWordMaxSel < pText + ped->cch) && (!spaceLocated || (ISDELIMETERA(*pWordMaxSel)))) { if (*pWordMaxSel == 0x0D) break; /* * Treat double byte character as a word ( in ansi pWordMaxSel loop ) */ /* ** if it's a double byte character then ** we are at the beginning of next word ** which is a double byte character. */ if (ECIsDBCSLeadByte( ped, *pWordMaxSel)) break; pWordMaxSel++; if (ISDELIMETERA(*pWordMaxSel)) spaceLocated = TRUE; if (*(pWordMaxSel - 1) == 0x0A) break; } /* * label for fast return ( for Ansi ) */ FastReturnA: ECUnlock(ped); if (pichMin) *pichMin = (ICH)(pWordMinSel - pText); if (pichMax) *pichMax = (ICH)(pWordMaxSel - pText); return; } else { // !fAnsi LPWSTR pwText; LPWSTR pwWordMinSel; LPWSTR pwWordMaxSel; BOOL charLocated = FALSE; BOOL spaceLocated = FALSE; PWSTR pwPrevChar; UserAssert(ped->cbChar == sizeof(WCHAR)); if (ped->lpfnNextWord) { NextWordCallBack(ped, ichStart, fLeft, pichMin, pichMax); return; } if (ped->pLpkEditCallout) { NextWordLpkCallBack(ped, ichStart, fLeft, pichMin, pichMax); return; } pwText = (LPWSTR)ECLock(ped); pwWordMinSel = pwWordMaxSel = pwText + ichStart; /* * if fLeft: Move pWordMinSel to the left looking for the start of a word. * If we start at a space, we will include spaces in the selection as we * move left untill we find a nonspace character. At that point, we continue * looking left until we find a space. Thus, the selection will consist of * a word with its trailing spaces or, it will consist of any leading at the * beginning of a line of text. */ /* * if !fLeft: (ie. right word) Move pWordMinSel looking for the start of a * word. If the pWordMinSel points to a character, then we move left * looking for a space which will signify the start of the word. If * pWordMinSel points to a space, we look right till we come upon a * character. pMaxWord will look right starting at pMinWord looking for the * end of the word and its trailing spaces. */ if (fLeft || (!ISDELIMETERW(*pwWordMinSel) && *pwWordMinSel != 0x0D)) /* If we are moving left or if we are moving right and we are not on a * space or a CR (the start of a word), then we was look left for the * start of a word which is either a CR or a character. We do this by * looking left till we find a character (or if CR we stop), then we * continue looking left till we find a space or LF. */ { while (pwWordMinSel > pwText && ((!ISDELIMETERW(*(pwWordMinSel - 1)) && *(pwWordMinSel - 1) != 0x0A) || !charLocated)) { /* * Treat double byte character as a word ( in unicode pwWordMinSel loop ) */ pwPrevChar = pwWordMinSel - 1; /* ** we are looking right ( !fLeft ). ** ** if current character is a double width chararacter ** or previous character is a double width character, ** we are on the beggining of a word. */ if (!fLeft && (ISDELIMETERW( *pwPrevChar) || *pwPrevChar == 0x0A || UserIsFullWidth(CP_ACP,*pwWordMinSel) || UserIsFullWidth(CP_ACP,*pwPrevChar))) { /* * If we are looking for the start of the word right, then we * stop when we have found it. (needed in case charLocated is * still FALSE) */ break; } if (UserIsFullWidth(CP_ACP,*pwPrevChar)) { /* ** Previous character is a double width character. ** ** if we are in a word ( charLocated == TRUE ) ** current position is the beginning of the word ** if we are not in a word ( charLocated == FALSE ) ** the previous character is what we looking for. */ if ( ! charLocated ) { pwWordMinSel = pwPrevChar; } break; } pwWordMinSel = pwPrevChar; if (!ISDELIMETERW(*pwWordMinSel) && *pwWordMinSel != 0x0A) /* * We have found the last char in the word. Continue looking * backwards till we find the first char of the word */ { charLocated = TRUE; /* * We will consider a CR the start of a word */ if (*pwWordMinSel == 0x0D) break; } } } else { /* * We are moving right and we are in between words so we need to move * right till we find the start of a word (either a CR or a character. */ while ((ISDELIMETERW(*pwWordMinSel) || *pwWordMinSel == 0x0A) && pwWordMinSel < pwText + ped->cch) pwWordMinSel++; } pwWordMaxSel = min((pwWordMinSel + 1), (pwText + ped->cch)); /* ** If pwWordMinSel points a double width character AND ** pwWordMaxSel points non space ** then ** pwWordMaxSel points the beggining of next word. */ if (UserIsFullWidth(CP_ACP,*pwWordMinSel) && ! ISDELIMETERW(*pwWordMaxSel)) goto FastReturnW; if (*pwWordMinSel == 0x0D) { if (pwWordMinSel > pwText && *(pwWordMinSel - 1) == 0x0D) /* So that we can treat CRCRLF as one word also. */ pwWordMinSel--; else if (*(pwWordMinSel + 1) == 0x0D) /* Move MaxSel on to the LF */ pwWordMaxSel++; } /* * Check if we have a one character word */ if (ISDELIMETERW(*pwWordMaxSel)) spaceLocated = TRUE; /* * Move pwWordMaxSel to the right looking for the end of a word and its * trailing spaces. WordMaxSel stops on the first character of the next * word. Thus, we break either at a CR or at the first nonspace char after * a run of spaces or LFs. */ while ((pwWordMaxSel < pwText + ped->cch) && (!spaceLocated || (ISDELIMETERW(*pwWordMaxSel)))) { if (*pwWordMaxSel == 0x0D) break; /* * treat double byte character as a word ( in unicode pwWordMaxSel loop ) */ /* ** if it's a double width character ** then we are at the beginning of ** the next word which is a double ** width character. */ if (UserIsFullWidth(CP_ACP,*pwWordMaxSel)) break; pwWordMaxSel++; if (ISDELIMETERW(*pwWordMaxSel)) spaceLocated = TRUE; if (*(pwWordMaxSel - 1) == 0x0A) break; } /* * label for fast return ( for Unicode ) */ FastReturnW: ECUnlock(ped); if (pichMin) *pichMin = (ICH)(pwWordMinSel - pwText); if (pichMax) *pichMax = (ICH)(pwWordMaxSel - pwText); return; } }

LRESULT EditWndProc (  PWND  pwnd, UINT  message, WPARAM  wParam, LPARAM  lParam )

Definition at line 2904 of file editec.c. References _GetClientRect(), BOOL, tagED::cch, tagED::cchTextMax, tagED::charPasswordChar, CI_16BIT, ClearWindowState(), tagED::cLines, CopyRect, DefWindowProcWorker(), DWORD, ECClearText(), ECCopy(), ECCutText(), ECDeleteText(), ECEmptyUndo(), ECEnableDisableIME(), ECGetEditDC(), ECGetText(), ECImeComposition(), EcImeRequestHandler(), ECImmSetCompositionFont(), ECImmSetCompositionWindow(), ECInitInsert(), ECInOutReconversionMode(), ECInvalidateClient(), ECIsAncestorActive(), ECMenu(), ECNcCreate(), ECNcDestroyHandler(), ECNotifyParent(), ECReleaseEditDC(), ECSetCaretHandler(), ECSetFont(), ECSetMargin(), ECSetPasswordChar(), ECSetText(), EFREADONLY, tagED::fAllowRTL, FALSE, tagED::fAnsi, tagED::fDirty, tagED::fDisabled, tagED::fFocus, FindNCHit(), tagED::fInReconversion, tagED::fInsertCompChr, tagED::fKorea, tagED::fLShift, tagED::fMouseDown, tagED::format, fpImmGetContext, fpImmIsIME, fpImmLockIMC, fpImmNotifyIME, fpImmReleaseContext, fpImmUnlockIMC, tagED::fReadOnly, tagED::fReplaceCompChr, tagED::fRtoLReading, tagED::fSawRButtonDown, tagED::fSingle, tagED::fSwapRoOnUp, GetClientInfo, GetKeyState(), tagED::hFont, tagED::hwnd, HWq, ICH, tagED::ichCaret, tagED::ichMaxSel, tagED::ichMinSel, L, tagED::lpfnNextWord, MapVirtualKey(), min, MLDeleteText(), MLEditWndProc(), NtUserGetCaretPos(), NULL, NULL_HIMC, tagED::pLpkEditCallout, PtInRect(), tagED::ptScreenBounding, Pundo, tagED::rcFmt, SetWindowState(), SLDrawText(), SLEditWndProc(), SYS_ALTERNATE, TestWF, THREAD_HKL, TRUE, UINT, UNDO_NONE, WFOLDUI, tagED::wImeStatus, tagED::wLeftMargin, and tagED::wRightMargin. Referenced by EditWndProcWorker(). { HWND hwnd = HWq(pwnd); LRESULT lreturn; PED ped; /* * Get the ped for the given window now since we will use it a lot in * various handlers. This was stored using SetWindowLong(hwnd,0,hped) when * we initially created the edit control. */ ped = ((PEDITWND)pwnd)->ped; /* * Dispatch the various messages we can receive */ lreturn = 1L; switch (message) { /* * Messages which are handled the same way for both single and multi line * edit controls. */ case WM_KEYDOWN: // LPK handling of Ctrl/LShift, Ctrl/RShift if (ped && ped->pLpkEditCallout && ped->fAllowRTL) { ped->fSwapRoOnUp = FALSE; // Any keydown cancels a ctrl/shift reading order change switch (wParam) { case VK_SHIFT: if ((GetKeyState(VK_CONTROL) & 0x8000) && !(GetKeyState(VK_MENU) & 0x8000)) { // Left shift or right shift pressed while control held down // Check that alt (VK_MENU) isn't down to avoid false firing on AltGr which equals Ctrl+Alt. if (MapVirtualKey((LONG)lParam>>16&0xff, 3) == VK_LSHIFT) { // User wants left to right reading order ped->fSwapRoOnUp = (ped->fRtoLReading) || (ped->format & ES_RIGHT) ; ped->fLShift = TRUE; } else { // User wants right to left reading order ped->fSwapRoOnUp = (!ped->fRtoLReading) || (ped->format & ES_RIGHT); ped->fLShift = FALSE; } } break; case VK_LEFT: if (ped->fRtoLReading) { wParam = VK_RIGHT; } break; case VK_RIGHT: if (ped->fRtoLReading) { wParam = VK_LEFT; } break; } } goto HandleEditMsg; case WM_KEYUP: if (ped && ped->pLpkEditCallout && ped->fAllowRTL && ped->fSwapRoOnUp) { BOOL fReadingOrder; // Complete reading order change detected earlier during keydown ped->fSwapRoOnUp = FALSE; fReadingOrder = ped->fRtoLReading; // Remove any overriding ES_CENTRE or ES_RIGHT format from dwStyle SetWindowLong(hwnd, GWL_STYLE, GetWindowLong(hwnd, GWL_STYLE) & ~ES_FMTMASK); if (ped->fLShift) { // Set Left to Right reading order and right scrollbar in EX_STYLE SetWindowLong(hwnd, GWL_EXSTYLE, GetWindowLong(hwnd, GWL_EXSTYLE) & ~(WS_EX_RTLREADING | WS_EX_RIGHT | WS_EX_LEFTSCROLLBAR)); // Edit control is LTR now, then notify the parent. ECNotifyParent(ped, EN_ALIGN_LTR_EC); // ? Select a keyboard layout appropriate to LTR operation } else { // Set Right to Left reading order, right alignment and left scrollbar SetWindowLong(hwnd, GWL_EXSTYLE, GetWindowLong(hwnd, GWL_EXSTYLE) | WS_EX_RTLREADING | WS_EX_RIGHT | WS_EX_LEFTSCROLLBAR); // Edit control is RTL now, then notify the parent. ECNotifyParent(ped, EN_ALIGN_RTL_EC); // ? Select a keyboard layout appropriate to RTL operation } // If reading order didn't change, so we are sure the alignment changed and the edit window didn't invalidate yet. if (fReadingOrder == (BOOL) ped->fRtoLReading) { ECInvalidateClient(ped, TRUE); } } goto HandleEditMsg; case WM_INPUTLANGCHANGE: if (ped) { // EC_INSERT_COMPOSITION_CHAR : WM_INPUTLANGCHANGE - call ECInitInsert() HKL hkl = THREAD_HKL(); ECInitInsert(ped, hkl); if (ped->fInReconversion) { ECInOutReconversionMode(ped, FALSE); } // // Font and caret position might be changed while // another keyboard layout is active. Set those // if the edit control has the focus. // if (ped->fFocus && fpImmIsIME(hkl)) { POINT pt; ECImmSetCompositionFont(ped); NtUserGetCaretPos(&pt); ECImmSetCompositionWindow(ped, pt.x, pt.y); } } goto HandleEditMsg; case WM_COPY: /* * wParam - not used * lParam - not used */ lreturn = (LONG)ECCopy(ped); break; case WM_CUT: /* * * wParamLo -- unused * lParam -- unused */ ECCutText(ped); return 0; case WM_CLEAR: /* * wParamLo -- unused * lParam -- unused */ ECClearText(ped); return 0; case WM_ENABLE: /* * wParam - nonzero if window is enabled else disable window if 0. * lParam - not used */ lreturn = (LONG)(ped->fDisabled = !((BOOL)wParam)); ECInvalidateClient(ped, TRUE); break; case WM_SYSCHAR: // // wParamLo -- key value // lParam -- unused // // // If this is a WM_SYSCHAR message generated by the UNDO // keystroke we want to EAT IT // if ((lParam & SYS_ALTERNATE) && ((WORD)wParam == VK_BACK)) return TRUE; else { return DefWindowProcWorker(pwnd, message, wParam, lParam, ped->fAnsi); } break; case EM_GETLINECOUNT: /* * wParam - not used lParam - not used */ lreturn = (LONG)ped->cLines; break; case EM_GETMODIFY: /* * wParam - not used lParam - not used */ /* * Gets the state of the modify flag for this edit control. */ lreturn = (LONG)ped->fDirty; break; case EM_SETMODIFY: /* * wParam - specifies the new value for the modify flag lParam - not used */ /* * Sets the state of the modify flag for this edit control. */ ped->fDirty = (wParam != 0); break; case EM_GETRECT: /* * wParam - not used lParam - pointer to a RECT data structure that gets the dimensions. */ /* * Copies the rcFmt rect to *lpRect. */ CopyRect((LPRECT)lParam, (LPRECT)&ped->rcFmt); lreturn = (LONG)TRUE; break; case WM_GETFONT: /* * wParam - not used lParam - not used */ lreturn = (LRESULT)ped->hFont; break; case WM_SETFONT: /* * wParam - handle to the font lParam - redraw if true else don't */ ECSetFont(ped, (HANDLE)wParam, (BOOL)LOWORD(lParam)); break; case WM_GETTEXT: /* * wParam - max number of _bytes_ (not characters) to copy * lParam - buffer to copy text to. Text is 0 terminated. */ lreturn = (LRESULT)ECGetText(ped, (ICH)wParam, (LPSTR)lParam, TRUE); break; case WM_SETTEXT: // // wParamLo -- unused // lParam -- LPSTR, null-terminated, with new text. // lreturn = (LRESULT)ECSetText(ped, (LPSTR)lParam); break; case WM_GETTEXTLENGTH: /* * Return count of CHARs!!! */ lreturn = (LONG)ped->cch; break; case WM_NCDESTROY: case WM_FINALDESTROY: /* * wParam - not used lParam - not used */ ECNcDestroyHandler(pwnd, ped); return 0; /* * Most apps (i.e. everyone but Quicken) don't pass on the rbutton * messages when they do something with 'em inside of subclassed * edit fields. As such, we keep track of whether we saw the * down before the up. If we don't see the up, then DefWindowProc * won't generate the context menu message, so no big deal. If * we didn't see the down, then don't let WM_CONTEXTMENU do * anything. * * We also might want to not generate WM_CONTEXTMENUs for old * apps when the mouse is captured. */ case WM_RBUTTONDOWN: ped->fSawRButtonDown = TRUE; goto HandleEditMsg; case WM_RBUTTONUP: if (ped->fSawRButtonDown) { ped->fSawRButtonDown = FALSE; if (!ped->fInReconversion) { goto HandleEditMsg; } } // Don't pass this on to DWP so WM_CONTEXTMENU isn't generated. return 0; case WM_CONTEXTMENU: { POINT pt ; int nHit = FindNCHit(pwnd, (LONG)lParam); if ((nHit == HTVSCROLL) || (nHit == HTHSCROLL)) { return DefWindowProcWorker(pwnd, message, wParam, lParam, ped->fAnsi); } POINTSTOPOINT(pt, lParam); if (!TestWF(pwnd, WFOLDUI) && ECIsAncestorActive(hwnd)) ECMenu(hwnd, ped, &pt); } return 0; case EM_CANUNDO: /* * wParam - not used lParam - not used */ lreturn = (LONG)(ped->undoType != UNDO_NONE); break; case EM_EMPTYUNDOBUFFER: /* * wParam - not used lParam - not used */ ECEmptyUndo(Pundo(ped)); break; case EM_GETMARGINS: // // wParam -- unused // lParam -- unused // return(MAKELONG(ped->wLeftMargin, ped->wRightMargin)); case EM_SETMARGINS: // // wParam -- EC_ margin flags // lParam -- LOWORD is left, HIWORD is right margin // ECSetMargin(ped, (UINT)wParam, (DWORD)lParam, TRUE); return 0; case EM_GETSEL: /* * Gets the selection range for the given edit control. The * starting position is in the low order word. It contains the position * of the first nonselected character after the end of the selection in * the high order word. */ if ((PDWORD)wParam != NULL) { *((PDWORD)wParam) = ped->ichMinSel; } if ((PDWORD)lParam != NULL) { *((PDWORD)lParam) = ped->ichMaxSel; } lreturn = MAKELONG(ped->ichMinSel,ped->ichMaxSel); break; case EM_GETLIMITTEXT: // // wParamLo -- unused // lParam -- unused // return(ped->cchTextMax); case EM_SETLIMITTEXT: /* Renamed from EM_LIMITTEXT in Chicago */ /* * wParam - max number of CHARACTERS that can be entered * lParam - not used */ /* * Specifies the maximum number of characters of text the user may * enter. If maxLength is 0, we may enter MAXINT number of CHARACTERS. */ if (ped->fSingle) { if (wParam) { wParam = min(0x7FFFFFFEu, wParam); } else { wParam = 0x7FFFFFFEu; } } if (wParam) { ped->cchTextMax = (ICH)wParam; } else { ped->cchTextMax = 0xFFFFFFFFu; } break; case EM_POSFROMCHAR: // // Validate that char index is within text range // if (wParam >= ped->cch) { return(-1L); } goto HandleEditMsg; case EM_CHARFROMPOS: { // Validate that point is within client of edit field RECT rc; POINT pt; POINTSTOPOINT(pt, lParam); _GetClientRect(pwnd, &rc); if (!PtInRect(&rc, pt)) { return(-1L); } goto HandleEditMsg; } case EM_SETPASSWORDCHAR: /* * wParam - sepecifies the new char to display instead of the * real text. if null, display the real text. */ ECSetPasswordChar(ped, (UINT)wParam); break; case EM_GETPASSWORDCHAR: lreturn = (DWORD)ped->charPasswordChar; break; case EM_SETREADONLY: /* * wParam - state to set read only flag to */ ped->fReadOnly = (wParam != 0); if (wParam) SetWindowState(pwnd, EFREADONLY); else ClearWindowState(pwnd, EFREADONLY); lreturn = 1L; ECEnableDisableIME( ped ); // We need to redraw the edit field so that the background color // changes. Read-only edits are drawn in CTLCOLOR_STATIC while // others are drawn with CTLCOLOR_EDIT. ECInvalidateClient(ped, TRUE); break; case EM_SETWORDBREAKPROC: /* * wParam - unused * lParam - FARPROC address of an app supplied call back function */ ped->lpfnNextWord = (EDITWORDBREAKPROCA)lParam; break; case EM_GETWORDBREAKPROC: lreturn = (LRESULT)ped->lpfnNextWord; break; // IME case EM_GETIMESTATUS: // wParam == sub command switch (wParam) { case EMSIS_COMPOSITIONSTRING: return ped->wImeStatus; #if 0 // memphis case EMSIS_GETLBBIT: return (DWORD)ped->bLBBit; #endif } break; case EM_SETIMESTATUS: // wParam == sub command switch (wParam) { case EMSIS_COMPOSITIONSTRING: ped->wImeStatus = (WORD)lParam; } break; case WM_NCCREATE: lreturn = ECNcCreate(ped, pwnd, (LPCREATESTRUCT)lParam); break; case WM_LBUTTONDOWN: // // B#3623 // Don't set focus to edit field if it is within an inactive, // captioned child. // We might want to version switch this... I haven't found // any problems by not, but you never know... // if (ECIsAncestorActive(hwnd)) { /* * Reconversion support: quit reconversion if left button is clicked. * Otherwise, if the current KL is Korean, finailize the composition string. */ if (ped->fInReconversion || ped->fKorea) { BOOLEAN fReconversion = (BOOLEAN)ped->fInReconversion; DWORD dwIndex = fReconversion ? CPS_CANCEL : CPS_COMPLETE; HIMC hImc; ped->fReplaceCompChr = FALSE; hImc = fpImmGetContext(ped->hwnd); if (hImc) { fpImmNotifyIME(hImc, NI_COMPOSITIONSTR, dwIndex, 0); fpImmReleaseContext(ped->hwnd, hImc); } if (fReconversion) { ECInOutReconversionMode(ped, FALSE); } ECSetCaretHandler(ped); } goto HandleEditMsg; } break; case WM_MOUSEMOVE: // // We only care about mouse messages when mouse is down. // if (ped->fMouseDown) goto HandleEditMsg; break; case WM_IME_SETCONTEXT: // // If ped->fInsertCompChr is TRUE, that means we will do // all the composition character drawing by ourself. // if ( ped->fInsertCompChr ) { lParam &= ~ISC_SHOWUICOMPOSITIONWINDOW; } if ( wParam ) { PINPUTCONTEXT pInputContext; HIMC hImc; hImc = fpImmGetContext( hwnd ); if ( (pInputContext = fpImmLockIMC( hImc )) != NULL ) { pInputContext->fdw31Compat &= ~F31COMPAT_ECSETCFS; fpImmUnlockIMC( hImc ); } if (GetClientInfo()->CI_flags & CI_16BIT) { fpImmNotifyIME(hImc, NI_COMPOSITIONSTR, CPS_CANCEL, 0L); } fpImmReleaseContext( hwnd, hImc ); } return DefWindowProcWorker(pwnd, message, wParam, lParam, ped->fAnsi); case WM_IME_ENDCOMPOSITION: ECInOutReconversionMode(ped, FALSE); if (ped->fReplaceCompChr) { ICH ich; HDC hdc; // // we have a DBCS character to be replaced. // let's delete it before inserting the new one. // ich = (ped->fAnsi) ? 2 : 1; ped->fReplaceCompChr = FALSE; ped->ichMaxSel = min(ped->ichCaret + ich, ped->cch); ped->ichMinSel = ped->ichCaret; if (ped->fSingle) { if (ECDeleteText( ped ) > 0) { // // Update the display // ECNotifyParent(ped, EN_UPDATE); hdc = ECGetEditDC(ped, FALSE); SLDrawText(ped, hdc, 0); ECReleaseEditDC(ped, hdc, FALSE); // // Tell parent our text contents changed. // ECNotifyParent(ped, EN_CHANGE); } } else { MLDeleteText(ped); } ECSetCaretHandler( ped ); } return DefWindowProcWorker(pwnd, message, wParam, lParam, ped->fAnsi); case WM_IME_STARTCOMPOSITION: if ( ped->fInsertCompChr ) { // // BUG BUG // // sending WM_IME_xxxCOMPOSITION will let // IME draw composition window. IME should // not do that since we cleared // ISC_SHOWUICOMPOSITIONWINDOW bit when // we got WM_IME_SETCONTEXT message. // // Korean IME should be fixed in the future. // break; } else { return DefWindowProcWorker(pwnd, message, wParam, lParam, ped->fAnsi); } // simple composition character support for FE IME. case WM_IME_COMPOSITION: return ECImeComposition(ped, wParam, lParam); case WM_KILLFOCUS: // // when focus is removed from the window, // composition character should be finalized // if (ped && fpImmIsIME(THREAD_HKL())) { HIMC hImc = fpImmGetContext(hwnd); if (hImc != NULL_HIMC) { if (ped->fReplaceCompChr || (ped->wImeStatus & EIMES_COMPLETECOMPSTRKILLFOCUS)) { // If the composition string to be determined upon kill focus, // do it now. fpImmNotifyIME(hImc, NI_COMPOSITIONSTR, CPS_COMPLETE, 0); } else if (ped->fInReconversion) { // If the composition string it not to be determined, // and if we're in reconversion mode, cancel reconversion now. fpImmNotifyIME(hImc, NI_COMPOSITIONSTR, CPS_CANCEL, 0); } // Get out from reconversion mode if (ped->fInReconversion) { ECInOutReconversionMode(ped, FALSE); } fpImmReleaseContext(hwnd, hImc); } } goto HandleEditMsg; break; case WM_SETFOCUS: if (ped && !ped->fFocus) { HKL hkl = THREAD_HKL(); if (fpImmIsIME(hkl)) { HIMC hImc; hImc = fpImmGetContext(hwnd); if (hImc) { LPINPUTCONTEXT lpImc; if (ped->wImeStatus & EIMES_CANCELCOMPSTRINFOCUS) { // cancel when in-focus fpImmNotifyIME(hImc, NI_COMPOSITIONSTR, CPS_CANCEL, 0); } ECImmSetCompositionFont(ped); if ((lpImc = fpImmLockIMC(hImc)) != NULL) { // We presume the CompForm will reset to CFS_DEFAULT, // when the edit control loses Focus. // IMEWndProc32 will call ImmSetCompositionWindow with // CFS_DEFAULT, when it receive WM_IME_SETCONTEXT. lpImc->fdw31Compat |= F31COMPAT_ECSETCFS; fpImmUnlockIMC(hImc); } fpImmReleaseContext(hwnd, hImc); } // // force to set IME composition window when // first getting focus. // ped->ptScreenBounding.x = -1; ped->ptScreenBounding.y = -1; } ECInitInsert(ped, hkl); } goto HandleEditMsg; break; case WM_IME_REQUEST: // simple ImeRequest Handler return EcImeRequestHandler(ped, wParam, lParam); case WM_CREATE: if (ped) ECEnableDisableIME(ped); goto HandleEditMsg; break; default: HandleEditMsg: /* (picked up from NT40FE SP3) * HACK ALERT: We may receive messages before the PED has been * allocated (eg: WM_GETMINMAXINFO is sent before WM_NCCREATE) * so we must test ped before dreferencing. */ if (ped != NULL) { if (ped->fSingle) { lreturn = SLEditWndProc(hwnd, ped, message, wParam, lParam); } else { lreturn = MLEditWndProc(hwnd, ped, message, wParam, lParam); } } } return lreturn; }

LRESULT EditWndProcA (  HWND  hwnd, UINT  message, WPARAM  wParam, LPARAM  lParam )

Definition at line 2787 of file editec.c. References DefWindowProcWorker(), EditWndProcWorker(), FNID_EDIT, FWINDOWMSG, NULL, TRUE, and ValidateHwnd. Referenced by ClientThreadSetup(), and EditWndProcWorker(). { PWND pwnd; if ((pwnd = ValidateHwnd(hwnd)) == NULL) return 0; /* * If the control is not interested in this message, * pass it to DefWindowProc. */ if (!FWINDOWMSG(message, FNID_EDIT)) return DefWindowProcWorker(pwnd, message, wParam, lParam, TRUE); return EditWndProcWorker(pwnd, message, wParam, lParam, TRUE); }

LRESULT EditWndProcW (  HWND  hwnd, UINT  message, WPARAM  wParam, LPARAM  lParam )

Definition at line 2808 of file editec.c. References DefWindowProcWorker(), EditWndProcWorker(), FALSE, FNID_EDIT, FWINDOWMSG, NULL, and ValidateHwnd. Referenced by ClientThreadSetup(), EditWndProcWorker(), and RW_RegisterControls(). { PWND pwnd; if ((pwnd = ValidateHwnd(hwnd)) == NULL) return 0; /* * If the control is not interested in this message, * pass it to DefWindowProc. */ if (!FWINDOWMSG(message, FNID_EDIT)) { return DefWindowProcWorker(pwnd, message, wParam, lParam, FALSE); } return EditWndProcWorker(pwnd, message, wParam, lParam, FALSE); }

LRESULT EditWndProcWorker (  PWND  pwnd, UINT  message, WPARAM  wParam, LPARAM  lParam, DWORD  fAnsi )

Definition at line 2831 of file editec.c. References BOOL, tagMSG_TABLE_ENTRY::bThunkMessage, CsSendMessage, ED, EditLookaside, EditWndProc(), EditWndProcA(), EditWndProcW(), FALSE, tagED::fAnsi, tagED::fInitialized, FNID_CALLWINDOWPROC, FNID_EDIT, HWq, INITCONTROLLOOKASIDE, MessageTable, PEDITWND, TestWF, TRUE, VALIDATECLASSANDSIZE, and WFANSICREATOR. Referenced by ClientThreadSetup(), EditWndProcA(), and EditWndProcW(). { PED ped; HWND hwnd = HWq(pwnd); static BOOL fInit = TRUE; VALIDATECLASSANDSIZE(pwnd, FNID_EDIT); INITCONTROLLOOKASIDE(&EditLookaside, ED, pwnd, 4); /* * Get the ped for the given window now since we will use it a lot in * various handlers. This was stored using SetWindowLong(hwnd,0,hped) when * we initially created the edit control. */ ped = ((PEDITWND)pwnd)->ped; /* * Make sure the ANSI flag is set correctly. */ if (!ped->fInitialized) { ped->fInitialized = TRUE; ped->fAnsi = TestWF(pwnd, WFANSICREATOR) ? TRUE : FALSE; } /* * We just call the regular EditWndProc if the ped is not created, the * incoming message type already matches the PED type or the message * does not need any translation. */ if (ped->fAnsi == fAnsi || (message >= WM_USER) || !MessageTable[message].bThunkMessage) { return EditWndProc(pwnd, message, wParam, lParam); } return CsSendMessage(hwnd, message, wParam, lParam, fAnsi ? (ULONG_PTR)EditWndProcW : (ULONG_PTR)EditWndProcA, FNID_CALLWINDOWPROC, fAnsi); }

UINT GetActualNegA (  HDC  hdc, PED  ped, int  x, LPSTR  lpstring, ICH  ichString, int  nCount, LPSTRIPINFO  NegAInfo )

Definition at line 117 of file editec.c. References tagED::aveCharWidth, CHAR_WIDTH_BUFFER_LENGTH, tagED::charOverhang, tagED::charWidthBuffer, tagED::fAnsi, tagED::fTrueType, LPSTRIPINFO, min, UINT, and tagED::wMaxNegAcharPos. Referenced by ECTabTheTextOut(). { int iCharCount, i; int iLeftmostPoint = x; PABC pABCwidthBuff; UINT wCharIndex; int xStartPoint = x; ABC abc; // To begin with, let us assume that there is no negative A width for // this strip and initialize accodingly. NegAInfo->XStartPos = x; NegAInfo->lpString = lpstring; NegAInfo->nCount = 0; NegAInfo->ichString = ichString; // If the current font is not a TrueType font, then there can not be any // negative A widths. if (!ped->fTrueType) { if(!ped->charOverhang) { return 0; } else { NegAInfo->nCount = min(nCount, (int)ped->wMaxNegAcharPos); return ped->charOverhang; } } // How many characters are to be considered for computing Negative A ? iCharCount = min(nCount, (int)ped->wMaxNegAcharPos); // Do we have the info on individual character's widths? if(!ped->charWidthBuffer) { // No! So, let us tell them to consider all the characters. NegAInfo->nCount = iCharCount; return(iCharCount * ped->aveCharWidth); } pABCwidthBuff = (PABC) ped->charWidthBuffer; if (ped->fAnsi) { for (i = 0; i < iCharCount; i++) { wCharIndex = (UINT)(*((unsigned char *)lpstring)); if (*lpstring == VK_TAB) { // To play it safe, we assume that this tab results in a tab length of // 1 pixel because this is the minimum possible tab length. x++; } else { if ( wCharIndex < CHAR_WIDTH_BUFFER_LENGTH ) x += pABCwidthBuff[wCharIndex].abcA; // Add the 'A' width. else { GetCharABCWidthsA(hdc, wCharIndex, wCharIndex, &abc) ; x += abc.abcA; } if (x < iLeftmostPoint) iLeftmostPoint = x; // Reset the leftmost point. if (x < xStartPoint) NegAInfo->nCount = i+1; // 'i' is index; To get the count add 1. if ( wCharIndex < CHAR_WIDTH_BUFFER_LENGTH ) { x += pABCwidthBuff[wCharIndex].abcB + pABCwidthBuff[wCharIndex].abcC; } else { x += abc.abcB + abc.abcC; } } lpstring++; } } else { // Unicode LPWSTR lpwstring = (LPWSTR) lpstring ; for (i = 0; i < iCharCount; i++) { wCharIndex = *lpwstring ; if (*lpwstring == VK_TAB) { // To play it safe, we assume that this tab results in a tab length of // 1 pixel because this is the minimum possible tab length. x++; } else { if ( wCharIndex < CHAR_WIDTH_BUFFER_LENGTH ) x += pABCwidthBuff[wCharIndex].abcA; // Add the 'A' width. else { GetCharABCWidthsW(hdc, wCharIndex, wCharIndex, &abc) ; x += abc.abcA ; } if (x < iLeftmostPoint) iLeftmostPoint = x; // Reset the leftmost point. if (x < xStartPoint) NegAInfo->nCount = i+1; // 'i' is index; To get the count add 1. if ( wCharIndex < CHAR_WIDTH_BUFFER_LENGTH ) x += pABCwidthBuff[wCharIndex].abcB + pABCwidthBuff[wCharIndex].abcC; else x += abc.abcB + abc.abcC ; } lpwstring++; } } // Let us return the negative A for the whole strip as a positive value. return((UINT)(xStartPoint - iLeftmostPoint)); }

void NextWordCallBack (  PED  ped, ICH  ichStart, BOOL  fLeft, ICH *  pichMin, ICH *  pichMax )

Definition at line 1446 of file editec.c. References BOOL, CALLWORDBREAKPROC, tagED::cch, ECLock(), ECUnlock(), tagED::fAnsi, ICH, tagED::lpfnNextWord, and min. Referenced by ECWord(). { ICH ichMinSel; ICH ichMaxSel; LPSTR pText; pText = ECLock(ped); if (fLeft || (!(BOOL)CALLWORDBREAKPROC(ped->lpfnNextWord, (LPSTR)pText, ichStart, ped->cch, WB_ISDELIMITER) && (ped->fAnsi ? (*(pText + ichStart) != VK_RETURN) : (*((LPWSTR)pText + ichStart) != VK_RETURN)) )) ichMinSel = CALLWORDBREAKPROC(*ped->lpfnNextWord, (LPSTR)pText, ichStart, ped->cch, WB_LEFT); else ichMinSel = CALLWORDBREAKPROC(*ped->lpfnNextWord, (LPSTR)pText, ichStart, ped->cch, WB_RIGHT); ichMaxSel = min(ichMinSel + 1, ped->cch); if (ped->fAnsi) { if (*(pText + ichMinSel) == VK_RETURN) { if (ichMinSel > 0 && *(pText + ichMinSel - 1) == VK_RETURN) { /* * So that we can treat CRCRLF as one word also. */ ichMinSel--; } else if (*(pText+ichMinSel + 1) == VK_RETURN) { /* * Move MaxSel on to the LF */ ichMaxSel++; } } } else { if (*((LPWSTR)pText + ichMinSel) == VK_RETURN) { if (ichMinSel > 0 && *((LPWSTR)pText + ichMinSel - 1) == VK_RETURN) { /* * So that we can treat CRCRLF as one word also. */ ichMinSel--; } else if (*((LPWSTR)pText+ichMinSel + 1) == VK_RETURN) { /* * Move MaxSel on to the LF */ ichMaxSel++; } } } ichMaxSel = CALLWORDBREAKPROC(ped->lpfnNextWord, (LPSTR)pText, ichMaxSel, ped->cch, WB_RIGHT); ECUnlock(ped); if (pichMin) *pichMin = ichMinSel; if (pichMax) *pichMax = ichMaxSel; }

void NextWordLpkCallBack (  PED  ped, ICH  ichStart, BOOL  fLeft, ICH *  pichMin, ICH *  pichMax )

Definition at line 1518 of file editec.c. References ECGetEditDC(), ECLock(), ECReleaseEditDC(), ECUnlock(), tagLPKEDITCALLOUT::EditNextWord, tagED::pLpkEditCallout, and TRUE. Referenced by ECWord(). { PSTR pText = ECLock(ped); HDC hdc = ECGetEditDC(ped, TRUE); ped->pLpkEditCallout->EditNextWord(ped, hdc, pText, ichStart, fLeft, pichMin, pichMax); ECReleaseEditDC(ped, hdc, TRUE); ECUnlock(ped); }

UINT WINAPI QueryFontAssocStatus (  void   )

Referenced by ECGetDBCSVector().

---

Variable Documentation

LOOKASIDE EditLookaside

Definition at line 17 of file editec.c. Referenced by ECNcCreate(), ECNcDestroyHandler(), and EditWndProcWorker().

UINT fFontAssocStatus = 0xffff

Definition at line 3810 of file editec.c. Referenced by ECGetDBCSVector().

---