edecrare.c File Reference

#include "precomp.h"

Go to the source code of this file.

Defines
#define	WS_EX_EDGEMASK   (WS_EX_WINDOWEDGE | WS_EX_CLIENTEDGE)
#define	GetCharABCWidthsAorW   ((ped)->fAnsi ? GetCharABCWidthsA : GetCharABCWidthsW)
#define	GetCharWidthAorW   ((ped)->fAnsi ? GetCharWidthA : GetCharWidthW)
#define	umin(a, b)   ((unsigned)(a) < (unsigned)(b) ? (unsigned)(a) : (unsigned)(b))
#define	GET_COMPOSITION_STRING   (ped->fAnsi ? fpImmGetCompositionStringA : fpImmGetCompositionStringW)
Typedefs
typedef BOOL(*	PFNABCWIDTHS )(HDC, UINT, UINT, LPABC)
typedef BOOL(*	PFNCHARWIDTH )(HDC, UINT, UINT, LPINT)
Functions
DWORD	GetMaxOverlapChars (void)
void	ECSetMargin (PED ped, UINT wFlags, long lMarginValues, BOOL fRedraw)
void	ECCalcMarginForDBCSFont (PED ped, BOOL fRedraw)
int	UserGetCharDimensionsEx (HDC hDC, HFONT hfont, LPTEXTMETRIC lptm, LPINT lpcy)
ICH	ECGetText (PED ped, ICH maxCchToCopy, LPSTR lpBuffer, BOOL fNullTerminate)
BOOL	ECNcCreate (PED ped, PWND pwnd, LPCREATESTRUCT lpCreateStruct)
BOOL	ECCreate (PED ped, LONG windowStyle)
void	ECNcDestroyHandler (PWND pwnd, PED ped)
void	ECSetPasswordChar (PED ped, UINT pwchar)
BOOL	GetNegABCwidthInfo (PED ped, HDC hdc)
void	ECSize (PED ped, LPRECT lprc, BOOL fRedraw)
void	ECSetFont (PED ped, HFONT hfont, BOOL fRedraw)
BOOL	ECIsCharNumeric (PED ped, DWORD keyPress)
VOID	ECEnableDisableIME (PED ped)
VOID	ECImmSetCompositionWindow (PED ped, LONG x, LONG y)
VOID	ECImmSetCompositionFont (PED ped)
VOID	ECInitInsert (PED ped, HKL hkl)
void	ECSetCaretHandler (PED ped)
void	MLReplaceSel (PED, LPSTR)
BOOL FAR PASCAL	ECResultStrHandler (PED ped)
LRESULT	ECImeComposition (PED ped, WPARAM wParam, LPARAM lParam)
BOOL	HanjaKeyHandler (PED ped)
LRESULT	EcImeRequestHandler (PED ped, WPARAM dwSubMsg, LPARAM lParam)
Variables
LOOKASIDE	EditLookaside
WCHAR	AveCharWidthData [] = L"abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"

---

Define Documentation

#define GET_COMPOSITION_STRING   (ped->fAnsi ? fpImmGetCompositionStringA : fpImmGetCompositionStringW)

Definition at line 1285 of file edecrare.c. Referenced by ECResultStrHandler().

#define GetCharABCWidthsAorW   ((ped)->fAnsi ? GetCharABCWidthsA : GetCharABCWidthsW)

Definition at line 25 of file edecrare.c. Referenced by ECCalcMarginForDBCSFont().

#define GetCharWidthAorW   ((ped)->fAnsi ? GetCharWidthA : GetCharWidthW)

Definition at line 26 of file edecrare.c.

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

Definition at line 28 of file edecrare.c. Referenced by ECCchInWidth().

#define WS_EX_EDGEMASK   (WS_EX_WINDOWEDGE | WS_EX_CLIENTEDGE)

Definition at line 20 of file edecrare.c.

---

Typedef Documentation

typedef BOOL(* PFNABCWIDTHS)(HDC, UINT, UINT, LPABC)

Definition at line 30 of file edecrare.c.

typedef BOOL(* PFNCHARWIDTH)(HDC, UINT, UINT, LPINT)

Definition at line 31 of file edecrare.c.

---

Function Documentation

void ECCalcMarginForDBCSFont (  PED  ped, BOOL  fRedraw )

Definition at line 109 of file edecrare.c. References ECSetMargin(), tagED::fSingle, tagED::fTrueType, GetCharABCWidthsAorW, tagED::hFont, tagED::hwnd, min, NtUserGetDC(), ReleaseDC(), TRUE, UINT, UserLocalAlloc, UserLocalFree, and tagED::wMaxNegA. Referenced by ECSetFont(). { if (!ped->fTrueType) return; if (!ped->fSingle) { // wMaxNegA came from ABC CharWidth. if (ped->wMaxNegA != 0) { ECSetMargin(ped, EC_LEFTMARGIN | EC_RIGHTMARGIN, MAKELONG(EC_USEFONTINFO, EC_USEFONTINFO),fRedraw); } } else { int iMaxNegA = 0, iMaxNegC = 0; int i; PVOID lpBuffer; LPABC lpABCBuff; ABC ABCInfo; HFONT hOldFont; HDC hdc = NtUserGetDC(ped->hwnd); if (!ped->hFont || !(hOldFont = SelectFont(hdc, ped->hFont))) { ReleaseDC(ped->hwnd, hdc); return; } if (lpBuffer = UserLocalAlloc(0,sizeof(ABC) * 256)) { lpABCBuff = lpBuffer; GetCharABCWidthsAorW(hdc, 0, 255, lpABCBuff); } else { lpABCBuff = &ABCInfo; GetCharABCWidthsAorW(hdc, 0, 0, lpABCBuff); } i = 0; while (TRUE) { iMaxNegA = min(iMaxNegA, lpABCBuff->abcA); iMaxNegC = min(iMaxNegC, lpABCBuff->abcC); if (++i == 256) break; if (lpBuffer) { lpABCBuff++; } else { GetCharABCWidthsAorW(hdc, i, i, lpABCBuff); } } SelectFont(hdc, hOldFont); if (lpBuffer) UserLocalFree(lpBuffer); ReleaseDC(ped->hwnd, hdc); if ((iMaxNegA != 0) || (iMaxNegC != 0)) ECSetMargin(ped, EC_LEFTMARGIN | EC_RIGHTMARGIN, MAKELONG((UINT)(-iMaxNegC), (UINT)(-iMaxNegA)),fRedraw); } return; }

BOOL ECCreate (  PED  ped, LONG  windowStyle )

Definition at line 387 of file edecrare.c. References BOOL, BYTE, tagED::cchTextMax, tagED::charSet, ECGetEditDC(), ECInitInsert(), ECReleaseEditDC(), tagLPKEDITCALLOUT::EditCreate, tagED::fAutoHScroll, tagED::fNoHideSel, tagED::format, fpLpkEditControl, HW, ICH, MAXTEXT, tagED::pLpkEditCallout, tagED::pwnd, TestWF, THREAD_HKL, TRUE, and WEFRIGHT. Referenced by MLCreate(), and SLCreate(). { HDC hdc; /* * Get values from the window instance data structure and put them in the * ped so that we can access them easier. */ if (windowStyle & ES_AUTOHSCROLL) ped->fAutoHScroll = 1; if (windowStyle & ES_NOHIDESEL) ped->fNoHideSel = 1; ped->format = (LOWORD(windowStyle) & LOWORD(ES_FMTMASK)); if (TestWF(ped->pwnd, WEFRIGHT) && !ped->format) ped->format = ES_RIGHT; ped->cchTextMax = MAXTEXT; /* Max # chars we will initially allow */ /* * Set up undo initial conditions... (ie. nothing to undo) */ ped->ichDeleted = (ICH)-1; ped->ichInsStart = (ICH)-1; ped->ichInsEnd = (ICH)-1; // initial charset value - need to do this BEFORE MLCreate is called // so that we know not to fool with scrollbars if nessacary hdc = ECGetEditDC(ped, TRUE); ped->charSet = (BYTE)GetTextCharset(hdc); ECReleaseEditDC(ped, hdc, TRUE); // FE_IME // EC_INSERT_COMPOSITION_CHARACTER: ECCreate() - call ECInitInsert() ECInitInsert(ped, THREAD_HKL()); if(ped->pLpkEditCallout = fpLpkEditControl) { return ped->pLpkEditCallout->EditCreate(ped, HW(ped->pwnd)); } else return TRUE; }

VOID ECEnableDisableIME (  PED  ped  )

Definition at line 1037 of file edecrare.c. References tagED::charPasswordChar, ECImmSetCompositionFont(), ECImmSetCompositionWindow(), ECInitInsert(), tagED::fFocus, fpImmAssociateContext, fpImmGetContext, fpImmReleaseContext, tagED::fReadOnly, tagED::hImcPrev, tagED::hwnd, NtUserGetCaretPos(), NULL_HIMC, THREAD_HKL, and VOID(). Referenced by ECSetPasswordChar(), and EditWndProc(). { if ( ped->fReadOnly || ped->charPasswordChar ) { // // IME should be disabled // HIMC hImc; hImc = fpImmGetContext( ped->hwnd ); if ( hImc != NULL_HIMC ) { fpImmReleaseContext( ped->hwnd, hImc ); ped->hImcPrev = fpImmAssociateContext( ped->hwnd, NULL_HIMC ); } } else { // // IME should be enabled // if ( ped->hImcPrev != NULL_HIMC ) { ped->hImcPrev = fpImmAssociateContext( ped->hwnd, ped->hImcPrev ); // // Font and the caret position might be changed while // IME was being disabled. Set those now if the window // has the focus. // if ( ped->fFocus ) { POINT pt; ECImmSetCompositionFont( ped ); NtUserGetCaretPos( &pt ); ECImmSetCompositionWindow( ped, pt.x, pt.y ); } } } ECInitInsert(ped, THREAD_HKL()); }

ICH ECGetText (  PED  ped, ICH  maxCchToCopy, LPSTR  lpBuffer, BOOL  fNullTerminate )

Definition at line 246 of file edecrare.c. References tagED::cbChar, tagED::cch, ECLock(), ECUnlock(), tagED::fAnsi, ICH, and min. Referenced by EditWndProc(), and SLEditWndProc(). { PSTR pText; if (maxCchToCopy) { /* * Zero terminator takes the extra byte */ if (fNullTerminate) maxCchToCopy--; maxCchToCopy = min(maxCchToCopy, ped->cch); /* * Zero terminate the string */ if (ped->fAnsi) *(LPSTR)(lpBuffer + maxCchToCopy) = 0; else *(((LPWSTR)lpBuffer) + maxCchToCopy) = 0; pText = ECLock(ped); RtlCopyMemory(lpBuffer, pText, maxCchToCopy*ped->cbChar); ECUnlock(ped); } return maxCchToCopy; }

LRESULT ECImeComposition (  PED  ped, WPARAM  wParam, LPARAM  lParam )

Definition at line 1337 of file edecrare.c. References BOOL, BYTE, tagED::cch, tagED::cchTextMax, DefWindowProcWorker(), ECDeleteText(), ECGetEditDC(), ECInOutReconversionMode(), ECNotifyParent(), ECReleaseEditDC(), ECResultStrHandler(), ECSetCaretHandler(), FALSE, tagED::fAnsi, tagED::fInsertCompChr, tagED::fMouseDown, tagED::fNoMoveCaret, fpImmGetContext, fpImmNotifyIME, fpImmReleaseContext, tagED::fReplaceCompChr, tagED::fResultProcess, tagED::fSingle, HIBYTE, tagED::hwnd, ICH, tagED::ichCaret, tagED::ichMaxSel, tagED::ichMinSel, INT, L, LOBYTE, max, min, MLDeleteText(), MLInsertText(), NtUserMessageBeep, tagED::pwnd, SLDrawText(), SLInsertText(), SLScrollText(), TRUE, and tagED::wImeStatus. Referenced by EditWndProc(). { INT ich; LRESULT lReturn = 1; HDC hdc; BOOL fSLTextUpdated = FALSE; ICH iResult; HIMC hImc; BYTE TextBuf[4]; if (!ped->fInsertCompChr) { if (lParam & GCS_RESULTSTR) { ECInOutReconversionMode(ped, FALSE); if (ped->wImeStatus & EIMES_GETCOMPSTRATONCE) { ResultAtOnce: ECResultStrHandler(ped); lParam &= ~GCS_RESULTSTR; } } return DefWindowProcWorker(ped->pwnd, WM_IME_COMPOSITION, wParam, lParam, ped->fAnsi); } // In case of Ansi edit control, the length of minimum composition string // is 2. Check here maximum byte of edit control. if( ped->fAnsi && ped->cchTextMax == 1 ) { HIMC hImc; hImc = fpImmGetContext( ped->hwnd ); fpImmNotifyIME(hImc, NI_COMPOSITIONSTR, CPS_CANCEL, 0L); fpImmReleaseContext( ped->hwnd, hImc ); NtUserMessageBeep(MB_ICONEXCLAMATION); return lReturn; } // Don't move this after CS_NOMOVECARET check. // In case if skip the message, fNoMoveCaret should not be set. if ((lParam & CS_INSERTCHAR) && ped->fResultProcess) { // Now we're in result processing. GCS_RESULTSTR ends up // to WM_IME_CHAR and WM_CHAR. Since WM_CHAR is posted, // the message(s) will come later than this CS_INSERTCHAR // message. This composition character should be handled // after the WM_CHAR message(s). // if(ped->fAnsi) PostMessageA(ped->hwnd, WM_IME_COMPOSITION, wParam, lParam); else PostMessageW(ped->hwnd, WM_IME_COMPOSITION, wParam, lParam); ped->fResultProcess = FALSE; return lReturn; } // // If fReplaceCompChr is TRUE, we change the shape of caret. A block // caret is displayed on the composition character. From the user's // point of view, there is no difference if the caret is before the // composition character or after the composition character. When // the composition character is finalized, the insertion point should // be moved to after the character, any way. Therefore checking // CS_NOMOVECARET bit doesn't make sense in our current implementation. // [takaok] // #if 0 if (lParam & CS_NOMOVECARET) ped->fNoMoveCaret=TRUE; // stick to current caret pos. else ped->fNoMoveCaret=FALSE; #endif if (lParam & GCS_RESULTSTR) { if (ped->wImeStatus & EIMES_GETCOMPSTRATONCE) { goto ResultAtOnce; } ped->fResultProcess=TRUE; if ( ped->fReplaceCompChr ) { // // 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 ( ECDeleteText( ped ) > 0 ) { if ( ped->fSingle ) { // // 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); } } ECSetCaretHandler( ped ); } } else if(lParam & CS_INSERTCHAR) { // // If we are in the middle of a mousedown command, don't do anything. // if (ped->fMouseDown) { return lReturn; } // // We can safely assume that interimm character is always DBCS. // ich = ( ped->fAnsi ) ? 2 : 1; if ( ped->fReplaceCompChr ) { // // we have a character to be replaced. // let's delete it before inserting the new one. // when we have a composition characters, the // caret is placed before the composition character. // ped->ichMaxSel = min(ped->ichCaret+ich, ped->cch); ped->ichMinSel = ped->ichCaret; } // // let's delete current selected text or composition character // if ( ped->fSingle ) { if ( ECDeleteText( ped ) > 0 ) { fSLTextUpdated = TRUE; } } else { MLDeleteText( ped ); } // // When the composition charcter is canceled, IME may give us NULL wParam, // with CS_INSERTCHAR flag on. We shouldn't insert a NULL character. // if ( wParam != 0 ) { if ( ped->fAnsi ) { TextBuf[0] = HIBYTE(LOWORD(wParam)); // leading byte TextBuf[1] = LOBYTE(LOWORD(wParam)); // trailing byte TextBuf[2] = '\0'; } else { TextBuf[0] = LOBYTE(LOWORD(wParam)); TextBuf[1] = HIBYTE(LOWORD(wParam)); TextBuf[2] = '\0'; TextBuf[3] = '\0'; } if ( ped->fSingle ) { iResult = SLInsertText( ped, (LPSTR)TextBuf, ich ); if (iResult == 0) { /* * Couldn't insert the text, for e.g. the text exceeded the limit. */ NtUserMessageBeep(0); } else if (iResult > 0) { /* * Remember we need to update the text. */ fSLTextUpdated = TRUE; } } else { iResult = MLInsertText( ped, (LPSTR)TextBuf, ich, TRUE); } if ( iResult > 0 ) { // // ped->fReplaceCompChr will be reset: // // 1) when the character is finalized. // we will receive GCS_RESULTSTR // // 2) when the character is canceled. // // we will receive WM_IME_COMPOSITION|CS_INSERTCHAR // with wParam == 0 (in case of user types backspace // at the first element of composition character). // // or // // we will receive WM_IME_ENDCOMPOSITION message // ped->fReplaceCompChr = TRUE; // // Caret should be placed BEFORE the composition // character. // ped->ichCaret = max( 0, ped->ichCaret - ich); ECSetCaretHandler( ped ); } else { // // We failed to insert a character. We might run out // of memory, or reached to the text size limit. let's // cancel the composition character. // hImc = fpImmGetContext(ped->hwnd); fpImmNotifyIME(hImc, NI_COMPOSITIONSTR, CPS_CANCEL, 0); fpImmReleaseContext(ped->hwnd, hImc); ped->fReplaceCompChr = FALSE; ECSetCaretHandler( ped ); } } else { // // the composition character is canceled. // ped->fReplaceCompChr = FALSE; ECSetCaretHandler( ped ); } // // We won't notify parent the text change // because the composition character has // not been finalized. // if ( fSLTextUpdated ) { // // Update the display // ECNotifyParent(ped, EN_UPDATE); hdc = ECGetEditDC(ped,FALSE); if ( ped->fReplaceCompChr ) { // // move back the caret to the original position // temporarily so that our new block cursor can // be located within the visible area of window. // ped->ichCaret = min( ped->cch, ped->ichCaret + ich); SLScrollText(ped, hdc); ped->ichCaret = max( 0, ped->ichCaret - ich); } else { SLScrollText(ped, hdc); } SLDrawText(ped, hdc, 0); ECReleaseEditDC(ped,hdc,FALSE); // // Tell parent our text contents changed. // ECNotifyParent(ped, EN_CHANGE); } return lReturn; } return DefWindowProcWorker(ped->pwnd, WM_IME_COMPOSITION, wParam, lParam, ped->fAnsi); }

LRESULT EcImeRequestHandler (  PED  ped, WPARAM  dwSubMsg, LPARAM  lParam )

Definition at line 1735 of file edecrare.c. References BYTE, tagED::cbChar, ECImmSetCompositionWindow(), ECInOutReconversionMode(), ECLock(), ECUnlock(), tagED::fAnsi, tagED::fFocus, fpImmIsIME, tagED::hText, tagED::ichMaxSel, tagED::ichMinSel, INT, L, lpDest, LPVOID, NULL, THREAD_HKL, TRUE, and UINT. Referenced by EditWndProc(). { LRESULT lreturn = 0L; switch (dwSubMsg) { case IMR_CONFIRMRECONVERTSTRING: // Edit control does not allow IME to change it. break; case IMR_RECONVERTSTRING: // // CHECK VERSION of the structure // if (lParam && ((LPRECONVERTSTRING)lParam)->dwVersion != 0) { RIPMSG1(RIP_WARNING, "EcImeRequestHandler: RECONVERTSTRING dwVersion is not expected.", ((LPRECONVERTSTRING)lParam)->dwVersion); return 0L; } if (ped && ped->fFocus && ped->hText && fpImmIsIME(THREAD_HKL())) { UINT cchLen = ped->ichMaxSel - ped->ichMinSel; // holds character count. if (cchLen == 0) { // if we have no selection, // just return 0. break; } UserAssert(ped->cbChar == sizeof(BYTE) || ped->cbChar == sizeof(WCHAR)); // This Edit Control has selection. if (lParam == 0) { // // IME just want to get required size for buffer. // cchLen + 1 is needed to reserve room for trailing L'\0'. // ~~~~ lreturn = sizeof(RECONVERTSTRING) + (cchLen + 1) * ped->cbChar; } else { LPRECONVERTSTRING lpRCS = (LPRECONVERTSTRING)lParam; LPVOID lpSrc; LPVOID lpDest = (LPBYTE)lpRCS + sizeof(RECONVERTSTRING); // check buffer size // if the given buffer is smaller than actual needed size, // shrink our size to fit the buffer if ((INT)lpRCS->dwSize <= sizeof(RECONVERTSTRING) + cchLen * ped->cbChar) { RIPMSG0(RIP_WARNING, "EcImeRequest: ERR09"); cchLen = (lpRCS->dwSize - sizeof(RECONVERTSTRING)) / ped->cbChar - ped->cbChar; } lpRCS->dwStrOffset = sizeof(RECONVERTSTRING); // buffer begins just after RECONVERTSTRING lpRCS->dwCompStrOffset = lpRCS->dwTargetStrOffset = 0; lpRCS->dwStrLen = lpRCS->dwCompStrLen = lpRCS->dwTargetStrLen = cchLen; // StrLen means TCHAR count lpSrc = ECLock(ped); if (lpSrc == NULL) { RIPMSG0(RIP_WARNING, "EcImeRequestHandler: LOCALLOCK(ped) failed."); } else { RtlCopyMemory(lpDest, (LPBYTE)lpSrc + ped->ichMinSel * ped->cbChar, cchLen * ped->cbChar); // Null-Terminate the string if (ped->fAnsi) { LPBYTE psz = (LPBYTE)lpDest; psz[cchLen] = '\0'; } else { LPWSTR pwsz = (LPWSTR)lpDest; pwsz[cchLen] = L'\0'; } ECUnlock(ped); // final buffer size lreturn = sizeof(RECONVERTSTRING) + (cchLen + 1) * ped->cbChar; ECInOutReconversionMode(ped, TRUE); ECImmSetCompositionWindow(ped, 0, 0); } } } break; } return lreturn; }

VOID ECImmSetCompositionFont (  PED  ped  )

Definition at line 1150 of file edecrare.c. References fpImmGetContext, fpImmReleaseContext, fpImmSetCompositionFontW, tagED::hFont, tagED::hwnd, lf, NULL_HIMC, and VOID(). Referenced by ECEnableDisableIME(), ECSetFont(), and EditWndProc(). { HIMC hImc; LOGFONTW lf; if ( (hImc = fpImmGetContext( ped->hwnd )) != NULL_HIMC ) { if (ped->hFont) { GetObjectW( ped->hFont, sizeof(LOGFONTW), (LPLOGFONTW)&lf); } else { GetObjectW( GetStockObject(SYSTEM_FONT), sizeof(LOGFONTW), (LPLOGFONTW)&lf); } fpImmSetCompositionFontW( hImc, &lf ); fpImmReleaseContext( ped->hwnd, hImc ); } }

VOID ECImmSetCompositionWindow (  PED  ped, LONG  x, LONG  y )

Definition at line 1085 of file edecrare.c. References DWORD, tagED::fAnsi, tagED::fFocus, tagED::fInReconversion, fpImmGetCompositionWindow, fpImmGetContext, fpImmReleaseContext, fpImmSetCompositionWindow, tagED::fSingle, GET_X_LPARAM, GET_Y_LPARAM, GetWindowRect(), tagED::hwnd, tagED::ichMinSel, MapWindowPoints(), NULL_HIMC, tagED::ptScreenBounding, tagED::rcFmt, SetRectEmpty, and VOID(). Referenced by ECDoIMEMenuCommand(), ECEnableDisableIME(), EcImeRequestHandler(), ECSize(), EditWndProc(), MLSetCaretPosition(), and SLSetCaretPosition(). { COMPOSITIONFORM cf; COMPOSITIONFORM cft; RECT rcScreenWindow; HIMC hImc; hImc = fpImmGetContext( ped->hwnd ); if ( hImc != NULL_HIMC ) { if ( ped->fFocus ) { GetWindowRect( ped->hwnd, &rcScreenWindow); // assuming RECT.left is the first and and RECT.top is the second field MapWindowPoints( ped->hwnd, HWND_DESKTOP, (LPPOINT)&rcScreenWindow, 2); if (ped->fInReconversion) { DWORD dwPoint = (DWORD)(ped->fAnsi ? SendMessageA : SendMessageW)(ped->hwnd, EM_POSFROMCHAR, ped->ichMinSel, 0); x = GET_X_LPARAM(dwPoint); y = GET_Y_LPARAM(dwPoint); RIPMSG2(RIP_WARNING, "ECImmSetCompositionWindow: fInReconversion (%d,%d)", x, y); } // // The window currently has the focus. // if (ped->fSingle) { // // Single line edit control. // cf.dwStyle = CFS_POINT; cf.ptCurrentPos.x = x; cf.ptCurrentPos.y = y; SetRectEmpty(&cf.rcArea); } else { // // Multi line edit control. // cf.dwStyle = CFS_RECT; cf.ptCurrentPos.x = x; cf.ptCurrentPos.y = y; cf.rcArea = ped->rcFmt; } fpImmGetCompositionWindow( hImc, &cft ); if ( (!RtlEqualMemory(&cf,&cft,sizeof(COMPOSITIONFORM))) || (ped->ptScreenBounding.x != rcScreenWindow.left) || (ped->ptScreenBounding.y != rcScreenWindow.top) ) { ped->ptScreenBounding.x = rcScreenWindow.left; ped->ptScreenBounding.y = rcScreenWindow.top; fpImmSetCompositionWindow( hImc, &cf ); } } fpImmReleaseContext( ped->hwnd, hImc ); } }

VOID ECInitInsert (  PED  ped, HKL  hkl )

Definition at line 1183 of file edecrare.c. References ECSetCaretHandler(), FALSE, tagED::fInsertCompChr, tagED::fKorea, tagED::fNoMoveCaret, fpImmIsIME, tagED::fReplaceCompChr, tagED::fResultProcess, TRUE, and VOID(). Referenced by ECCreate(), ECEnableDisableIME(), and EditWndProc(). { ped->fKorea = FALSE; ped->fInsertCompChr = FALSE; ped->fNoMoveCaret = FALSE; ped->fResultProcess = FALSE; if ( fpImmIsIME(hkl) ) { if ( PRIMARYLANGID(LOWORD(HandleToUlong(hkl))) == LANG_KOREAN ) { ped->fKorea = TRUE; } // // LATER:this flag should be set based on the IME caps // retrieved from IME. (Such IME caps should be defined) // For now, we can safely assume that only Korean IMEs // set CS_INSERTCHAR. // if ( ped->fKorea ) { ped->fInsertCompChr = TRUE; } } // // if we had a composition character, the shape of caret // is changed. We need to reset the caret shape. // if ( ped->fReplaceCompChr ) { ped->fReplaceCompChr = FALSE; ECSetCaretHandler( ped ); } }

BOOL ECIsCharNumeric (  PED  ped, DWORD  keyPress )

Definition at line 1010 of file edecrare.c. References BOOL, FALSE, tagED::fAnsi, THREAD_HKL, and TRUE. Referenced by MLChar(), and SLChar(). { WORD wCharType; if (ped->fAnsi) { char ch = (char)keyPress; LCID lcid = (LCID)((ULONG_PTR)THREAD_HKL() & 0xFFFF); GetStringTypeA(lcid, CT_CTYPE1, &ch, 1, &wCharType); } else { WCHAR wch = (WCHAR)keyPress; GetStringTypeW(CT_CTYPE1, &wch, 1, &wCharType); } return (wCharType & C1_DIGIT ? TRUE : FALSE); }

BOOL ECNcCreate (  PED  ped, PWND  pwnd, LPCREATESTRUCT  lpCreateStruct )

Definition at line 285 of file edecrare.c. References BOOL, tagED::cbChar, tagED::cchAlloc, CCHALLOCEXTRA, CHAR, tagED::charWidthBuffer, tagED::chLines, ClearWindowState(), DefWindowProcWorker(), DWORD, EditLookaside, EFMULTILINE, EFREADONLY, tagED::f40Compat, FALSE, tagED::fAnsi, tagED::fBorder, tagED::fDisabled, tagED::fEncoded, tagED::fFlatBorder, FNID_CLEANEDUP_BIT, tagED::fReadOnly, FreeLookasideEntry(), tagED::fSingle, tagED::fWin31Compat, GETEXPWINVER, tagED::hImcPrev, tagED::hInstance, tagED::hText, tagED::hwnd, tagED::hwndParent, HWq, tagED::iLockLevel, LHND, tagED::lineHeight, LOCALALLOC, NtUserSetWindowFNID(), NULL, NULL_HIMC, tagED::pTabStops, TestWF, TRUE, WEFEDGEMASK, WFANSICREATOR, WFBORDER, WFDISABLED, and tagED::wImeStatus. Referenced by EditWndProc(). { HWND hwnd = HWq(pwnd); BOOL fAnsi; fAnsi = TestWF(pwnd, WFANSICREATOR); /* * Initialize the ped */ ped->fEncoded = FALSE; ped->iLockLevel = 0; ped->chLines = NULL; ped->pTabStops = NULL; ped->charWidthBuffer = NULL; ped->fAnsi = fAnsi ? 1 : 0; // Force TRUE to be 1 because its a 1 bit field ped->cbChar = (WORD)(fAnsi ? sizeof(CHAR) : sizeof(WCHAR)); ped->hInstance = pwnd->hModule; // IME ped->hImcPrev = NULL_HIMC; { DWORD dwVer = GETEXPWINVER(lpCreateStruct->hInstance); ped->fWin31Compat = (dwVer >= 0x030a); ped->f40Compat = (dwVer >= 0x0400); } // // NOTE: // The order of the following two checks is important. People can // create edit fields with a 3D and a normal border, and we don't // want to disallow that. But we need to detect the "no 3D border" // border case too. // if (TestWF(pwnd, WEFEDGEMASK)) { ped->fBorder = TRUE; } else if (TestWF(pwnd, WFBORDER)) { ClearWindowState(pwnd, WFBORDER); ped->fFlatBorder = TRUE; ped->fBorder = TRUE; } if (!TestWF(pwnd, EFMULTILINE)) ped->fSingle = TRUE; if (TestWF(pwnd, WFDISABLED)) ped->fDisabled = TRUE; if (TestWF(pwnd, EFREADONLY)) { if (!ped->fWin31Compat) { /* * BACKWARD COMPATIBILITY HACK * * "MileStone" unknowingly sets the ES_READONLY style. So, we strip this * style here for all Win3.0 apps (this style is new for Win3.1). * Fix for Bug #12982 -- SANKAR -- 01/24/92 -- */ ClearWindowState(pwnd, EFREADONLY); } else ped->fReadOnly = TRUE; } /* * Allocate storage for the text for the edit controls. Storage for single * line edit controls will always get allocated in the local data segment. * Multiline will allocate in the local ds but the app may free this and * allocate storage elsewhere... */ ped->hText = LOCALALLOC(LHND, CCHALLOCEXTRA*ped->cbChar, ped->hInstance); if (!ped->hText) { FreeLookasideEntry(&EditLookaside, ped); NtUserSetWindowFNID(hwnd, FNID_CLEANEDUP_BIT); /* No ped for this window */ return FALSE; /* If no_memory error */ } ped->cchAlloc = CCHALLOCEXTRA; ped->lineHeight = 1; ped->hwnd = hwnd; ped->hwndParent = lpCreateStruct->hwndParent; ped->wImeStatus = 0; return (BOOL)DefWindowProcWorker(pwnd, WM_NCCREATE, 0, (LPARAM)lpCreateStruct, fAnsi); }

void ECNcDestroyHandler (  PWND  pwnd, PED  ped )

Definition at line 439 of file edecrare.c. References tagED::charWidthBuffer, tagED::chLines, ComboBoxWndProcWorker(), EditLookaside, FALSE, FNID_CLEANEDUP_BIT, FNID_COMBOBOX, FreeLookasideEntry(), GETFNID, tagED::hCaretBitmap, tagED::hInstance, tagED::hText, HWq, LOCALFREE, NtUserSetWindowFNID(), NULL, tagED::pLpkEditCallout, tagED::pTabStops, PTR_TO_ID, REBASEPWND, tagWND::spmenu, UserGlobalFree, and UserLocalFree. Referenced by EditWndProc(). { PWND pwndParent; /* * ped could be NULL if WM_NCCREATE failed to create it... */ if (ped) { /* * Free the text buffer (always present?) */ LOCALFREE(ped->hText, ped->hInstance); /* * Free up undo buffer and line start array (if present) */ if (ped->hDeletedText != NULL) UserGlobalFree(ped->hDeletedText); /* * Free tab stop buffer (if present) */ if (ped->pTabStops) UserLocalFree(ped->pTabStops); /* * Free line start array (if present) */ if (ped->chLines) { UserLocalFree(ped->chLines); } /* * Free the character width buffer (if present) */ if (ped->charWidthBuffer) UserLocalFree(ped->charWidthBuffer); /* * Free the cursor bitmap */ if (ped->pLpkEditCallout && ped->hCaretBitmap) { DeleteObject(ped->hCaretBitmap); } /* * Last but not least, free the ped */ FreeLookasideEntry(&EditLookaside, ped); } /* * Set the window's fnid status so that we can ignore rogue messages */ NtUserSetWindowFNID(HWq(pwnd), FNID_CLEANEDUP_BIT); /* * If we're part of a combo box, let it know we're gone */ pwndParent = REBASEPWND(pwnd, spwndParent); if (pwndParent && GETFNID(pwndParent) == FNID_COMBOBOX) { ComboBoxWndProcWorker(pwndParent, WM_PARENTNOTIFY, MAKELONG(WM_DESTROY, PTR_TO_ID(pwnd->spmenu)), (LPARAM)HWq(pwnd), FALSE); } }

BOOL FAR PASCAL ECResultStrHandler (  PED  ped  )

Definition at line 1287 of file edecrare.c. References BOOL, tagED::cbChar, ECSetCaretHandler(), FALSE, FAR, tagED::fInsertCompChr, tagED::fNoMoveCaret, fpImmGetContext, fpImmReleaseContext, tagED::fReplaceCompChr, tagED::fResultProcess, tagED::fSingle, GET_COMPOSITION_STRING, tagED::hwnd, MLReplaceSel(), NULL, SLReplaceSel(), TRUE, UserGlobalAlloc, and UserGlobalFree. Referenced by ECImeComposition(). { HIMC himc; LPSTR lpStr; LONG dwLen; ped->fInsertCompChr = FALSE; // clear the state ped->fNoMoveCaret = FALSE; if ((himc = fpImmGetContext(ped->hwnd)) == 0) { return FALSE; } dwLen = GET_COMPOSITION_STRING(himc, GCS_RESULTSTR, NULL, 0); if (dwLen == 0) { fpImmReleaseContext(ped->hwnd, himc); return FALSE; } dwLen *= ped->cbChar; dwLen += ped->cbChar; lpStr = (LPSTR)UserGlobalAlloc(GPTR, dwLen); if (lpStr == NULL) { fpImmReleaseContext(ped->hwnd, himc); return FALSE; } GET_COMPOSITION_STRING(himc, GCS_RESULTSTR, lpStr, dwLen); if (ped->fSingle) { SLReplaceSel(ped, lpStr); } else { MLReplaceSel(ped, lpStr); } UserGlobalFree((HGLOBAL)lpStr); fpImmReleaseContext(ped->hwnd, himc); ped->fReplaceCompChr = FALSE; ped->fNoMoveCaret = FALSE; ped->fResultProcess = FALSE; ECSetCaretHandler(ped); return TRUE; }

void ECSetCaretHandler (  PED  ped  )

Definition at line 1225 of file edecrare.c. References tagED::aveCharWidth, CreateCaret, tagED::cxSysCharWidth, DestroyCaret(), ECGetEditDC(), ECLock(), ECReleaseEditDC(), ECUnlock(), tagED::fAnsi, tagED::fFocus, tagED::fReplaceCompChr, tagED::fSingle, tagED::hwnd, tagED::ichCaret, tagED::lineHeight, MLSetCaretPosition(), NtUserHideCaret(), NtUserShowCaret(), NULL, SLSetCaretPosition(), and TRUE. Referenced by ECImeComposition(), ECInitInsert(), ECResultStrHandler(), and EditWndProc(). { HDC hdc; SIZE size; PSTR pText; // if (!ped->fInsertCompChr || ped->fReadOnly) // return; // In any case destroy caret beforehand otherwise SetCaretPos() // will get crazy.. win95d-B#992,B#2370 // if (ped->fFocus) { NtUserHideCaret(ped->hwnd); DestroyCaret(); if ( ped->fReplaceCompChr ) { hdc = ECGetEditDC(ped, TRUE ); pText = ECLock(ped); if ( ped->fAnsi) GetTextExtentPointA(hdc, pText + ped->ichCaret, 2, &size); else GetTextExtentPointW(hdc, (LPWSTR)pText + ped->ichCaret, 1, &size); ECUnlock(ped); ECReleaseEditDC(ped, hdc, TRUE); CreateCaret(ped->hwnd, (HBITMAP)NULL, size.cx, ped->lineHeight); } else { CreateCaret(ped->hwnd, (HBITMAP)NULL, (ped->cxSysCharWidth > ped->aveCharWidth ? 1 : 2), ped->lineHeight); } hdc = ECGetEditDC(ped, TRUE ); if ( ped->fSingle ) SLSetCaretPosition( ped, hdc ); else MLSetCaretPosition( ped, hdc ); ECReleaseEditDC(ped, hdc, TRUE); NtUserShowCaret(ped->hwnd); } }

void ECSetFont (  PED  ped, HFONT  hfont, BOOL  fRedraw )

Definition at line 708 of file edecrare.c. References tagED::aveCharWidth, CHAR_WIDTH_BUFFER_LENGTH, tagED::charOverhang, tagED::charPasswordChar, tagED::charSet, tagED::charWidthBuffer, tagED::cxSysCharWidth, tagED::cySysCharHeight, DWORD, ECCalcMarginForDBCSFont(), ECGetCaretWidth, ECGetDBCSVector(), ECImmSetCompositionFont(), ECSetMargin(), ECSetPasswordChar(), ECSize(), tagLPKEDITCALLOUT::EditCreateCaret, tagED::f40Compat, FALSE, tagED::fDBCS, tagED::fFocus, tagED::fNonPropDBCS, tagED::fNonPropFont, fpImmIsIME, tagED::fSingle, tagED::fTrueType, tagED::fWrap, GETAPPVER, GetMaxOverlapChars(), GetNegABCwidthInfo(), gpsi, tagED::hFont, tagED::hwnd, tagED::lineHeight, MLBuildchLines(), NtUserCreateCaret(), NtUserDestroyCaret, NtUserGetDC(), NtUserHideCaret(), NtUserShowCaret(), NULL, tagED::pLpkEditCallout, ReleaseDC(), THREAD_HKL, TRUE, UINT, UserGetCharDimensionsEx(), UserLocalAlloc, UserLocalFree, UserLocalReAlloc, VER40, tagED::wMaxNegA, tagED::wMaxNegAcharPos, tagED::wMaxNegC, and tagED::wMaxNegCcharPos. Referenced by EditWndProc(), MLCreate(), and SLCreate(). { short i; TEXTMETRIC TextMetrics; HDC hdc; HFONT hOldFont=NULL; UINT wBuffSize; LPINT lpCharWidthBuff; DWORD dwMaxOverlapChars; CHWIDTHINFO cwi; UINT uExtracharPos; hdc = NtUserGetDC(ped->hwnd); if (ped->hFont = hfont) { // // Since the default font is the system font, no need to select it in // if that's what the user wants. // if (!(hOldFont = SelectObject(hdc, hfont))) { hfont = ped->hFont = NULL; } // // Get the metrics and ave char width for the currently selected font // // // Call Vertical font-aware AveWidth compute function... // // FE_SB ped->aveCharWidth = UserGetCharDimensionsEx(hdc, hfont, &TextMetrics, &ped->lineHeight); /* * This might fail when people uses network fonts (or bad fonts). */ if (ped->aveCharWidth == 0) { RIPMSG0(RIP_WARNING, "ECSetFont: GdiGetCharDimensions failed"); if (hOldFont != NULL) { SelectObject(hdc, hOldFont); } /* * We've messed up the ped so let's reset the font. * Note that we won't recurse more than once because we'll * pass hfont == NULL. * Too bad WM_SETFONT doesn't return a value. */ ECSetFont(ped, NULL, fRedraw); return; } } else { ped->aveCharWidth = gpsi->cxSysFontChar; ped->lineHeight = gpsi->cySysFontChar; TextMetrics = gpsi->tmSysFont; } ped->charOverhang = TextMetrics.tmOverhang; //assume that they don't have any negative widths at all. ped->wMaxNegA = ped->wMaxNegC = ped->wMaxNegAcharPos = ped->wMaxNegCcharPos = 0; // Check if Proportional Width Font // // NOTE: as SDK doc says about TEXTMETRIC: // TMPF_FIXED_PITCH // If this bit is set the font is a variable pitch font. If this bit is clear // the font is a fixed pitch font. Note very carefully that those meanings are // the opposite of what the constant name implies. // // Thus we have to reverse the value using logical not (fNonPropFont has 1 bit width) // ped->fNonPropFont = !(TextMetrics.tmPitchAndFamily & FIXED_PITCH); // Check for a TrueType font // Older app OZWIN chokes if we allocate a bigger buffer for TrueType fonts // So, for apps older than 4.0, no special treatment for TrueType fonts. if (ped->f40Compat && (TextMetrics.tmPitchAndFamily & TMPF_TRUETYPE)) { ped->fTrueType = GetCharWidthInfo(hdc, &cwi); #if DBG if (!ped->fTrueType) { RIPMSG0(RIP_WARNING, "ECSetFont: GetCharWidthInfo Failed"); } #endif } else { ped->fTrueType = FALSE; } // FE_SB // // In DBCS Windows, Edit Control must handle Double Byte Character // if tmCharSet field of textmetrics is double byte character set // such as SHIFTJIS_CHARSET(128:Japan), HANGEUL_CHARSET(129:Korea). // // We call ECGetDBCSVector even when fAnsi is false so that we could // treat ped->fAnsi and ped->fDBCS indivisually. I changed ECGetDBCSVector // function so that it returns 0 or 1, because I would like to set ped->fDBCS // bit field here. // ped->fDBCS = ECGetDBCSVector(ped,hdc,TextMetrics.tmCharSet); ped->charSet = TextMetrics.tmCharSet; if (ped->fDBCS) { // // Free the character width buffer if ped->fDBCS. // // I expect single GetTextExtentPoint call is faster than multiple // GetTextExtentPoint call (because the graphic engine has a cache buffer). // See editec.c/ECTabTheTextOut(). // if (ped->charWidthBuffer) { LocalFree(ped->charWidthBuffer); ped->charWidthBuffer = NULL; } // // if FullWidthChar : HalfWidthChar == 2 : 1.... // // TextMetrics.tmMaxCharWidth = FullWidthChar width // ped->aveCharWidth = HalfWidthChar width // if (ped->fNonPropFont && ((ped->aveCharWidth * 2) == TextMetrics.tmMaxCharWidth)) { ped->fNonPropDBCS = TRUE; } else { ped->fNonPropDBCS = FALSE; } } else { // // Since the font has changed, let us obtain and save the character width // info for this font. // // First left us find out if the maximum chars that can overlap due to // negative widths. Since we can't access USER globals, we make a call here. // if (!(ped->fSingle || ped->pLpkEditCallout)) { // Is this a multiline edit control with no LPK present? // // For multiline edit controls, we maintain a buffer that contains // the character width information. // wBuffSize = (ped->fTrueType) ? (CHAR_WIDTH_BUFFER_LENGTH * sizeof(ABC)) : (CHAR_WIDTH_BUFFER_LENGTH * sizeof(int)); if (ped->charWidthBuffer) { /* If buffer already present */ lpCharWidthBuff = ped->charWidthBuffer; ped->charWidthBuffer = UserLocalReAlloc(lpCharWidthBuff, wBuffSize, HEAP_ZERO_MEMORY); if (ped->charWidthBuffer == NULL) { UserLocalFree((HANDLE)lpCharWidthBuff); } } else { ped->charWidthBuffer = UserLocalAlloc(HEAP_ZERO_MEMORY, wBuffSize); } if (ped->charWidthBuffer != NULL) { if (ped->fTrueType) { ped->fTrueType = GetNegABCwidthInfo(ped, hdc); } /* * It is possible that the above attempts could have failed and reset * the value of fTrueType. So, let us check that value again. */ if (!ped->fTrueType) { if (!GetCharWidthA(hdc, 0, CHAR_WIDTH_BUFFER_LENGTH-1, ped->charWidthBuffer)) { UserLocalFree((HANDLE)ped->charWidthBuffer); ped->charWidthBuffer=NULL; } else { /* * We need to subtract out the overhang associated with * each character since GetCharWidth includes it... */ for (i=0;i < CHAR_WIDTH_BUFFER_LENGTH;i++) ped->charWidthBuffer[i] -= ped->charOverhang; } } } /* if (ped->charWidthBuffer != NULL) */ } /* if (!ped->fSingle) */ } /* if (ped->fDBCS) */ { /* * Calculate MaxNeg A C metrics */ dwMaxOverlapChars = GetMaxOverlapChars(); if (ped->fTrueType) { if (cwi.lMaxNegA < 0) ped->wMaxNegA = -cwi.lMaxNegA; else ped->wMaxNegA = 0; if (cwi.lMaxNegC < 0) ped->wMaxNegC = -cwi.lMaxNegC; else ped->wMaxNegC = 0; if (cwi.lMinWidthD != 0) { ped->wMaxNegAcharPos = (ped->wMaxNegA + cwi.lMinWidthD - 1) / cwi.lMinWidthD; ped->wMaxNegCcharPos = (ped->wMaxNegC + cwi.lMinWidthD - 1) / cwi.lMinWidthD; if (ped->wMaxNegA + ped->wMaxNegC > (UINT)cwi.lMinWidthD) { uExtracharPos = (ped->wMaxNegA + ped->wMaxNegC - 1) / cwi.lMinWidthD; ped->wMaxNegAcharPos += uExtracharPos; ped->wMaxNegCcharPos += uExtracharPos; } } else { ped->wMaxNegAcharPos = LOWORD(dwMaxOverlapChars); // Left ped->wMaxNegCcharPos = HIWORD(dwMaxOverlapChars); // Right } } else if (ped->charOverhang != 0) { /* * Some bitmaps fonts (i.e., italic) have under/overhangs; * this is pretty much like having negative A and C widths. */ ped->wMaxNegA = ped->wMaxNegC = ped->charOverhang; ped->wMaxNegAcharPos = LOWORD(dwMaxOverlapChars); // Left ped->wMaxNegCcharPos = HIWORD(dwMaxOverlapChars); // Right } } /* if (ped->fDBCS) */ if (!hfont) { // // We are getting the stats for the system font so update the system // font fields in the ed structure since we use these when calculating // some spacing. // ped->cxSysCharWidth = ped->aveCharWidth; ped->cySysCharHeight= ped->lineHeight; } else if (hOldFont) SelectObject(hdc, hOldFont); if (ped->fFocus) { // // Update the caret. // NtUserHideCaret(ped->hwnd); NtUserDestroyCaret(); if (ped->pLpkEditCallout) { ped->pLpkEditCallout->EditCreateCaret (ped, hdc, ECGetCaretWidth(), ped->lineHeight, 0); } else { NtUserCreateCaret(ped->hwnd, (HBITMAP)NULL, ECGetCaretWidth(), ped->lineHeight); } NtUserShowCaret(ped->hwnd); } ReleaseDC(ped->hwnd, hdc); // // Update password character. // if (ped->charPasswordChar) ECSetPasswordChar(ped, ped->charPasswordChar); // // If it is a TrueType font and it's a new app, set both the margins at the // max negative width values for all types of the edit controls. // (NOTE: Can't use ped->f40Compat here because edit-controls inside dialog // boxes without DS_LOCALEDIT style are always marked as 4.0 compat. // This is the fix for NETBENCH 3.0) // if (ped->fTrueType && (GETAPPVER() >= VER40)) if (ped->fDBCS) { // For DBCS TrueType Font, we calc margin from ABC width. ECCalcMarginForDBCSFont(ped, fRedraw); } else { ECSetMargin(ped, EC_LEFTMARGIN | EC_RIGHTMARGIN, MAKELONG(EC_USEFONTINFO, EC_USEFONTINFO), fRedraw); } // // We need to calc maxPixelWidth when font changes. // If the word-wrap is ON, then this is done in MLSize() called later. // if((!ped->fSingle) && (!ped->fWrap)) MLBuildchLines(ped, 0, 0, FALSE, NULL, NULL); // // Recalc the layout. // ECSize(ped, NULL, fRedraw); if ( ped->fFocus && fpImmIsIME(THREAD_HKL()) ) { ECImmSetCompositionFont( ped ); } }

void ECSetMargin (  PED  ped, UINT  wFlags, long  lMarginValues, BOOL  fRedraw )

Definition at line 49 of file edecrare.c. References tagED::aveCharWidth, BOOL, ECInvalidateClient(), FALSE, min, tagED::rcFmt, TRUE, UINT, tagED::wLeftMargin, tagED::wMaxNegA, tagED::wMaxNegC, and tagED::wRightMargin. Referenced by ECCalcMarginForDBCSFont(), ECSetFont(), and EditWndProc(). { BOOL fUseFontInfo = FALSE; UINT wValue, wOldLeftMargin, wOldRightMargin; if (wFlags & EC_LEFTMARGIN) /* Set the left margin */ { if ((int) (wValue = (int)(short)LOWORD(lMarginValues)) < 0) { fUseFontInfo = TRUE; wValue = min((ped->aveCharWidth / 2), (int)ped->wMaxNegA); } ped->rcFmt.left += wValue - ped->wLeftMargin; wOldLeftMargin = ped->wLeftMargin; ped->wLeftMargin = wValue; } if (wFlags & EC_RIGHTMARGIN) /* Set the Right margin */ { if ((int) (wValue = (int)(short)HIWORD(lMarginValues)) < 0) { fUseFontInfo = TRUE; wValue = min((ped->aveCharWidth / 2), (int)ped->wMaxNegC); } ped->rcFmt.right -= wValue - ped->wRightMargin; wOldRightMargin = ped->wRightMargin; ped->wRightMargin = wValue; } if (fUseFontInfo) { if (ped->rcFmt.right - ped->rcFmt.left < 2 * ped->aveCharWidth) { RIPMSG0(RIP_WARNING, "ECSetMargin: rcFmt is too narrow for EC_USEFONTINFO"); if (wFlags & EC_LEFTMARGIN) /* Reset the left margin */ { ped->rcFmt.left += wOldLeftMargin - ped->wLeftMargin; ped->wLeftMargin = wOldLeftMargin; } if (wFlags & EC_RIGHTMARGIN) /* Reset the Right margin */ { ped->rcFmt.right -= wOldRightMargin - ped->wRightMargin; ped->wRightMargin = wOldRightMargin; } return; } } // NtUserInvalidateRect(ped->hwnd, NULL, TRUE); if (fRedraw) { ECInvalidateClient(ped, TRUE); } }

void ECSetPasswordChar (  PED  ped, UINT  pwchar )

Definition at line 516 of file edecrare.c. References tagED::charPasswordChar, ClearWindowState(), tagED::cPasswordCharWidth, ECEnableDisableIME(), ECGetEditDC(), ECReleaseEditDC(), EFPASSWORD, tagED::fAnsi, max, tagED::pwnd, SetWindowState(), and TRUE. Referenced by ECSetFont(), EditWndProc(), and SLCreate(). { HDC hdc; SIZE size; ped->charPasswordChar = pwchar; if (pwchar) { hdc = ECGetEditDC(ped, TRUE); if (ped->fAnsi) GetTextExtentPointA(hdc, (LPSTR)&pwchar, 1, &size); else GetTextExtentPointW(hdc, (LPWSTR)&pwchar, 1, &size); GetTextExtentPointW(hdc, (LPWSTR)&pwchar, 1, &size); ped->cPasswordCharWidth = max(size.cx, 1); ECReleaseEditDC(ped, hdc, TRUE); } if (pwchar) SetWindowState(ped->pwnd, EFPASSWORD); else ClearWindowState(ped->pwnd, EFPASSWORD); ECEnableDisableIME(ped); }

void ECSize (  PED  ped, LPRECT  lprc, BOOL  fRedraw )

Definition at line 597 of file edecrare.c. References _GetClientRect(), tagED::aveCharWidth, CopyRect, ECImmSetCompositionWindow(), FALSE, tagED::fBorder, tagED::fCaretHidden, tagED::fFlatBorder, tagED::fFocus, fpImmIsIME, tagED::fSingle, tagED::hwnd, InflateRect(), tagED::lineHeight, min, MLSize(), NtUserGetCaretPos(), NtUserInvalidateRect(), NULL, tagED::pwnd, tagED::rcFmt, SYSMET, THREAD_HKL, TRUE, tagED::wLeftMargin, and tagED::wRightMargin. Referenced by ECSetFont(), MLEditWndProc(), and SLEditWndProc(). { RECT rc; /* * BiDi VB32 Creates an Edit Control and immediately sends a WM_SIZE * message which causes EXSize to be called before ECSetFont, which * in turn causes a divide by zero exception below. This check for * ped->lineHeight will pick it up safely. [samera] 3/5/97 */ if(ped->lineHeight == 0) return; // assume that we won't be able to display the caret ped->fCaretHidden = TRUE; if ( lprc ) CopyRect(&rc, lprc); else _GetClientRect(ped->pwnd, &rc); if (!(rc.right - rc.left) || !(rc.bottom - rc.top)) { if (ped->rcFmt.right - ped->rcFmt.left) return; rc.left = 0; rc.top = 0; rc.right = ped->aveCharWidth * 10; rc.bottom = ped->lineHeight; } if (!lprc) { // subtract the margins from the given rectangle -- // make sure that this rectangle is big enough to have these margins. if ((rc.right - rc.left) > (int)(ped->wLeftMargin + ped->wRightMargin)) { rc.left += ped->wLeftMargin; rc.right -= ped->wRightMargin; } } // // Leave space so text doesn't touch borders. // For 3.1 compatibility, don't subtract out vertical borders unless // there is room. // if (ped->fBorder) { int cxBorder = SYSMET(CXBORDER); int cyBorder = SYSMET(CYBORDER); if (ped->fFlatBorder) { cxBorder *= 2; cyBorder *= 2; } if (rc.bottom < rc.top + ped->lineHeight + 2*cyBorder) cyBorder = 0; InflateRect(&rc, -cxBorder, -cyBorder); } // Is the resulting rectangle too small? Don't change it then. if ((!ped->fSingle) && ((rc.right - rc.left < (int) ped->aveCharWidth) || ((rc.bottom - rc.top) / ped->lineHeight == 0))) return; // now, we know we're safe to display the caret ped->fCaretHidden = FALSE; CopyRect(&ped->rcFmt, &rc); if (ped->fSingle) ped->rcFmt.bottom = min(rc.bottom, rc.top + ped->lineHeight); else MLSize(ped, fRedraw); if (fRedraw) { NtUserInvalidateRect(ped->hwnd, NULL, TRUE); // UpdateWindow31(ped->hwnd); Evaluates to NOP in Chicago - Johnl } // FE_IME // ECSize() - call ECImmSetCompositionWindow() // // normally this isn't needed because WM_SIZE will cause // WM_PAINT and the paint handler will take care of IME // composition window. However when the edit window is // restored from maximized window and client area is out // of screen, the window will not be redrawn. // if (ped->fFocus && fpImmIsIME(THREAD_HKL())) { POINT pt; NtUserGetCaretPos(&pt); ECImmSetCompositionWindow(ped, pt.x, pt.y); } }

DWORD GetMaxOverlapChars (  void   )

Definition at line 39 of file edecrare.c. References DWORD, and gpsi. Referenced by ECSetFont(). { return (DWORD) MAKELONG( gpsi->wMaxLeftOverlapChars, gpsi->wMaxRightOverlapChars ) ; }

BOOL GetNegABCwidthInfo (  PED  ped, HDC  hdc )

Definition at line 555 of file edecrare.c. References BOOL, CHAR_WIDTH_BUFFER_LENGTH, tagED::charOverhang, tagED::charWidthBuffer, FALSE, and TRUE. Referenced by ECSetFont(). { LPABC lpABCbuff; int i; int CharWidthBuff[CHAR_WIDTH_BUFFER_LENGTH]; // Local char width buffer. int iOverhang; if (!GetCharABCWidthsA(hdc, 0, CHAR_WIDTH_BUFFER_LENGTH-1, (LPABC)ped->charWidthBuffer)) { RIPMSG0(RIP_WARNING, "GetNegABCwidthInfo: GetCharABCWidthsA Failed"); return FALSE; } // The (A+B+C) returned for some fonts (eg: Lucida Caligraphy) does not // equal the actual advanced width returned by GetCharWidths() minus overhang. // This is due to font bugs. So, we adjust the 'B' width so that this // discrepancy is removed. // Fix for Bug #2932 --sankar-- 02/17/93 iOverhang = ped->charOverhang; GetCharWidthA(hdc, 0, CHAR_WIDTH_BUFFER_LENGTH-1, (LPINT)CharWidthBuff); lpABCbuff = (LPABC)ped->charWidthBuffer; for(i = 0; i < CHAR_WIDTH_BUFFER_LENGTH; i++) { lpABCbuff->abcB = CharWidthBuff[i] - iOverhang - lpABCbuff->abcA - lpABCbuff->abcC; lpABCbuff++; } return(TRUE); }

BOOL HanjaKeyHandler (  PED  ped  )

Definition at line 1683 of file edecrare.c. References BOOL, tagED::cbChar, tagED::cch, ECLock(), ECUnlock(), FALSE, tagED::fAnsi, tagED::fKorea, fpImmEscapeA, fpImmEscapeW, fpImmGetContext, tagED::fReadOnly, tagED::fReplaceCompChr, tagED::hwnd, ICH, tagED::ichCaret, tagED::ichMaxSel, tagED::ichMinSel, NtUserMessageBeep, THREAD_HKL, and TRUE. Referenced by MLKeyDown(), and SLKeyDown(). { BOOL changeSelection = FALSE; if (ped->fKorea && !ped->fReadOnly) { ICH oldCaret = ped->ichCaret; if (ped->fReplaceCompChr) return FALSE; if (ped->ichMinSel < ped->ichMaxSel) ped->ichCaret = ped->ichMinSel; if (!ped->cch || ped->cch == ped->ichCaret) { ped->ichCaret = oldCaret; NtUserMessageBeep(MB_ICONEXCLAMATION); return FALSE; } if (ped->fAnsi) { if (fpImmEscapeA(THREAD_HKL(), fpImmGetContext(ped->hwnd), IME_ESC_HANJA_MODE, (ECLock(ped) + ped->ichCaret * ped->cbChar))) { changeSelection = TRUE; } else ped->ichCaret = oldCaret; ECUnlock(ped); } else { if (fpImmEscapeW(THREAD_HKL(), fpImmGetContext(ped->hwnd), IME_ESC_HANJA_MODE, (ECLock(ped) + ped->ichCaret * ped->cbChar))) { changeSelection = TRUE; } else ped->ichCaret = oldCaret; ECUnlock(ped); } } return changeSelection; }

void MLReplaceSel (  PED  , LPSTR  )

Definition at line 1309 of file editml.c. { ICH cchText; // // Delete text, which will put it into the clean undo buffer. // ECEmptyUndo(Pundo(ped)); MLDeleteText(ped); // // B#3356 // Some apps do "clear" by selecting all of the text, then replacing // it with "", in which case MLInsertText() will return 0. But that // doesn't mean failure... // if ( ped->fAnsi ) cchText = strlen(lpText); else cchText = wcslen((LPWSTR)lpText); if (cchText ) { BOOL fFailed; UNDO undo; HWND hwndSave; // // B#1385,1427 // Save undo buffer, but DO NOT CLEAR IT. We want to restore it // if insertion fails due to OOM. // ECSaveUndo(Pundo(ped), (PUNDO)&undo, FALSE); hwndSave = ped->hwnd; fFailed = (BOOL) !MLInsertText(ped, lpText, cchText, FALSE); if (!IsWindow(hwndSave)) return; if (fFailed) { // // UNDO the previous edit // ECSaveUndo((PUNDO)&undo, Pundo(ped), FALSE); MLUndo(ped); } } }

int UserGetCharDimensionsEx (  HDC  hDC, HFONT  hfont, LPTEXTMETRIC  lptm, LPINT  lpcy )

Definition at line 185 of file edecrare.c. References AveCharWidthData, L, and lf. Referenced by ECSetFont(). { int cxWidth; TEXTMETRIC tm; LOGFONTW lf; WCHAR wchFaceName[LF_FACESIZE]; // // Is this font vertical font ?? // GetTextFaceW(hDC, LF_FACESIZE, wchFaceName); if (wchFaceName[0] != L'@') { // // if not call GDI... // return(GdiGetCharDimensions(hDC, lptm, lpcy)); } if (!lptm) lptm = &tm; GetTextMetrics(hDC, lptm); // TMPF_FIXED_PITCH // // If this bit is set the font is a variable pitch font. // If this bit is clear the font is a fixed pitch font. // Note very carefully that those meanings are the opposite of what the constant name implies. // if (!(lptm->tmPitchAndFamily & TMPF_FIXED_PITCH)) { // If !variable_width font // This is fixed pitch font.... cxWidth = lptm->tmAveCharWidth; } else { // This is variable pitch font... if (hfont && GetObjectW(hfont, sizeof(LOGFONTW), &lf) && (lf.lfEscapement != 0)) { cxWidth = lptm->tmAveCharWidth; } else { SIZE size; GetTextExtentPointW(hDC, AveCharWidthData, 52, &size); cxWidth = ((size.cx / 26) + 1) / 2; } } if (lpcy) *lpcy = lptm->tmHeight; return(cxWidth); }

---

Variable Documentation

WCHAR AveCharWidthData[] = L"abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"

Definition at line 176 of file edecrare.c. Referenced by UserGetCharDimensionsEx().

LOOKASIDE EditLookaside

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

---