ntimm.c File Reference

#include "precomp.h"

Go to the source code of this file.

Functions
PIMC	CreateInputContext (ULONG_PTR dwClientImcData)
BOOL	DestroyInputContext (IN PIMC pImc)
VOID	FreeInputContext (IN PIMC pImc)
BOOL	UpdateInputContext (IN PIMC pImc, IN UPDATEINPUTCONTEXTCLASS UpdateType, IN ULONG_PTR UpdateValue)
HIMC	AssociateInputContext (IN PWND pWnd, IN PIMC pImc)
AIC_STATUS	AssociateInputContextEx (IN PWND pWnd, IN PIMC pImc, IN DWORD dwFlag)
VOID	xxxFocusSetInputContext (IN PWND pWnd, IN BOOL fActivate, IN BOOL fQueueMsg)
UINT	BuildHimcList (PTHREADINFO pti, UINT cHimcMax, HIMC *ccxphimcFirst)
PWND	xxxCreateDefaultImeWindow (IN PWND pwnd, IN ATOM atomT, IN HANDLE hInst)
BOOL	xxxImmActivateThreadsLayout (PTHREADINFO pti, PTLBLOCK ptlBlockPrev, PKL pkl)
VOID	xxxImmActivateAndUnloadThreadsLayout (IN PTHREADINFO *ptiList, IN UINT nEntries, IN PTLBLOCK ptlBlockPrev, PKL pklCurrent, DWORD dwHklReplace)
VOID	xxxImmActivateLayout (IN PTHREADINFO pti, IN PKL pkl)
VOID	xxxImmUnloadThreadsLayout (IN PTHREADINFO *ptiList, IN UINT nEntries, IN PTLBLOCK ptlBlockPrev, IN DWORD dwFlag)
VOID	xxxImmUnloadLayout (IN PTHREADINFO pti, IN DWORD dwFlag)
PIMEINFOEX	xxxImmLoadLayout (IN HKL hKL)
BOOL	GetImeInfoEx (PWINDOWSTATION pwinsta, PIMEINFOEX piiex, IMEINFOEXCLASS SearchType)
BOOL	SetImeInfoEx (PWINDOWSTATION pwinsta, PIMEINFOEX piiex)
DWORD	xxxImmProcessKey (IN PQ pq, IN PWND pwnd, IN UINT message, IN WPARAM wParam, IN LPARAM lParam)
BOOL	ImeCanDestroyDefIME (PWND pwndDefaultIme, PWND pwndDestroy)
BOOL	IsChildSameThread (PWND pwndParent, PWND pwndChild)
BOOL	ImeCanDestroyDefIMEforChild (PWND pwndDefaultIme, PWND pwndDestroy)
VOID	ImeCheckTopmost (PWND pwndIme)
VOID	ImeSetFutureOwner (PWND pwndIme, PWND pwndOrgOwner)
VOID	ImeSetTopmostChild (PWND pwndParent, BOOL fMakeTopmost)
PWND	GetLastTopMostWindowNoIME (PWND pwndRoot)
VOID	ImeSetTopmost (PWND pwndRootIme, BOOL fMakeTopmost, PWND pwndInsertBefore)
PSOFTKBDDATA	ProbeAndCaptureSoftKbdData (PSOFTKBDDATA Source)
VOID	SetConvMode (PTHREADINFO pti, DWORD dwConversion)
VOID	xxxNotifyIMEStatus (IN PWND pwnd, IN DWORD dwOpen, IN DWORD dwConversion)
BOOL	xxxCheckImeShowStatus (PWND pwndIme, PTHREADINFO pti)
LRESULT	xxxSendMessageToUI (PTHREADINFO ptiIme, PIMEUI pimeui, UINT message, WPARAM wParam, LPARAM lParam)
VOID	xxxSendOpenStatusNotify (PTHREADINFO ptiIme, PIMEUI pimeui, PWND pwndApp, BOOL fOpen)
VOID	xxxNotifyImeShowStatus (PWND pwndIme)
BOOL	xxxSetIMEShowStatus (IN BOOL fShow)
VOID	xxxBroadcastImeShowStatusChange (PWND pwndIme, BOOL fShow)
VOID	xxxCheckImeShowStatusInThread (PWND pwndIme)
BOOL	_GetIMEShowStatus (VOID)
Variables
CONST WCHAR	wszDefaultIme [] = L"Default IME"

---

Function Documentation

BOOL _GetIMEShowStatus (  VOID   )

Definition at line 2705 of file ntimm.c. References BOOL, FALSE, and gfIMEShowStatus. Referenced by xxxSystemParametersInfo(). { return gfIMEShowStatus != FALSE; }

HIMC AssociateInputContext (  IN PWND  pWnd, IN PIMC  pImc )

Definition at line 289 of file ntimm.c. References PtoH. Referenced by AssociateInputContextEx(), and DestroyInputContext(). { HIMC hImcRet = pWnd->hImc; pWnd->hImc = (HIMC)PtoH(pImc); return hImcRet; }

AIC_STATUS AssociateInputContextEx (  IN PWND  pWnd, IN PIMC  pImc, IN DWORD  dwFlag )

Definition at line 299 of file ntimm.c. References AIC_ERROR, AIC_FOCUSCONTEXTCHANGED, AIC_STATUS, AIC_SUCCESS, AssociateInputContext(), BOOL, BuildHwndList(), BWL_ENUMCHILDREN, BWL_ENUMLIST, FreeHwndList(), GETPTI, tagWND::hImc, NULL, NULL_HIMC, tagTHREADINFO::pq, PtiCurrent, PtoH, RevalidateHwnd, tagBWL::rghwnd, tagTHREADINFO::spDefaultImc, tagQ::spwndFocus, and Status. Referenced by NtUserAssociateInputContext(). { PTHREADINFO ptiWnd = GETPTI(pWnd); PWND pWndFocus = ptiWnd->pq->spwndFocus; HIMC hImcFocus = pWndFocus->hImc; BOOL fIgnoreNoContext = (dwFlag & IACE_IGNORENOCONTEXT) == IACE_IGNORENOCONTEXT; AIC_STATUS Status = AIC_SUCCESS; if (dwFlag & IACE_DEFAULT) { /* * use default input context. */ pImc = ptiWnd->spDefaultImc; } else if (pImc != NULL && GETPTI(pImc) != ptiWnd) { /* * Cannot associate input context to window created * by other thread. */ RIPERR0(ERROR_ACCESS_DENIED, RIP_WARNING, "AssociateInputContextEx: pwnd not of Imc pti"); return AIC_ERROR; } /* * Cannot do association under different process context. */ if (GETPTI(pWnd)->ppi != PtiCurrent()->ppi) { RIPERR0(ERROR_ACCESS_DENIED, RIP_WARNING, "AssociateInputContextEx: pwnd not of current ppi"); return AIC_ERROR; } /* * Finally, make sure they are on the same desktop. */ if (pImc != NULL && pImc->head.rpdesk != pWnd->head.rpdesk) { RIPERR0(ERROR_ACCESS_DENIED, RIP_WARNING, "AssociateInputContextEx: no desktop access"); return AIC_ERROR; } /* * If IACE_CHILDREN is specified, associate the input context * to the child windows of pWnd as well. */ if ((dwFlag & IACE_CHILDREN) && pWnd->spwndChild != NULL) { PBWL pbwl; PWND pwndT; HWND *phwndT; pbwl = BuildHwndList(pWnd->spwndChild, BWL_ENUMLIST|BWL_ENUMCHILDREN, ptiWnd); if (pbwl != NULL) { for (phwndT = pbwl->rghwnd; *phwndT != (HWND)1; phwndT++) { /* * Make sure this hwnd is still around. */ if ((pwndT = RevalidateHwnd(*phwndT)) == NULL) continue; if (pwndT->hImc == (HIMC)PtoH(pImc)) continue; if (pwndT->hImc == NULL_HIMC && fIgnoreNoContext) continue; AssociateInputContext(pwndT, pImc); if (pwndT == pWndFocus) Status = AIC_FOCUSCONTEXTCHANGED; } FreeHwndList(pbwl); } } /* * Associate the input context to pWnd. */ if (pWnd->hImc != NULL_HIMC || !fIgnoreNoContext) { if (pWnd->hImc != (HIMC)PtoH(pImc)) { AssociateInputContext(pWnd, pImc); if (pWnd == pWndFocus) Status = AIC_FOCUSCONTEXTCHANGED; } } return Status; }

UINT BuildHimcList (  PTHREADINFO  pti, UINT  cHimcMax, HIMC *  ccxphimcFirst )

Definition at line 475 of file ntimm.c. References FALSE, NULL, tagIMC::pImcNext, PtiCurrent, tagTHREADINFO::ptiSibling, PtoH, tagTHREADINFO::spDefaultImc, and UINT. Referenced by ImmEnumInputContext(), and NtUserBuildHimcList(). { PIMC pImcT; UINT i = 0; if (pti == NULL) { /* * Build the list which contains all IMCs created by calling process. */ for (pti = PtiCurrent()->ppi->ptiList; pti != NULL; pti = pti->ptiSibling) { pImcT = pti->spDefaultImc; while (pImcT != NULL) { if (i < cHimcMax) { try { ccxphimcFirst[i] = (HIMC)PtoH(pImcT); } except (W32ExceptionHandler(FALSE, RIP_WARNING)) { } } i++; pImcT = pImcT->pImcNext; } } } else { /* * Build the list which contains all IMCs created by specified thread. */ pImcT = pti->spDefaultImc; while (pImcT != NULL) { if (i < cHimcMax) { try { ccxphimcFirst[i] = (HIMC)PtoH(pImcT); } except (W32ExceptionHandler(FALSE, RIP_WARNING)) { } } i++; pImcT = pImcT->pImcNext; } } return i; }

PIMC CreateInputContext (  ULONG_PTR  dwClientImcData  )

Definition at line 40 of file ntimm.c. References tagTHREADINFO::amdesk, tagIMC::dwClientImcData, HMAllocObject(), IS_IME_ENABLED, Lock, NULL, tagIMC::pImcNext, PtiCurrentShared, RETURN_IF_ACCESS_DENIED, tagTHREADINFO::rpdesk, tagTHREADINFO::spDefaultImc, TIF_DISABLEIME, tagTHREADINFO::TIF_flags, and TYPE_INPUTCONTEXT. { PTHREADINFO ptiCurrent; PIMC pImc; PDESKTOP pdesk = NULL; ptiCurrent = PtiCurrentShared(); /* * Only for thread that wants IME processing. */ if ((ptiCurrent->TIF_flags & TIF_DISABLEIME) || !IS_IME_ENABLED()) { RIPMSG1(RIP_VERBOSE, "CreateInputContext: TIF_DISABLEIME or !IME Enabled. pti=%#p", ptiCurrent); return NULL; } /* * If pti->spDefaultImc is NULL (means this is the first instance) * but dwClientImcData is not 0, some bogus application like NtCrash * has tried to trick the kernel. Just bail out. */ if (dwClientImcData != 0 && ptiCurrent->spDefaultImc == NULL) { RIPMSG2(RIP_WARNING, "CreateInputContext: bogus value(0x%08x) is passed. pti=%#p", dwClientImcData, ptiCurrent); return NULL; } /* * If the windowstation has been initialized, allocate from * the current desktop. */ pdesk = ptiCurrent->rpdesk; #ifdef LATER RETURN_IF_ACCESS_DENIED(ptiCurrent->amdesk, DESKTOP_CREATEINPUTCONTEXT, NULL); #else if (ptiCurrent->rpdesk == NULL) { return NULL; } #endif pImc = HMAllocObject(ptiCurrent, pdesk, TYPE_INPUTCONTEXT, sizeof(IMC)); if (pImc == NULL) { RIPMSG0(RIP_WARNING, "CreateInputContext: out of memory"); return NULL; } if (dwClientImcData == 0) { /* * We are creating default input context for current thread. * Initialize the default input context as head of the * per-thread IMC list. */ UserAssert(ptiCurrent->spDefaultImc == NULL); Lock(&ptiCurrent->spDefaultImc, pImc); pImc->pImcNext = NULL; } else { /* * Link it to the per-thread IMC list. */ UserAssert(ptiCurrent->spDefaultImc != NULL); pImc->pImcNext = ptiCurrent->spDefaultImc->pImcNext; ptiCurrent->spDefaultImc->pImcNext = pImc; } pImc->dwClientImcData = dwClientImcData; return pImc; }

BOOL DestroyInputContext (  IN PIMC  pImc  )

Definition at line 122 of file ntimm.c. References AssociateInputContext(), _HANDLEENTRY::bFlags, BOOL, BuildHwndList(), BWL_ENUMCHILDREN, BWL_ENUMLIST, FALSE, FreeHwndList(), GETPTI, HANDLEF_DESTROY, tagWND::hImc, HMDestroyUnlockedObject(), HMPheFromObject, NULL, tagDESKTOP::pDeskInfo, PtiCurrent, PtoH, RevalidateHwnd, tagBWL::rghwnd, tagTHREADINFO::rpdesk, tagTHREADINFO::spDefaultImc, tagDESKTOPINFO::spwnd, tagWND::spwndChild, and TRUE. Referenced by ImmDestroyContext(), ImmDllInitialize(), and NtUserDestroyInputContext(). { PTHREADINFO ptiImcOwner; PBWL pbwl; PWND pwnd; HWND *phwnd; PHE phe; ptiImcOwner = GETPTI(pImc); /* * Cannot destroy input context from other thread. */ if (ptiImcOwner != PtiCurrent()) { RIPERR0(ERROR_ACCESS_DENIED, RIP_WARNING, "DestroyInputContext: pImc not of current pti"); return FALSE; } /* * Cannot destroy default input context. */ if (pImc == ptiImcOwner->spDefaultImc) { RIPERR0(ERROR_INVALID_PARAMETER, RIP_WARNING, "DestroyInputContext: can't destroy default Imc"); return FALSE; } /* * Cleanup destroyed input context from each associated window. */ pbwl = BuildHwndList(ptiImcOwner->rpdesk->pDeskInfo->spwnd->spwndChild, BWL_ENUMLIST|BWL_ENUMCHILDREN, ptiImcOwner); if (pbwl != NULL) { for (phwnd = pbwl->rghwnd; *phwnd != (HWND)1; phwnd++) { /* * Make sure this hwnd is still around. */ if ((pwnd = RevalidateHwnd(*phwnd)) == NULL) continue; /* * Cleanup by associating the default input context. */ if (pwnd->hImc == (HIMC)PtoH(pImc)) AssociateInputContext(pwnd, ptiImcOwner->spDefaultImc); } FreeHwndList(pbwl); } phe = HMPheFromObject(pImc); /* * Make sure this object isn't already marked to be destroyed - we'll * do no good if we try to destroy it now since it is locked. */ if (!(phe->bFlags & HANDLEF_DESTROY)) HMDestroyUnlockedObject(phe); return TRUE; }

VOID FreeInputContext (  IN PIMC  pImc  )

Definition at line 198 of file ntimm.c. References GETPTI, HMFreeObject(), HMMarkObjectDestroy(), NULL, tagIMC::pImcNext, and VOID(). { PIMC pImcT; /* * Mark it for destruction. If it the object is locked it can't * be freed right now. */ if (!HMMarkObjectDestroy((PVOID)pImc)) return; /* * Unlink it. */ pImcT = GETPTI(pImc)->spDefaultImc; while (pImcT != NULL && pImcT->pImcNext != pImc) pImcT = pImcT->pImcNext; if (pImcT != NULL) pImcT->pImcNext = pImc->pImcNext; /* * We're really going to free the input context. */ HMFreeObject((PVOID)pImc); return; }

BOOL GetImeInfoEx (  PWINDOWSTATION  pwinsta, PIMEINFOEX  piiex, IMEINFOEXCLASS  SearchType )

Definition at line 1166 of file ntimm.c. References BOOL, FALSE, tagIMEINFOEX::hkl, tagKL::hkl, IM_FILE_SIZE, ImeInfoExImeFileName, ImeInfoExKeyboardLayout, NULL, tagKL::piiex, tagKL::pklNext, tagWINDOWSTATION::spklList, TRUE, and tagIMEINFOEX::wszImeFile. { PKL pkl, pklFirst; /* * Note: this check was forced to insert due to winmm.dll who indirectly * loads imm32.dll in CSRSS context. CSRSS is not always bound to * specific window station, thus pwinsta could be NULL. * This has been avoided by not loading imm32.dll. * After winmm.dll gets removed from CSRSS, this if statement should be * removed, or substituted as an assertion. */ if (pwinsta == NULL) { return FALSE; } /* * Keyboard layer has not been initialized. */ if (pwinsta->spklList == NULL) return FALSE; pkl = pklFirst = pwinsta->spklList; switch (SearchType) { case ImeInfoExKeyboardLayout: do { if (pkl->hkl == piiex->hkl) { if (pkl->piiex == NULL) break; RtlCopyMemory(piiex, pkl->piiex, sizeof(IMEINFOEX)); return TRUE; } pkl = pkl->pklNext; } while (pkl != pklFirst); break; case ImeInfoExImeFileName: do { if (pkl->piiex != NULL && !_wcsnicmp(pkl->piiex->wszImeFile, piiex->wszImeFile, IM_FILE_SIZE)) { RtlCopyMemory(piiex, pkl->piiex, sizeof(IMEINFOEX)); return TRUE; } pkl = pkl->pklNext; } while (pkl != pklFirst); break; default: break; } return FALSE; }

PWND GetLastTopMostWindowNoIME (  PWND  pwndRoot  )

Definition at line 1891 of file ntimm.c. References _GetDesktopWindow(), tagCLS::atomClassName, tagSERVERINFO::atomSysClass, BOOL, CFIME, FALSE, gpsi, ICLS_IME, NULL, tagWND::pcls, tagWND::spwndChild, tagWND::spwndNext, tagWND::spwndOwner, TestCF, TestWF, TRUE, and WEFTOPMOST. Referenced by ImeSetTopmost(). { PWND pwndT = _GetDesktopWindow(); PWND pwndRet = NULL; /* * pwndRoot should not be NULL, and should be IME window. */ UserAssert(pwndRoot && pwndRoot->pcls->atomClassName == gpsi->atomSysClass[ICLS_IME]); if (pwndT == NULL || pwndT->spwndChild == NULL) { #if _DBG if (pwndT == NULL) { RIPMSG0(RIP_WARNING, "GetLastTopMostWindowNoIME: there's no desktop window !!"); } else { RIPMSG0(RIP_WARNING, "GetLastTopMostWindowNoIME: there is no toplevel window !!"); } #endif return NULL; } /* * Get the first child of the desktop window. */ pwndT = pwndT->spwndChild; /* * Loop through the toplevel windows while they are topmost. */ while (TestWF(pwndT, WEFTOPMOST)) { PWND pwndOwner = pwndT; BOOL fOwned = FALSE; /* * If pwndT is a IME related window, track the owner. If pwndRoot is not * pwndT's owner, remember pwndT as a candidate. */ if (TestCF(pwndT,CFIME) || (pwndT->pcls->atomClassName == gpsi->atomSysClass[ICLS_IME])) { while (pwndOwner != NULL) { if (pwndRoot == pwndOwner) { fOwned = TRUE; break; } pwndOwner = pwndOwner->spwndOwner; } } if (!fOwned) pwndRet = pwndT; /* * Next toplevel window. */ pwndT = pwndT->spwndNext; UserAssert(pwndT->spwndParent == _GetDesktopWindow()); } return pwndRet; }

BOOL ImeCanDestroyDefIME (  PWND  pwndDefaultIme, PWND  pwndDestroy )

Definition at line 1503 of file ntimm.c. References tagCLS::atomClassName, tagSERVERINFO::atomSysClass, BOOL, CFIME, FALSE, gpsi, ICLS_IME, ImeCheckTopmost(), ImeSetFutureOwner(), NULL, tagWND::pcls, ProbeAndReadStructure, tagWND::spwndNext, tagWND::spwndOwner, TestCF, TRUE, and Unlock. { PWND pwnd; PIMEUI pimeui; pimeui = ((PIMEWND)pwndDefaultIme)->pimeui; if (pimeui == NULL || (LONG_PTR)pimeui == (LONG_PTR)-1) return FALSE; try { if (ProbeAndReadStructure(pimeui, IMEUI).fDestroy) { return FALSE; } } except (W32ExceptionHandler(FALSE, RIP_WARNING)) { } /* * If the pwndDestroy has no owner/ownee relationship with * pwndDefaultIme, don't bother to change anything. * * If pwndDefaultIme->spwndOwner is NULL, this means we need * to search for a new good owner window. */ if ( pwndDefaultIme->spwndOwner != NULL ) { for (pwnd = pwndDefaultIme->spwndOwner; pwnd != pwndDestroy && pwnd != NULL; pwnd = pwnd->spwndOwner) ; if (pwnd == NULL) return FALSE; } /* * If the destroying window is IME or UI window, do nothing */ pwnd = pwndDestroy; while (pwnd != NULL) { if (TestCF(pwnd, CFIME) || pwnd->pcls->atomClassName == gpsi->atomSysClass[ICLS_IME]) return FALSE; pwnd = pwnd->spwndOwner; } ImeSetFutureOwner(pwndDefaultIme, pwndDestroy); /* * If new owner is lower z-order than IME class window, * we need to check topmost to change z-order. */ pwnd = pwndDefaultIme->spwndOwner; while (pwnd != NULL && pwnd != pwndDefaultIme) pwnd = pwnd->spwndNext; if (pwnd == pwndDefaultIme) ImeCheckTopmost(pwndDefaultIme); #if DBG CheckOwnerCirculate(pwndDefaultIme); #endif /* * If ImeSetFutureOwner can not find the owner window any * more, this IME window should be destroyed. */ if (pwndDefaultIme->spwndOwner == NULL || pwndDestroy == pwndDefaultIme->spwndOwner) { // RIPMSG1(RIP_WARNING, "ImeCanDestroyDefIME: TRUE for pwnd=%#p", pwndDestroy); Unlock(&pwndDefaultIme->spwndOwner); /* * Return TRUE! Please destroy me. */ return TRUE; } return FALSE; }

BOOL ImeCanDestroyDefIMEforChild (  PWND  pwndDefaultIme, PWND  pwndDestroy )

Definition at line 1687 of file ntimm.c. References BOOL, FALSE, GETPTI, IsChildSameThread(), NULL, ProbeAndReadStructure, PWNDDESKTOP, tagWND::spwndParent, and TRUE. { PWND pwnd; PIMEUI pimeui; pimeui = ((PIMEWND)pwndDefaultIme)->pimeui; /* * If this window is not for Child Thread..... */ if (pimeui == NULL || (LONG_PTR)pimeui == (LONG_PTR)-1) return FALSE; try { if (!ProbeAndReadStructure(pimeui, IMEUI).fChildThreadDef) { return FALSE; } } except (W32ExceptionHandler(FALSE, RIP_WARNING)) { } /* * If parent belongs to different thread, * we don't need to check any more... */ if (pwndDestroy->spwndParent == NULL || GETPTI(pwndDestroy) == GETPTI(pwndDestroy->spwndParent)) return FALSE; pwnd = pwndDestroy; while (pwnd != NULL && pwnd != PWNDDESKTOP(pwnd)) { if (IsChildSameThread(pwnd->spwndParent, pwndDestroy)) return FALSE; pwnd = pwnd->spwndParent; } /* * We could not find any other window created by GETPTI(pwndDestroy). * Let's destroy the default IME window of this Q. */ return TRUE; }

VOID ImeCheckTopmost (  PWND  pwndIme  )

Definition at line 1740 of file ntimm.c. References GETPTI, gptiForeground, ImeSetTopmost(), NULL, tagWND::spwndOwner, TestWF, VOID(), and WEFTOPMOST. { if (pwndIme->spwndOwner) { PWND pwndInsertBeforeThis; /* * The ime window have to be same topmost tyle with the owner window. * If the Q of this window is not foreground Q, we don't need to * forground the IME window. * But the topmost attribute of owner was changed, this IME window * should be re-calced. */ if (GETPTI(pwndIme) == gptiForeground) { pwndInsertBeforeThis = NULL; } else { pwndInsertBeforeThis = pwndIme->spwndOwner; } ImeSetTopmost(pwndIme, TestWF(pwndIme->spwndOwner, WEFTOPMOST) != 0, pwndInsertBeforeThis); } }

VOID ImeSetFutureOwner (  PWND  pwndIme, PWND  pwndOrgOwner )

Definition at line 1770 of file ntimm.c. References tagCLS::atomClassName, tagSERVERINFO::atomSysClass, CFIME, GETPTI, gpsi, ICLS_IME, ICLS_MENU, Lock, NULL, tagWND::pcls, tagWND::spwndChild, tagWND::spwndNext, tagWND::spwndOwner, tagWND::spwndParent, TestCF, TestWF, VOID(), WFBOTTOMMOST, WFCHILD, and WFINDESTROY. { PWND pwnd, pwndOwner; PTHREADINFO ptiImeWnd = GETPTI(pwndIme); if (pwndOrgOwner == NULL || TestWF(pwndOrgOwner, WFCHILD)) return; pwnd = pwndOrgOwner; /* * Get top of owner created by the same thread. */ while ((pwndOwner = pwnd->spwndOwner) != NULL && GETPTI(pwndOwner) == ptiImeWnd) pwnd = pwndOwner; /* * Bottom window can not be the owner of IME window easily... */ if (TestWF(pwnd, WFBOTTOMMOST) && !TestWF(pwndOrgOwner, WFBOTTOMMOST)) pwnd = pwndOrgOwner; /* * CS_IME class or "IME" class windows can not be the owner of * IME windows. */ if (TestCF(pwnd, CFIME) || pwnd->pcls->atomClassName == gpsi->atomSysClass[ICLS_IME]) pwnd = pwndOrgOwner; /* * If hwndOrgOwner is a top of owner, we start to search * another top owner window in same queue. */ if (pwndOrgOwner == pwnd && pwnd->spwndParent != NULL) { PWND pwndT; for (pwndT = pwnd->spwndParent->spwndChild; pwndT != NULL; pwndT = pwndT->spwndNext) { if (GETPTI(pwnd) != GETPTI(pwndT)) continue; if (pwndT->pcls->atomClassName == gpsi->atomSysClass[ICLS_MENU]) continue; /* * CS_IME class or "IME" class windows can not be the owner of * IME windows. */ if (TestCF(pwndT, CFIME) || pwndT->pcls->atomClassName == gpsi->atomSysClass[ICLS_IME]) continue; // We don't like the window that is being destroyed. if (TestWF(pwndT, WFINDESTROY)) continue; /* * !!!!WARNING!!!!! * Is hwndT a good owner of hIMEwnd?? * 1. Of cource, it should no CHILD window! * 2. If it is hwnd,.. I know it and find next! * 3. Does hwndT have owner in the same thread? */ if (!TestWF(pwndT, WFCHILD) && pwnd != pwndT && (pwndT->spwndOwner == NULL || GETPTI(pwndT) != GETPTI(pwndT->spwndOwner))) { UserAssert(GETPTI(pwndIme) == GETPTI(pwndT)); pwnd = pwndT; break; } } } UserAssert(!TestCF(pwnd, CFIME)); Lock(&pwndIme->spwndOwner, pwnd); return; }

VOID ImeSetTopmost (  PWND  pwndRootIme, BOOL  fMakeTopmost, PWND  pwndInsertBefore )

Definition at line 1995 of file ntimm.c. References tagCLS::atomClassName, tagSERVERINFO::atomSysClass, CFIME, ClrWF, FALSE, GetLastTopMostWindowNoIME(), GETPTI, gpsi, ICLS_IME, ImeSetTopmostChild(), LinkWindow(), NULL, tagWND::pcls, PWND_TOP, SetWF, tagWND::spwndChild, tagWND::spwndNext, tagWND::spwndOwner, tagWND::spwndParent, TestCF, TestWF, TRUE, UnlinkWindow(), VOID(), WEFTOPMOST, and WFBOTTOMMOST. { PWND pwndParent = pwndRootIme->spwndParent; PWND pwndInsert = PWND_TOP; // pwnd which should be prior to pwndRootIme. PWND pwnd, pwndT; PWND pwndInsertFirst; BOOLEAN fFound; if (pwndParent == NULL) return; pwnd = pwndParent->spwndChild; if (!fMakeTopmost) { /* * Get the last topmost window. This should be after unlink pwndRootIme * because pwndRootIme may be the last topmost window. */ pwndInsert = GetLastTopMostWindowNoIME(pwndRootIme); if (pwndInsertBefore) { fFound = FALSE; pwndT = pwndInsert; while (pwndT != NULL && pwndT->spwndNext != pwndInsertBefore) { if (pwndT == pwndRootIme) fFound = TRUE; pwndT = pwndT->spwndNext; } if (pwndT == NULL || fFound) return; pwndInsert = pwndT; } if (TestWF(pwndRootIme->spwndOwner, WFBOTTOMMOST)) { pwndT = pwndInsert; while (pwndT != NULL && pwndT != pwndRootIme->spwndOwner) { if (!TestCF(pwndT, CFIME) && pwndT->pcls->atomClassName != gpsi->atomSysClass[ICLS_IME]) { pwndInsert = pwndT; } pwndT = pwndT->spwndNext; } } } pwndInsertFirst = pwndInsert; /* * Enum the all toplevel windows and if the owner of the window is same as * the owner of pwndRootIme, the window should be changed the position of * window link. */ while (pwnd != NULL) { /* * Get the next window before calling ImeSetTopmost. * Because the next window will be changed in LinkWindow. */ PWND pwndNext = pwnd->spwndNext; /* * the owner relation between IME and UI window is in same thread. */ if (GETPTI(pwnd) != GETPTI(pwndRootIme)) goto ist_next; /* * pwnd have to be CS_IME class or "IME" class. */ if (!TestCF(pwnd, CFIME) && pwnd->pcls->atomClassName != gpsi->atomSysClass[ICLS_IME]) goto ist_next; /* * If pwnd is pwndInsert, we don't need to do anything... */ if (pwnd == pwndInsert) goto ist_next; pwndT = pwnd; while (pwndT != NULL) { if (pwndT == pwndRootIme) { /* * Found!! * pwnd is the ownee of pwndRootIme. */ UserAssert(GETPTI(pwnd) == GETPTI(pwndRootIme)); UserAssert(TestCF(pwnd,CFIME) || (pwnd->pcls->atomClassName == gpsi->atomSysClass[ICLS_IME])); UserAssert(pwnd != pwndInsert); UnlinkWindow(pwnd, pwndParent); if (fMakeTopmost) { if (pwndInsert != PWND_TOP) UserAssert(TestWF(pwndInsert, WEFTOPMOST)); SetWF(pwnd, WEFTOPMOST); } else { if (pwndInsert == PWND_TOP) { /* * In rare cases, the first toplevel window could be the one we'll look next, * who may still have obscure topmost flag. */ UserAssert(pwndParent->spwndChild == pwndNext || !TestWF(pwndParent->spwndChild, WEFTOPMOST)); } else if (pwndInsert->spwndNext != NULL) { /* * In rare cases, pwndInsert->spwndNext could be the one we'll look next, * who may still have obscure topmost flag. */ UserAssert(pwndInsert->spwndNext == pwndNext || !TestWF(pwndInsert->spwndNext, WEFTOPMOST)); } ClrWF(pwnd, WEFTOPMOST); } LinkWindow(pwnd, pwndInsert, pwndParent); #if 0 // Let's see what happens if we disable this ImeSetTopmostChild(pwnd, fMakeTopmost); #endif pwndInsert = pwnd; break; // goto ist_next; } pwndT = pwndT->spwndOwner; } ist_next: pwnd = pwndNext; /* * Skip the windows that were inserted before. */ if (pwnd != NULL && pwnd == pwndInsertFirst) pwnd = pwndInsert->spwndNext; #if DBG if (pwnd) ImeCheckSetTopmostLink(pwnd, pwndInsertFirst, pwndInsert); #endif } }

VOID ImeSetTopmostChild (  PWND  pwndParent, BOOL  fMakeTopmost )

Definition at line 1862 of file ntimm.c. References ClrWF, ImeSetTopmostChild(), NULL, SetWF, tagWND::spwndChild, tagWND::spwndNext, VOID(), and WEFTOPMOST. { PWND pwnd = pwndParent->spwndChild; while (pwnd != NULL) { if (fMakeTopmost) SetWF(pwnd, WEFTOPMOST); else ClrWF(pwnd, WEFTOPMOST); ImeSetTopmostChild(pwnd, fMakeTopmost); pwnd = pwnd->spwndNext; } return; }

BOOL IsChildSameThread (  PWND  pwndParent, PWND  pwndChild )

Definition at line 1594 of file ntimm.c. References tagCLS::atomClassName, tagSERVERINFO::atomSysClass, BOOL, CFIME, FALSE, GETPTI, gpsi, ICLS_IME, ICLS_MENU, NULL, tagWND::pcls, tagWND::spwndChild, tagWND::spwndNext, tagWND::spwndOwner, tagWND::spwndParent, TestCF, TestwndChild, and TRUE. { PWND pwnd; PTHREADINFO ptiChild = GETPTI(pwndChild); for (pwnd = pwndParent->spwndChild; pwnd; pwnd = pwnd->spwndNext) { /* * If pwnd is not child window, we need to skip MENU window and * IME related window. */ if (!TestwndChild(pwnd)) { PWND pwndOwner = pwnd; BOOL fFoundOwner = FALSE; /* * Skip MENU window. */ if (pwnd->pcls->atomClassName == gpsi->atomSysClass[ICLS_MENU]) continue; while (pwndOwner != NULL) { /* * CS_IME class or "IME" class windows can not be the owner of * IME windows. */ if (TestCF(pwndOwner, CFIME) || pwndOwner->pcls->atomClassName == gpsi->atomSysClass[ICLS_IME]) { fFoundOwner = TRUE; break; } pwndOwner = pwndOwner->spwndOwner; } if (fFoundOwner) continue; } /* * We need to skip pwndChild. */ if (pwnd == pwndChild) continue; /* * pwnd and pwndChild are on same thread? */ if (GETPTI(pwnd) == ptiChild) { PWND pwndT = pwnd; BOOL fFoundImeWnd = FALSE; /* * Check again. If hwndT is children or ownee of * IME related window, skip it. */ if (TestwndChild(pwndT)) { for (; TestwndChild(pwndT) && GETPTI(pwndT) == ptiChild; pwndT = pwndT->spwndParent) { if (TestCF(pwndT, CFIME) || pwndT->pcls->atomClassName == gpsi->atomSysClass[ICLS_IME]) fFoundImeWnd = TRUE; } } if (!TestwndChild(pwndT)) { for (; pwndT != NULL && GETPTI(pwndT) == ptiChild; pwndT = pwndT->spwndOwner) { if (TestCF(pwndT, CFIME) || pwndT->pcls->atomClassName == gpsi->atomSysClass[ICLS_IME]) fFoundImeWnd = TRUE; } } if (!fFoundImeWnd) return TRUE; } } return FALSE; }

PSOFTKBDDATA ProbeAndCaptureSoftKbdData (  PSOFTKBDDATA  Source  )

Definition at line 2154 of file ntimm.c. References BYTE, DWORD, ExRaiseStatus(), NULL, ProbeAndReadUlong, ProbeForReadBuffer, TRUE, and UINT. Referenced by MESSAGECALL(). { PSOFTKBDDATA Destination = NULL; DWORD cbSize; UINT uCount; try { uCount = ProbeAndReadUlong((PULONG)Source); #if defined(_X86_) ProbeForReadBuffer(&Source->wCode, uCount, sizeof(BYTE)); #else ProbeForReadBuffer(&Source->wCode, uCount, sizeof(WORD)); #endif cbSize = FIELD_OFFSET(SOFTKBDDATA, wCode[0]) + uCount * sizeof(WORD) * 256; Destination = (PSOFTKBDDATA)UserAllocPool(cbSize, TAG_IME); if (Destination != NULL) { RtlCopyMemory(Destination, Source, cbSize); } else { ExRaiseStatus(STATUS_NO_MEMORY); } } except (W32ExceptionHandler(TRUE, RIP_WARNING)) { if (Destination != NULL) { UserFreePool(Destination); } return NULL; } return Destination; }

VOID SetConvMode (  PTHREADINFO  pti, DWORD  dwConversion )

Definition at line 2196 of file ntimm.c. References ClearKeyStateDown, ClearKeyStateToggle, tagKL::hkl, NULL, tagTHREADINFO::pq, SetKeyStateDown, SetKeyStateToggle, tagTHREADINFO::spklActive, and VOID(). Referenced by xxxNotifyIMEStatus(). { if ( pti->spklActive == NULL ) return; switch ( PRIMARYLANGID(HandleToUlong(pti->spklActive->hkl)) ) { case LANG_JAPANESE: ClearKeyStateDown(pti->pq, VK_DBE_ALPHANUMERIC); ClearKeyStateToggle(pti->pq, VK_DBE_ALPHANUMERIC); ClearKeyStateDown(pti->pq, VK_DBE_KATAKANA); ClearKeyStateToggle(pti->pq, VK_DBE_KATAKANA); ClearKeyStateDown(pti->pq, VK_DBE_HIRAGANA); ClearKeyStateToggle(pti->pq, VK_DBE_HIRAGANA); if ( dwConversion & IME_CMODE_NATIVE ) { if ( dwConversion & IME_CMODE_KATAKANA ) { SetKeyStateDown( pti->pq, VK_DBE_KATAKANA); SetKeyStateToggle( pti->pq, VK_DBE_KATAKANA); } else { SetKeyStateDown( pti->pq, VK_DBE_HIRAGANA); SetKeyStateToggle( pti->pq, VK_DBE_HIRAGANA); } } else { SetKeyStateDown( pti->pq, VK_DBE_ALPHANUMERIC); SetKeyStateToggle( pti->pq, VK_DBE_ALPHANUMERIC); } if ( dwConversion & IME_CMODE_FULLSHAPE ) { SetKeyStateDown( pti->pq, VK_DBE_DBCSCHAR); SetKeyStateToggle( pti->pq, VK_DBE_DBCSCHAR); ClearKeyStateDown(pti->pq, VK_DBE_SBCSCHAR); ClearKeyStateToggle(pti->pq, VK_DBE_SBCSCHAR); } else { SetKeyStateDown( pti->pq, VK_DBE_SBCSCHAR); SetKeyStateToggle( pti->pq, VK_DBE_SBCSCHAR); ClearKeyStateDown(pti->pq, VK_DBE_DBCSCHAR); ClearKeyStateToggle(pti->pq, VK_DBE_DBCSCHAR); } if ( dwConversion & IME_CMODE_ROMAN ) { SetKeyStateDown( pti->pq, VK_DBE_ROMAN); SetKeyStateToggle( pti->pq, VK_DBE_ROMAN); ClearKeyStateDown(pti->pq, VK_DBE_NOROMAN); ClearKeyStateToggle(pti->pq, VK_DBE_NOROMAN); } else { SetKeyStateDown( pti->pq, VK_DBE_NOROMAN); SetKeyStateToggle( pti->pq, VK_DBE_NOROMAN); ClearKeyStateDown(pti->pq, VK_DBE_ROMAN); ClearKeyStateToggle(pti->pq, VK_DBE_ROMAN); } if ( dwConversion & IME_CMODE_CHARCODE ) { SetKeyStateDown( pti->pq, VK_DBE_CODEINPUT); SetKeyStateToggle( pti->pq, VK_DBE_CODEINPUT); ClearKeyStateDown(pti->pq, VK_DBE_NOCODEINPUT); ClearKeyStateToggle(pti->pq, VK_DBE_NOCODEINPUT); } else { SetKeyStateDown( pti->pq, VK_DBE_NOCODEINPUT); SetKeyStateToggle( pti->pq, VK_DBE_NOCODEINPUT); ClearKeyStateDown(pti->pq, VK_DBE_CODEINPUT); ClearKeyStateToggle(pti->pq, VK_DBE_CODEINPUT); } break; case LANG_KOREAN: if ( dwConversion & IME_CMODE_NATIVE) { SetKeyStateToggle( pti->pq, VK_HANGUL); } else { ClearKeyStateToggle( pti->pq, VK_HANGUL); } if ( dwConversion & IME_CMODE_FULLSHAPE ) { SetKeyStateToggle( pti->pq, VK_JUNJA); } else { ClearKeyStateToggle( pti->pq, VK_JUNJA); } if ( dwConversion & IME_CMODE_HANJACONVERT ) { SetKeyStateToggle( pti->pq, VK_HANJA); } else { ClearKeyStateToggle( pti->pq, VK_HANJA); } break; default: break; } return; }

BOOL SetImeInfoEx (  PWINDOWSTATION  pwinsta, PIMEINFOEX  piiex )

Definition at line 1237 of file ntimm.c. References BOOL, FALSE, tagIMEINFOEX::fLoadFlag, tagIMEINFOEX::hkl, tagKL::hkl, IMEF_NONLOAD, NULL, tagKL::piiex, tagKL::pklNext, tagWINDOWSTATION::spklList, and TRUE. { PKL pkl, pklFirst; if (pwinsta == NULL) { return FALSE; } UserAssert(pwinsta->spklList != NULL); pkl = pklFirst = pwinsta->spklList; do { if (pkl->hkl == piiex->hkl) { /* * Error out for non-IME based keyboard layout. */ if (pkl->piiex == NULL) return FALSE; /* * Update kernel side IMEINFOEX for this keyboard layout * only if this is its first loading. */ if (pkl->piiex->fLoadFlag == IMEF_NONLOAD) { RtlCopyMemory(pkl->piiex, piiex, sizeof(IMEINFOEX)); } return TRUE; } pkl = pkl->pklNext; } while (pkl != pklFirst); return FALSE; }

BOOL UpdateInputContext (  IN PIMC  pImc, IN UPDATEINPUTCONTEXTCLASS  UpdateType, IN ULONG_PTR  UpdateValue )

Definition at line 239 of file ntimm.c. References BOOL, FALSE, GETPTI, tagTHREADINFO::ppi, PtiCurrent, TRUE, UpdateClientInputContext, and UpdateInUseImeWindow. Referenced by NtUserUpdateInputContext(). { PTHREADINFO ptiCurrent, ptiImcOwner; ptiCurrent = PtiCurrent(); ptiImcOwner = GETPTI(pImc); /* * Cannot update input context from other process. */ if (ptiImcOwner->ppi != ptiCurrent->ppi) { RIPERR0(ERROR_ACCESS_DENIED, RIP_WARNING, "UpdateInputContext: pImc not of current ppi"); return FALSE; } switch (UpdateType) { case UpdateClientInputContext: if (pImc->dwClientImcData != 0) { RIPERR0(RIP_WARNING, RIP_WARNING, "UpdateInputContext: pImc->dwClientImcData != 0"); return FALSE; } pImc->dwClientImcData = UpdateValue; break; case UpdateInUseImeWindow: pImc->hImeWnd = (HWND)UpdateValue; break; default: return FALSE; } return TRUE; }

VOID xxxBroadcastImeShowStatusChange (  PWND  pwndIme, BOOL  fShow )

Definition at line 2679 of file ntimm.c. References CheckCritIn, gfIMEShowStatus, VOID(), and xxxNotifyImeShowStatus(). { CheckCritIn(); gfIMEShowStatus = !!fShow; xxxNotifyImeShowStatus(pwndIme); }

BOOL xxxCheckImeShowStatus (  PWND  pwndIme, PTHREADINFO  pti )

Definition at line 2375 of file ntimm.c. References tagCLS::atomClassName, tagSERVERINFO::atomSysClass, BOOL, BuildHwndList(), BWL_ENUMLIST, FALSE, FreeHwndList(), tagIMEUI::fShowStatus, GETPTI, gpsi, tagIMEUI::hwndIMC, ICLS_IME, KeAttachProcess(), KeDetachProcess(), L, NULL, tagWND::pcls, PHWND, tagTHREADINFO::ppi, ProbeAndReadStructure, PtiCurrent, RevalidateHwnd, tagBWL::rghwnd, tagWND::spwndChild, tagWND::spwndParent, TestWF, ThreadLockAlways, ThreadUnlock, TIF_INCLEANUP, TRUE, WFINDESTROY, and xxxSendMessage(). Referenced by xxxCheckImeShowStatusInThread(), and xxxNotifyImeShowStatus(). { PBWL pbwl; PHWND phwnd; BOOL fRet = FALSE; PTHREADINFO ptiCurrent = PtiCurrent(); if (TestWF(pwndIme, WFINDESTROY)) { return FALSE; } // Parent window of IME window should be the desktop window UserAssert(pwndIme); UserAssert(pwndIme->spwndParent == GETPTI(pwndIme)->pDeskInfo->spwnd); pbwl = BuildHwndList(pwndIme->spwndParent->spwndChild, BWL_ENUMLIST, NULL); if (pbwl != NULL) { fRet = TRUE; for (phwnd = pbwl->rghwnd; *phwnd != (HWND)1; phwnd++) { PWND pwndT = RevalidateHwnd(*phwnd); // If pwndT is the current active IME window, we should skip it // since it's the only one window allowed to show status, and // we've already taken care of it. if (pwndT == NULL || (/*pwndIme && */pwndIme == pwndT)) { // Can skip pwndIme != NULL test continue; } // We are going to touch IME windows only if (pwndT->pcls->atomClassName == gpsi->atomSysClass[ICLS_IME] && !TestWF(pwndT, WFINDESTROY)) { PIMEUI pimeui = ((PIMEWND)pwndT)->pimeui; if (pimeui == NULL || pimeui == (PIMEUI)-1) { continue; } if (pti == NULL || pti == GETPTI(pwndT)) { BOOLEAN fAttached = FALSE; PWND pwndIMC; // If pwndT is not a window of the current process, we have to138163 // attach the process to get access to pimeui. if (GETPTI(pwndT)->ppi != ptiCurrent->ppi) { RIPMSG0(RIP_VERBOSE, "Attaching process in xxxCheckImeShowStatus"); KeAttachProcess(&GETPTI(pwndT)->ppi->Process->Pcb); fAttached = TRUE; } try { if (ProbeAndReadStructure(pimeui, IMEUI).fShowStatus) { if (pti == NULL) { RIPMSG0(RIP_VERBOSE, "xxxCheckImeShowStatus: the status window is shown !!"); } if ((pwndIMC = RevalidateHwnd(pimeui->hwndIMC)) != NULL) { pimeui->fShowStatus = FALSE; } } else { pwndIMC = NULL; } } except (W32ExceptionHandler(FALSE, RIP_WARNING)) { pwndIMC = NULL; } if (fAttached) { KeDetachProcess(); } if (pwndIMC && GETPTI(pwndIMC) && !(GETPTI(pwndIMC)->TIF_flags & TIF_INCLEANUP)) { TL tl; ThreadLockAlways(pwndIMC, &tl); RIPMSG1(RIP_VERBOSE, "Sending WM_IME_NOTIFY to %#p, IMN_CLOSESTATUSWINDOW", pwndIMC); xxxSendMessage(pwndIMC, WM_IME_NOTIFY, IMN_CLOSESTATUSWINDOW, 0L); ThreadUnlock(&tl); } } } } FreeHwndList(pbwl); } return fRet; }

VOID xxxCheckImeShowStatusInThread (  PWND  pwndIme  )

Definition at line 2694 of file ntimm.c. References GETPTI, IS_IME_ENABLED, TestWF, VOID(), WFINDESTROY, and xxxCheckImeShowStatus(). { if (IS_IME_ENABLED()) { UserAssert(pwndIme); if (!TestWF(pwndIme, WFINDESTROY)) { xxxCheckImeShowStatus(pwndIme, GETPTI(pwndIme)); } } }

PWND xxxCreateDefaultImeWindow (  IN PWND  pwnd, IN ATOM  atomT, IN HANDLE  hInst )

Definition at line 531 of file ntimm.c. References tagSERVERINFO::atomSysClass, CFIME, CreateInputContext(), DesktopAlloc(), DesktopFree, DTAG_IMETEXT, DWORD, FALSE, GETPTI, gpidLogon, gpsi, hInst, ICLS_IME, NULL, tagDESKTOP::pheapDesktop, tagTHREADINFO::ppi, ProbeForWrite(), PtiCurrentShared, tagTHREADINFO::rpdesk, RtlInitLargeUnicodeString(), tagTHREADINFO::spDefaultImc, tagTHREADINFO::spwndDefaultIme, TestCF, TestWF, TestwndChild, ThreadLock, ThreadUnlock, TIF_DISABLEIME, tagTHREADINFO::TIF_flags, TRUE, UINT, VER40, WFSERVERSIDEPROC, wszDefaultIme, and xxxCreateWindowEx(). Referenced by xxxCreateWindowEx(). { LARGE_STRING strWindowName; PWND pwndDefaultIme; TL tlpwnd; PIMEUI pimeui; PTHREADINFO ptiCurrent = PtiCurrentShared(); LPWSTR pwszDefaultIme; UserAssert(ptiCurrent == GETPTI(pwnd) && ptiCurrent->spwndDefaultIme == NULL); /* * Those conditions should have been checked by WantImeWindow() * before xxxCreateDefaultImeWindow gets called. */ UserAssert(!(ptiCurrent->TIF_flags & TIF_DISABLEIME)); UserAssert(!TestWF(pwnd, WFSERVERSIDEPROC)); /* * The first Winlogon thread starts without default input context. * Create it now. */ if (ptiCurrent->spDefaultImc == NULL && ptiCurrent->pEThread->Cid.UniqueProcess == gpidLogon) CreateInputContext(0); /* * No default IME window for thread that doesn't have * default input context */ if (ptiCurrent->spDefaultImc == NULL) return (PWND)NULL; /* * Avoid recursion */ if (atomT == gpsi->atomSysClass[ICLS_IME] || TestCF(pwnd, CFIME)) return (PWND)NULL; /* * B#12165-win95b * Yet MFC does another nice. We need to avoid to give an IME window * to the child of desktop window which is in different process. */ if (TestwndChild(pwnd) && GETPTI(pwnd->spwndParent)->ppi != ptiCurrent->ppi && !(pwnd->style & WS_VISIBLE)) return (PWND)NULL; if (ptiCurrent->rpdesk->pheapDesktop == NULL) return (PWND)NULL; /* * Allocate storage for L"Default IME" string from desktop heap * so that it can be referenced from USER32.DLL in user mode. */ pwszDefaultIme = (LPWSTR)DesktopAlloc(ptiCurrent->rpdesk, sizeof(wszDefaultIme), DTAG_IMETEXT); if (pwszDefaultIme == NULL) return (PWND)NULL; RtlCopyMemory(pwszDefaultIme, wszDefaultIme, sizeof(wszDefaultIme)); RtlInitLargeUnicodeString((PLARGE_UNICODE_STRING)&strWindowName, pwszDefaultIme, (UINT)-1); ThreadLock(pwnd, &tlpwnd); pwndDefaultIme = xxxCreateWindowEx( (DWORD)0, (PLARGE_STRING)gpsi->atomSysClass[ICLS_IME], (PLARGE_STRING)&strWindowName, WS_POPUP | WS_DISABLED, 0, 0, 0, 0, pwnd, (PMENU)NULL, hInst, NULL, VER40); if (pwndDefaultIme != NULL) { pimeui = ((PIMEWND)pwndDefaultIme)->pimeui; UserAssert(pimeui != NULL && (LONG_PTR)pimeui != (LONG_PTR)-1); try { ProbeForWrite(pimeui, sizeof *pimeui, sizeof(DWORD)); pimeui->fDefault = TRUE; if (TestwndChild(pwnd) && GETPTI(pwnd->spwndParent) != ptiCurrent) { pimeui->fChildThreadDef = TRUE; } } except (W32ExceptionHandler(FALSE, RIP_WARNING)) { } } ThreadUnlock(&tlpwnd); DesktopFree(ptiCurrent->rpdesk, pwszDefaultIme); return pwndDefaultIme; }

VOID xxxFocusSetInputContext (  IN PWND  pWnd, IN BOOL  fActivate, IN BOOL  fQueueMsg )

Definition at line 405 of file ntimm.c. References tagSERVERINFO::atomSysClass, CFIME, CheckLock, GETPTI, gpsi, HWq, ICLS_IME, L, NULL, tagTHREADINFO::spwndDefaultIme, TestCF, TestWF, ThreadLockAlways, ThreadUnlock, tagTHREADINFO::TIF_flags, TIF_INCLEANUP, VOID(), WFDESTROYED, xxxSendMessage(), and xxxSendMessageCallback(). Referenced by CancelInputState(), xxxDeactivate(), xxxDestroyWindow(), and xxxSendFocusMessages(). { PTHREADINFO pti; PWND pwndDefaultIme; TL tlpwndDefaultIme; CheckLock(pWnd); pti = GETPTI(pWnd); /* * CS_IME class or "IME" class windows can not be SetActivated to hImc. * WinWord 6.0 US Help calls ShowWindow with the default IME window. * HELPMACROS get the default IME window by calling GetNextWindow(). */ if (TestCF(pWnd, CFIME) || (pWnd->pcls->atomClassName == gpsi->atomSysClass[ICLS_IME])) return; /* * Do nothing if the thread does not have default IME window. */ if ((pwndDefaultIme = pti->spwndDefaultIme) == NULL) return; /* * If the thread is going away or the default IME window is being vanished, * then do nothing. */ if (pti->TIF_flags & TIF_INCLEANUP) return; UserAssert(!TestWF(pwndDefaultIme, WFDESTROYED)); ThreadLockAlways(pwndDefaultIme, &tlpwndDefaultIme); if (fQueueMsg) { xxxSendMessageCallback(pwndDefaultIme, WM_IME_SYSTEM, fActivate ? IMS_ACTIVATECONTEXT : IMS_DEACTIVATECONTEXT, (LPARAM)HWq(pWnd), NULL, 1L, 0); } else { xxxSendMessage(pwndDefaultIme, WM_IME_SYSTEM, fActivate ? IMS_ACTIVATECONTEXT : IMS_DEACTIVATECONTEXT, (LPARAM)HWq(pWnd)); } #if _DBG if (pti->spwndDefaultIme != pwndDefaultIme) { RIPMSG1(RIP_WARNING, "pti(%#p)->spwndDefaultIme got freed during the callback.", pti); } #endif ThreadUnlock(&tlpwndDefaultIme); return; }

VOID xxxImmActivateAndUnloadThreadsLayout (  IN PTHREADINFO *  ptiList, IN UINT  nEntries, IN PTLBLOCK  ptlBlockPrev, PKL  pklCurrent, DWORD  dwHklReplace )

Definition at line 749 of file ntimm.c. References CheckLock, tagKL::CodePage, dwFlags, DWORD, FALSE, tagKL::hkl, IFL_DEACTIVATEIME, INT, IS_IME_KBDLAYOUT, KeAttachProcess(), KeDetachProcess(), tagTLBLOCK::list, Lock, NULL, tagTHREADINFO::pClientInfo, tagTHREADINFO::ppi, PtiCurrentShared, tagTLBLOCK::ptlBlockPrev, ThreadLockPti, THREADS_PER_TLBLOCK, ThreadUnlockPti, TIF_INCLEANUP, TRUE, VOID(), xxxImmActivateLayout(), and xxxImmUnloadLayout(). Referenced by xxxSetPKLinThreads(). { TLBLOCK tlBlock; PTHREADINFO ptiCurrent; int i, cThreads; enum { RUN_ACTIVATE = 1, RUN_UNLOAD = 2, RUN_FLAGS_MASK = RUN_ACTIVATE | RUN_UNLOAD, RUN_INVALID = 0xffff0000 }; CheckLock(pklCurrent); ptiCurrent = PtiCurrentShared(); tlBlock.ptlBlockPrev = ptlBlockPrev; /* * Build a list of threads that we need to unload their IME DLL(s). * We can't just walk the ptiList while we're doing the work, because * for IME based keyboard layout, we will do callback to client side * and the pti could get deleted out while we leave the critical section. */ for (i = 0, cThreads = 0; i < (INT)nEntries; i++) { DWORD dwFlags = 0; /* * Skip all the *do nothing* cases in xxxImmActivateLayout * so as to minimize the # of TLBLOCKs required. */ if (ptiList[i]->TIF_flags & TIF_INCLEANUP) { dwFlags = RUN_INVALID; } else if (ptiList[i]->spklActive != pklCurrent) { if (ptiList[i]->spwndDefaultIme == NULL) { BOOLEAN fAttached = FALSE; Lock(&ptiList[i]->spklActive, pklCurrent); if (ptiList[i]->pClientInfo != ptiCurrent->pClientInfo && ptiList[i]->ppi != ptiCurrent->ppi) { /* * If the thread is in another process, attach * to that process so that we can access its ClientInfo. */ KeAttachProcess(&ptiList[i]->ppi->Process->Pcb); fAttached = TRUE; } try { ptiList[i]->pClientInfo->CodePage = pklCurrent->CodePage; ptiList[i]->pClientInfo->hKL = pklCurrent->hkl; } except (W32ExceptionHandler(FALSE, RIP_WARNING)) { dwFlags = RUN_INVALID; } if (fAttached) { KeDetachProcess(); } } else { dwFlags = RUN_ACTIVATE; } } /* * Skip all the *do nothing* cases in xxxImmUnloadLayout() * so as to minimize the # of TLBLOCK required. * (#99321) */ if (ptiList[i]->spwndDefaultIme != NULL && ptiList[i]->spklActive != NULL && (dwHklReplace != IFL_DEACTIVATEIME || IS_IME_KBDLAYOUT(ptiList[i]->spklActive->hkl)) && dwFlags != RUN_INVALID) { dwFlags |= RUN_UNLOAD; } if (dwFlags && dwFlags != RUN_INVALID) { ThreadLockPti(ptiCurrent, ptiList[i], &tlBlock.list[cThreads].tlpti); #if DBG tlBlock.list[cThreads].dwUnlockedCount = 0; #endif tlBlock.list[cThreads].pti = ptiList[i]; tlBlock.list[cThreads++].dwFlags = dwFlags; if (cThreads == THREADS_PER_TLBLOCK) { i++; // 1 more before exit the loop. break; } } } /* * If we can't service all the threads in this run, * call xxxImmActivateAndUnloadThreadsLayout again for a new TLBLOCK. */ if (i < (INT)nEntries) { ptiList += i; nEntries -= i; xxxImmActivateAndUnloadThreadsLayout(ptiList, nEntries, &tlBlock, pklCurrent, dwHklReplace); return; } /* * Finally, we can do the actual keyboard layout activation * starting from this run. Work on current TLBLOCK first. * We walk the list backwards so that the pti unlocks will * be done in the right order. */ i = cThreads - 1; for (ptlBlockPrev = &tlBlock; ptlBlockPrev != NULL; ptlBlockPrev = ptlBlockPrev->ptlBlockPrev) { for ( ; i >= 0; i--) { if ((ptlBlockPrev->list[i].dwFlags & RUN_ACTIVATE) && !(ptlBlockPrev->list[i].pti->TIF_flags & TIF_INCLEANUP)) { xxxImmActivateLayout(ptlBlockPrev->list[i].pti, pklCurrent); } // unlock the thread if the thread is only locked for the first run if ((ptlBlockPrev->list[i].dwFlags & RUN_FLAGS_MASK) == RUN_ACTIVATE) { ThreadUnlockPti(ptiCurrent, &ptlBlockPrev->list[i].tlpti); #if DBG ptlBlockPrev->list[i].dwUnlockedCount++; #endif } } i = THREADS_PER_TLBLOCK - 1; } i = cThreads - 1; for (ptlBlockPrev = &tlBlock; ptlBlockPrev != NULL; ptlBlockPrev = ptlBlockPrev->ptlBlockPrev) { for ( ; i >= 0; --i) { if (ptlBlockPrev->list[i].dwFlags & RUN_UNLOAD) { if (!(ptlBlockPrev->list[i].pti->TIF_flags & TIF_INCLEANUP)) { xxxImmUnloadLayout(ptlBlockPrev->list[i].pti, dwHklReplace); } else { RIPMSG1(RIP_WARNING, "xxxImmActivateAndUnloadThreadsLayout: thread %#p is cleaned up.", ptlBlockPrev->list[i].pti); } // unlock the thread UserAssert((ptlBlockPrev->list[i].dwFlags & RUN_FLAGS_MASK) != RUN_ACTIVATE); UserAssert(ptlBlockPrev->list[i].dwUnlockedCount == 0); ThreadUnlockPti(ptiCurrent, &ptlBlockPrev->list[i].tlpti); #if DBG ptlBlockPrev->list[i].dwUnlockedCount++; #endif } } i = THREADS_PER_TLBLOCK - 1; } #if DBG // Check if all the locked thread is properly unlocked i = cThreads - 1; for (ptlBlockPrev = &tlBlock; ptlBlockPrev; ptlBlockPrev = ptlBlockPrev->ptlBlockPrev) { for ( ; i >= 0; --i) { UserAssert(ptlBlockPrev->list[i].dwUnlockedCount == 1); } i = THREADS_PER_TLBLOCK - 1; } #endif return; }

VOID xxxImmActivateLayout (  IN PTHREADINFO  pti, IN PKL  pkl )

Definition at line 921 of file ntimm.c. References CheckLock, Lock, NULL, PtiCurrentShared, tagTHREADINFO::spwndDefaultIme, ThreadLockAlwaysWithPti, ThreadUnlock, VOID(), and xxxSendMessage(). Referenced by xxxImmActivateAndUnloadThreadsLayout(), xxxImmActivateThreadsLayout(), and xxxInternalActivateKeyboardLayout(). { TL tlpwndDefaultIme; PTHREADINFO ptiCurrent; CheckLock(pkl); /* * Do nothing if it's already been the current active layout. */ if (pti->spklActive == pkl) return; if (pti->spwndDefaultIme == NULL) { /* * Only activate kernel side keyboard layout if this pti * doesn't have the default IME window. */ Lock(&pti->spklActive, pkl); return; } ptiCurrent = PtiCurrentShared(); /* * Activate client side IME based keyboard layout. */ ThreadLockAlwaysWithPti(ptiCurrent, pti->spwndDefaultIme, &tlpwndDefaultIme); xxxSendMessage(pti->spwndDefaultIme, WM_IME_SYSTEM, (WPARAM)IMS_ACTIVATETHREADLAYOUT, (LPARAM)pkl->hkl); ThreadUnlock(&tlpwndDefaultIme); Lock(&pti->spklActive, pkl); return; }

BOOL xxxImmActivateThreadsLayout (  PTHREADINFO  pti, PTLBLOCK  ptlBlockPrev, PKL  pkl )

Definition at line 646 of file ntimm.c. References BOOL, CheckLock, _CLIENTINFO::CI_flags, CI_INPUTCONTEXT_REINIT, _CLIENTINFO::CodePage, tagKL::CodePage, FALSE, tagKL::hkl, _CLIENTINFO::hKL, tagTHREADINFO::hklPrev, INT, tagTLBLOCK::list, Lock, NULL, tagTHREADINFO::pClientInfo, tagTHREADINFO::ppi, PpiCurrent, PtiCurrentShared, tagTHREADINFO::ptiSibling, PTLBLOCK, tagTLBLOCK::ptlBlockPrev, tagTHREADINFO::spDefaultImc, tagTHREADINFO::spklActive, tagTHREADINFO::spwndDefaultIme, ThreadLockPti, THREADS_PER_TLBLOCK, ThreadUnlockPti, tagTHREADINFO::TIF_flags, TIF_INCLEANUP, TLBLOCK, TRUE, UINT, and xxxImmActivateLayout(). Referenced by xxxInternalActivateKeyboardLayout(). { TLBLOCK tlBlock; PTHREADINFO ptiCurrent, ptiT; UINT cThreads = 0; INT i; CheckLock(pkl); ptiCurrent = PtiCurrentShared(); /* * Build a list of threads that we need to update their active layouts. * We can't just walk the ptiT list while we're doing the work, because * for IME based keyboard layout, we will do callback to client side * and the ptiT could get deleted out while we leave the critical section. */ for (ptiT = pti; ptiT != NULL; ptiT = ptiT->ptiSibling) { /* * Skip all the *do nothing* cases in xxxImmActivateLayout * so as to minimize the # of TLBLOCK required. */ if (ptiT->spklActive == pkl || (ptiT->TIF_flags & TIF_INCLEANUP)) continue; UserAssert(ptiT->pClientInfo != NULL); UserAssert(ptiT->ppi == PpiCurrent()); // can't access pClientInfo of other process if (ptiT->spwndDefaultIme == NULL) { /* * Keyboard layout is being switched but there's no way to callback * the client side to activate&initialize input context now. * Let's do hkl switching only in the kernel side for this thread * but remember the input context needs to be re-initialized * when this GUI thread recreates the default IME window later. */ ptiT->hklPrev = ptiT->spklActive->hkl; Lock(&ptiT->spklActive, pkl); if (ptiT->spDefaultImc) { ptiT->pClientInfo->CI_flags |= CI_INPUTCONTEXT_REINIT; RIPMSG1(RIP_VERBOSE, "xxxImmActivateThreadsLayout: ptiT(%08p) will be re-initialized.", ptiT); } UserAssert((ptiT->TIF_flags & TIF_INCLEANUP) == 0); ptiT->pClientInfo->hKL = pkl->hkl; ptiT->pClientInfo->CodePage = pkl->CodePage; continue; } ThreadLockPti(ptiCurrent, ptiT, &tlBlock.list[cThreads].tlpti); tlBlock.list[cThreads++].pti = ptiT; if (cThreads == THREADS_PER_TLBLOCK) break; } /* * Return FALSE if all the threads already had the pkl active. */ if (ptlBlockPrev == NULL && ptiT == NULL && cThreads == 0) return FALSE; /* * If we can't service all the threads in this run, * call ImmActivateThreadsLayout() again for a new TLBLOCK. */ if (ptiT != NULL && ptiT->ptiSibling != NULL) { tlBlock.ptlBlockPrev = ptlBlockPrev; return xxxImmActivateThreadsLayout(ptiT->ptiSibling, &tlBlock, pkl); } /* * Finally, we can do the actual keyboard layout activation * starting from this run. Work on current TLBLOCK first. * We walk the list backwards so that the pti unlocks will * be done in the right order. */ tlBlock.ptlBlockPrev = ptlBlockPrev; ptlBlockPrev = &tlBlock; while (ptlBlockPrev != NULL) { for (i = cThreads - 1; i >= 0; --i) { if ((ptlBlockPrev->list[i].pti->TIF_flags & TIF_INCLEANUP) == 0) { ptiT = ptlBlockPrev->list[i].pti; UserAssert(ptiT); xxxImmActivateLayout(ptiT, pkl); if ((ptiT->TIF_flags & TIF_INCLEANUP) == 0) { ptiT->pClientInfo->hKL = pkl->hkl; ptiT->pClientInfo->CodePage = pkl->CodePage; } } ThreadUnlockPti(ptiCurrent, &ptlBlockPrev->list[i].tlpti); } ptlBlockPrev = ptlBlockPrev->ptlBlockPrev; cThreads = THREADS_PER_TLBLOCK; } return TRUE; }

PIMEINFOEX xxxImmLoadLayout (  IN HKL  hKL  )

Definition at line 1118 of file ntimm.c. References ClientImmLoadLayout(), IS_IME_KBDLAYOUT, NULL, PtiCurrent, ThreadLockPool, ThreadUnlockAndFreePool, and ThreadUnlockPool. Referenced by xxxLoadKeyboardLayoutEx(). { PIMEINFOEX piiex; PTHREADINFO ptiCurrent; TL tlPool; /* * No IMEINFOEX for non-IME based keyboard layout. */ if (!IS_IME_KBDLAYOUT(hKL)) return (PIMEINFOEX)NULL; piiex = (PIMEINFOEX)UserAllocPool(sizeof(IMEINFOEX), TAG_IME); if (piiex == NULL) { RIPMSG1(RIP_WARNING, "xxxImmLoadLayout: failed to create piiex for hkl = %lx", hKL); return (PIMEINFOEX)NULL; } ptiCurrent = PtiCurrent(); /* * Lock this allocations since we are going to the client side */ ThreadLockPool(ptiCurrent, piiex, &tlPool); if (!ClientImmLoadLayout(hKL, piiex)) { ThreadUnlockAndFreePool(ptiCurrent, &tlPool); return (PIMEINFOEX)NULL; } ThreadUnlockPool(ptiCurrent, &tlPool); return piiex; }

DWORD xxxImmProcessKey (  IN PQ  pq, IN PWND  pwnd, IN UINT  message, IN WPARAM  wParam, IN LPARAM  lParam )

Definition at line 1286 of file ntimm.c. References _PostMessage(), BOOL, CheckImeHotKey(), CheckLock, ClientImmProcessKey(), tagKL::dwFontSigs, _tagIMEHOTKEY::dwHotKeyID, DWORD, FALSE, GetAppImeCompatFlags(), GETPTI, gSystemFS, _tagIMEHOTKEYOBJ::hk, _tagIMEHOTKEY::hKL, tagKL::hkl, HtoP, tagIMEINFOEX::ImeInfo, IPHK_HOTKEY, IS_IME_ENABLED, NULL, tagKL::piiex, PtiCurrent, PtoH, and UINT. Referenced by xxxScanSysQueue(). { UINT uVKey; PKL pkl; DWORD dwHotKeyID; DWORD dwReturn = 0; PIMC pImc = NULL; BOOL fDBERoman = FALSE; PIMEHOTKEYOBJ pImeHotKeyObj; HKL hklTarget; CheckLock(pwnd); // // we're interested in only keyboard messages. // if ( message != WM_KEYDOWN && message != WM_SYSKEYDOWN && message != WM_KEYUP && message != WM_SYSKEYUP ) { return dwReturn; } // // Check if it's IME hotkey. This must be done before checking // the keyboard layout because IME hotkey handler should be // called even if current keyboard layout is non-IME layout. // pkl = GETPTI(pwnd)->spklActive; if ( pkl == NULL ) { return dwReturn; } uVKey = (UINT)wParam & 0xff; pImeHotKeyObj = CheckImeHotKey(pq, uVKey, lParam); if (pImeHotKeyObj) { dwHotKeyID = pImeHotKeyObj->hk.dwHotKeyID; hklTarget = pImeHotKeyObj->hk.hKL; } else { dwHotKeyID = IME_INVALID_HOTKEY; hklTarget = (HKL)NULL; } // // Handle Direct KL switching here. // if (dwHotKeyID >= IME_HOTKEY_DSWITCH_FIRST && dwHotKeyID <= IME_HOTKEY_DSWITCH_LAST) { UserAssert(hklTarget != NULL); if (pkl->hkl != hklTarget) { // // Post the message only if the new Keyboard Layout is different from // the current Keyboard Layout. // _PostMessage(pwnd, WM_INPUTLANGCHANGEREQUEST, (pkl->dwFontSigs & gSystemFS) ? INPUTLANGCHANGE_SYSCHARSET : 0, (LPARAM)hklTarget); } if (GetAppImeCompatFlags(GETPTI(pwnd)) & IMECOMPAT_HYDRACLIENT) { return 0; } return IPHK_HOTKEY; } if (!IS_IME_ENABLED()) { // // Since IMM is disabled, no need to process further. // Just bail out. // return 0; } if ( dwHotKeyID != IME_INVALID_HOTKEY ) { // // if it's a valid hotkey, go straight and call back // the IME in the client side. // goto ProcessKeyCallClient; } // // if it's not a hotkey, we may want to check something // before calling back. // if ( pkl->piiex == NULL ) { return dwReturn; } // // Check input context // pImc = HtoP(pwnd->hImc); if ( pImc == NULL ) { return dwReturn; } #ifdef LATER // // If there is an easy way to check the input context open/close status // from the kernel side, IME_PROP_NO_KEYS_ON_CLOSE checking should be // done here in kernel side. [ 3/10/96 takaok] // // // Check IME_PROP_NO_KEYS_ON_CLOSE bit // // if the current imc is not open and IME doesn't need // keys when being closed, we don't pass any keyboard // input to ime except hotkey and keys that change // the keyboard status. // if ( (piix->ImeInfo.fdwProperty & IME_PROP_NO_KEYS_ON_CLOSE) && (!pimc->fdwState & IMC_OPEN) && uVKey != VK_SHIFT && // 0x10 uVKey != VK_CONTROL && // 0x11 uVKey != VK_CAPITAL && // 0x14 uVKey != VK_KANA && // 0x15 uVKey != VK_NUMLOCK && // 0x90 uVKey != VK_SCROLL ) // 0x91 { // Check if Korea Hanja conversion mode if( !(pimc->fdwConvMode & IME_CMODE_HANJACONVERT) ) { return dwReturn; } } #endif // // if the IME doesn't need key up messages, we don't call ime. // if ( lParam & 0x80000000 && // set if key up, clear if key down pkl->piiex->ImeInfo.fdwProperty & IME_PROP_IGNORE_UPKEYS ) { return dwReturn; } // // we don't want to handle sys keys since many functions for // acceelerators won't work without this // fDBERoman = (BOOL)( (uVKey == VK_DBE_ROMAN) || (uVKey == VK_DBE_NOROMAN) || (uVKey == VK_DBE_HIRAGANA) || (uVKey == VK_DBE_KATAKANA) || (uVKey == VK_DBE_CODEINPUT) || (uVKey == VK_DBE_NOCODEINPUT) || (uVKey == VK_DBE_IME_WORDREGISTER) || (uVKey == VK_DBE_IME_DIALOG) ); if (message == WM_SYSKEYDOWN || message == WM_SYSKEYUP ) { // // IME may be waiting for VK_MENU, VK_F10 or VK_DBE_xxx // if ( uVKey != VK_MENU && uVKey != VK_F10 && !fDBERoman ) { return dwReturn; } } // // check if the IME doesn't need ALT key // if ( !(pkl->piiex->ImeInfo.fdwProperty & IME_PROP_NEED_ALTKEY) ) { // // IME doesn't need ALT key // // we don't pass the ALT and ALT+xxx except VK_DBE_xxx keys. // if ( ! fDBERoman && (uVKey == VK_MENU || (lParam & 0x20000000)) // KF_ALTDOWN ) { return dwReturn; } } // // finaly call back the client // ProcessKeyCallClient: if ((uVKey & 0xff) == VK_PACKET) { // // need to retrieve UNICODE character from pti // uVKey = MAKELONG(wParam, PtiCurrent()->wchInjected); } dwReturn = ClientImmProcessKey( PtoH(pwnd), pkl->hkl, uVKey, lParam, dwHotKeyID); // // Hydra server wants to see the IME hotkeys. // if (GetAppImeCompatFlags(GETPTI(pwnd)) & IMECOMPAT_HYDRACLIENT) { dwReturn &= ~IPHK_HOTKEY; } return dwReturn; }

VOID xxxImmUnloadLayout (  IN PTHREADINFO  pti, IN DWORD  dwFlag )

Definition at line 1070 of file ntimm.c. References CMSHUNGAPPTIMEOUT, IFL_DEACTIVATEIME, IS_IME_KBDLAYOUT, NULL, PtiCurrentShared, tagTHREADINFO::spwndDefaultIme, ThreadLockAlwaysWithPti, ThreadUnlock, VOID(), and xxxSendMessageTimeout(). Referenced by xxxImmActivateAndUnloadThreadsLayout(), and xxxImmUnloadThreadsLayout(). { TL tlpwndDefaultIme; PTHREADINFO ptiCurrent; ULONG_PTR dwResult; LRESULT r; /* * Do nothing if the thread does not have default IME window. */ if (pti->spwndDefaultIme == NULL) return; if (pti->spklActive == NULL) return; if (dwFlag == IFL_DEACTIVATEIME && !IS_IME_KBDLAYOUT(pti->spklActive->hkl)) return; ptiCurrent = PtiCurrentShared(); ThreadLockAlwaysWithPti(ptiCurrent, pti->spwndDefaultIme, &tlpwndDefaultIme); r = xxxSendMessageTimeout(pti->spwndDefaultIme, WM_IME_SYSTEM, IMS_UNLOADTHREADLAYOUT, (LONG)dwFlag, SMTO_NOTIMEOUTIFNOTHUNG, CMSHUNGAPPTIMEOUT, &dwResult); if (!r) { RIPMSG1(RIP_WARNING, "Timeout in xxxImmUnloadLayout: perhaps this thread (0x%x) is not pumping messages.", pti->pEThread->Cid.UniqueThread); } ThreadUnlock(&tlpwndDefaultIme); return; }

VOID xxxImmUnloadThreadsLayout (  IN PTHREADINFO *  ptiList, IN UINT  nEntries, IN PTLBLOCK  ptlBlockPrev, IN DWORD  dwFlag )

Definition at line 961 of file ntimm.c. References FALSE, IFL_DEACTIVATEIME, IFL_UNLOADIME, INT, IS_IME_KBDLAYOUT, tagTLBLOCK::list, NULL, PtiCurrentShared, tagTLBLOCK::ptlBlockPrev, ThreadLockPti, THREADS_PER_TLBLOCK, ThreadUnlockPti, TIF_INCLEANUP, TRUE, VOID(), and xxxImmUnloadLayout(). Referenced by xxxFreeImeKeyboardLayouts(). { TLBLOCK tlBlock; PTHREADINFO ptiCurrent; INT i, cThreads; BOOLEAN fPerformUnlock; ptiCurrent = PtiCurrentShared(); tlBlock.ptlBlockPrev = ptlBlockPrev; /* * Build a list of threads that we need to unload their IME DLL(s). * We can't just walk the ptiList while we're doing the work, because * for IME based keyboard layout, we will do callback to client side * and the pti could get deleted out while we leave the critical section. */ for (i = 0, cThreads = 0; i < (INT)nEntries; i++) { /* * Skip all the *do nothing* cases in xxxImmUnloadLayout() * so as to minimize the # of TLBLOCK required. */ if ((ptiList[i]->TIF_flags & TIF_INCLEANUP) || ptiList[i]->spwndDefaultIme == NULL) continue; if (ptiList[i]->spklActive == NULL) continue; if (dwFlag == IFL_DEACTIVATEIME && !IS_IME_KBDLAYOUT(ptiList[i]->spklActive->hkl)) // #99321 continue; #if DBG tlBlock.list[cThreads].dwUnlockedCount = 0; #endif ThreadLockPti(ptiCurrent, ptiList[i], &tlBlock.list[cThreads].tlpti); tlBlock.list[cThreads++].pti = ptiList[i]; if (cThreads == THREADS_PER_TLBLOCK) { i++; // 1 more before exit the loop. break; } } if (i < (INT)nEntries) { ptiList += i; nEntries -= i; xxxImmUnloadThreadsLayout(ptiList, nEntries, &tlBlock, dwFlag); return; } UserAssert(dwFlag == IFL_UNLOADIME || dwFlag == IFL_DEACTIVATEIME); if (dwFlag == IFL_UNLOADIME) { dwFlag = IFL_DEACTIVATEIME; fPerformUnlock = FALSE; } else { fPerformUnlock = TRUE; } RepeatForUnload: /* * Finally, we can unload the IME based keyboard layout * starting from this run. Work on current TLBLOCK first. * We walk the list backwards so that the pti unlocks will * be done in the right order. */ i = cThreads - 1; for (ptlBlockPrev = &tlBlock; ptlBlockPrev; ptlBlockPrev = ptlBlockPrev->ptlBlockPrev) { for ( ; i >= 0; --i) { if (!(ptlBlockPrev->list[i].pti->TIF_flags & TIF_INCLEANUP)) { xxxImmUnloadLayout(ptlBlockPrev->list[i].pti, dwFlag); } else { RIPMSG2(RIP_WARNING, "Thread %#p is cleaned during the loop for %x!", ptlBlockPrev->list[i].pti, dwFlag); } if (fPerformUnlock) { #if DBG ptlBlockPrev->list[i].dwUnlockedCount++; #endif ThreadUnlockPti(ptiCurrent, &ptlBlockPrev->list[i].tlpti); } } i = THREADS_PER_TLBLOCK - 1; } if (!fPerformUnlock) { fPerformUnlock = TRUE; dwFlag = IFL_UNLOADIME; goto RepeatForUnload; } #if DBG // Check if all the locked thread is properly unlocked i = cThreads - 1; for (ptlBlockPrev = &tlBlock; ptlBlockPrev; ptlBlockPrev = ptlBlockPrev->ptlBlockPrev) { for ( ; i >= 0; --i) { UserAssert(ptlBlockPrev->list[i].dwUnlockedCount == 1); } i = THREADS_PER_TLBLOCK - 1; } #endif return; }

VOID xxxNotifyImeShowStatus (  PWND  pwndIme  )

Definition at line 2544 of file ntimm.c. References BOOL, FALSE, tagIMEUI::fShowStatus, GETPTI, gfIMEShowStatus, tagIMEUI::hwndIMC, IS_IME_ENABLED, KeAttachProcess(), KeDetachProcess(), NULL, ProbeAndReadStructure, PtiCurrent, RevalidateHwnd, TestWF, TRUE, VOID(), WFINDESTROY, xxxCheckImeShowStatus(), and xxxSendOpenStatusNotify(). Referenced by xxxBroadcastImeShowStatusChange(), and xxxSetIMEShowStatus(). { PIMEUI pimeui; BOOL fShow; PWND pwnd; PTHREADINFO ptiIme, ptiCurrent; BOOL fSendOpenStatusNotify = FALSE; if (!IS_IME_ENABLED() || TestWF(pwndIme, WFINDESTROY)) { RIPMSG0(RIP_WARNING, "IME is not enabled or in destroy."); return; } ptiCurrent = PtiCurrent(); ptiIme = GETPTI(pwndIme); if (ptiIme != ptiCurrent) { RIPMSG1(RIP_VERBOSE, "Attaching pti=%#p", ptiIme); KeAttachProcess(&GETPTI(pwndIme)->ppi->Process->Pcb); } try { pimeui = ((PIMEWND)pwndIme)->pimeui; fShow = gfIMEShowStatus && ProbeAndReadStructure(pimeui, IMEUI).fCtrlShowStatus; pwnd = RevalidateHwnd(pimeui->hwndIMC); if (pwnd != NULL || (pwnd = GETPTI(pwndIme)->pq->spwndFocus) != NULL) { RIPMSG0(RIP_VERBOSE, "Setting new show status."); fSendOpenStatusNotify = TRUE; pimeui->fShowStatus = fShow; } } except (W32ExceptionHandler(FALSE, RIP_WARNING)) { if (ptiIme != ptiCurrent) { KeDetachProcess(); } return; } if (ptiIme != ptiCurrent) { KeDetachProcess(); } if (fSendOpenStatusNotify) { RIPMSG1(RIP_VERBOSE, "Sending OpenStatus fShow=%d", fShow); xxxSendOpenStatusNotify(ptiIme, pimeui, pwnd, fShow); } // Check the show status of all IME windows in the system. if (!TestWF(pwndIme, WFINDESTROY)) { xxxCheckImeShowStatus(pwndIme, NULL); } }

VOID xxxNotifyIMEStatus (  IN PWND  pwnd, IN DWORD  dwOpen, IN DWORD  dwConversion )

Definition at line 2295 of file ntimm.c. References CheckLock, gdwIMEConversionStatus, gdwIMEOpenStatus, GETPTI, gHimcFocus, gptiForeground, tagKL::hkl, HWq, IsHooked, NlsKbdSendIMENotification(), NULL, tagTHREADINFO::pq, SetConvMode(), tagTHREADINFO::spklActive, VOID(), WHF_SHELL, and xxxCallHook(). Referenced by NtUserNotifyIMEStatus(). { PTHREADINFO pti; CheckLock(pwnd); if ( (pti = GETPTI(pwnd)) != NULL && gptiForeground != NULL ) { if ( pti == gptiForeground || pti->pq == gptiForeground->pq ) { if ( gHimcFocus != pwnd->hImc || gdwIMEOpenStatus != dwOpen || gdwIMEConversionStatus != dwConversion ) { // // save the new status // gHimcFocus = pwnd->hImc; if ( gHimcFocus != (HIMC)NULL ) { RIPMSG2(RIP_VERBOSE, "xxxNotifyIMEStatus: newOpen=%x newConv=%x", dwOpen, dwConversion); gdwIMEOpenStatus = dwOpen; gdwIMEConversionStatus = dwConversion; // // set keyboard states that are related to IME conversion status // SetConvMode(pti, dwOpen ? dwConversion : 0); } // // notify shell the IME status change // // Implementation note: [takaok 9/5/96] // // Using HSHELL_LANGUAGE is not the best way to inform shell // IME status change because we didn't change the keyboard layout. // ( The spec says HSHELL_LANGUAGE is for keyboard layout change. // Also passing window handle as WPARAM is not documented ) // // This is same as what Win95 does. I won't change this for now // because in the future shell will be developed by a different // group in MS. // // Currently only Korean Windows is interested in getting // the conversion status change. // if (IsHooked(pti, WHF_SHELL)) { HKL hkl = NULL; if (pti->spklActive != NULL) { hkl = pti->spklActive->hkl; } xxxCallHook(HSHELL_LANGUAGE, (WPARAM)HWq(pwnd), (LPARAM)hkl, WH_SHELL); } // // notify keyboard driver // NlsKbdSendIMENotification(dwOpen,dwConversion); } } } }

LRESULT xxxSendMessageToUI (  PTHREADINFO  ptiIme, PIMEUI  pimeui, UINT  message, WPARAM  wParam, LPARAM  lParam )

Definition at line 2461 of file ntimm.c. References BOOL, CheckCritIn, FALSE, KeAttachProcess(), KeDetachProcess(), L, tagIMEUI::nCntInIMEProc, NULL, tagTHREADINFO::ppi, ProbeAndReadStructure, ProbeAndReadUlong, PtiCurrent, RevalidateHwnd, ThreadLockAlways, ThreadUnlock, TRUE, and xxxSendMessage(). Referenced by xxxSendOpenStatusNotify(). { PWND pwndUI; LRESULT lRet = 0L; TL tl; BOOL fAttached = FALSE; CheckCritIn(); if (ptiIme != PtiCurrent()) { fAttached = TRUE; KeAttachProcess(&ptiIme->ppi->Process->Pcb); } try { pwndUI = RevalidateHwnd(ProbeAndReadStructure(pimeui, IMEUI).hwndUI); } except (W32ExceptionHandler(FALSE, RIP_WARNING)) { pwndUI = NULL; } if (pwndUI != NULL){ try { ProbeAndReadUlong((PULONG)&pimeui->nCntInIMEProc); InterlockedIncrement(&pimeui->nCntInIMEProc); // Mark to avoid recursion. } except (W32ExceptionHandler(FALSE, RIP_WARNING)) { goto skip_it; } if (fAttached) { KeDetachProcess(); } ThreadLockAlways(pwndUI, &tl); RIPMSG3(RIP_VERBOSE, "Sending message UI pwnd=%#p, msg:%x to wParam=%#p", pwndUI, message, wParam); lRet = xxxSendMessage(pwndUI, message, wParam, lParam); ThreadUnlock(&tl); if (fAttached) { KeAttachProcess(&ptiIme->ppi->Process->Pcb); } try { InterlockedDecrement(&pimeui->nCntInIMEProc); // Mark to avoid recursion. } except (W32ExceptionHandler(FALSE, RIP_WARNING)) { } } skip_it: if (fAttached) { KeDetachProcess(); } return lRet; }

VOID xxxSendOpenStatusNotify (  PTHREADINFO  ptiIme, PIMEUI  pimeui, PWND  pwndApp, BOOL  fOpen )

Definition at line 2518 of file ntimm.c. References GETPTI, tagWND::hImc, L, NULL, ThreadLockAlways, ThreadUnlock, VER40, VOID(), xxxSendMessage(), and xxxSendMessageToUI(). Referenced by xxxNotifyImeShowStatus(). { WPARAM wParam = fOpen ? IMN_OPENSTATUSWINDOW : IMN_CLOSESTATUSWINDOW; UserAssert(GETPTI(pwndApp)); if (GETPTI(pwndApp)->dwExpWinVer >= VER40 && pwndApp->hImc != NULL) { TL tl; ThreadLockAlways(pwndApp, &tl); RIPMSG2(RIP_VERBOSE, "Sending %s to pwnd=%#p", fOpen ? "IMN_OPENSTATUSWINDOW" : "IMN_CLOSESTATUSWINDOW", pwndApp); xxxSendMessage(pwndApp, WM_IME_NOTIFY, wParam, 0L); ThreadUnlock(&tl); } else { xxxSendMessageToUI(ptiIme, pimeui, WM_IME_NOTIFY, wParam, 0L); } return; }

BOOL xxxSetIMEShowStatus (  IN BOOL  fShow  )

Definition at line 2606 of file ntimm.c. References BOOL, CheckCritIn, CreateProfileUserName(), FALSE, FreeProfileUserName(), GETPTI, gfIMEShowStatus, gpqForeground, IMESHOWSTATUS_NOTINITIALIZED, IS_IME_ENABLED, NULL, PMAP_INPUTMETHOD, tagTHREADINFO::spwndDefaultIme, tagQ::spwndFocus, ThreadLockAlways, ThreadUnlock, tagTHREADINFO::TIF_flags, TIF_INCLEANUP, TRUE, UpdateWinIniInt(), and xxxNotifyImeShowStatus(). Referenced by xxxSystemParametersInfo(). { CheckCritIn(); UserAssert(fShow == FALSE || fShow == TRUE); if (gfIMEShowStatus == fShow) { return TRUE; } if (gfIMEShowStatus == IMESHOWSTATUS_NOTINITIALIZED) { /* * Called for the first time after logon. * No need to write the value to the registry. */ gfIMEShowStatus = fShow; } else { /* * We need to save the new fShow status to the registry. */ TL tlName; PUNICODE_STRING pProfileUserName; BOOL fOK = FALSE; pProfileUserName = CreateProfileUserName(&tlName); if (pProfileUserName) { UserAssert(pProfileUserName != NULL); fOK = UpdateWinIniInt(pProfileUserName, PMAP_INPUTMETHOD, STR_SHOWIMESTATUS, fShow); FreeProfileUserName(pProfileUserName, &tlName); } if (!fOK) { return FALSE; } gfIMEShowStatus = fShow; } /* * If IME is not enabled, further processing is not needed */ if (!IS_IME_ENABLED()) { return TRUE; } /* * Let the current active IME window know the change. */ if (gpqForeground && gpqForeground->spwndFocus) { PTHREADINFO ptiFocus = GETPTI(gpqForeground->spwndFocus); TL tl; UserAssert(ptiFocus); if (ptiFocus->spwndDefaultIme && !(ptiFocus->TIF_flags & TIF_INCLEANUP)) { ThreadLockAlways(ptiFocus->spwndDefaultIme, &tl); xxxNotifyImeShowStatus(ptiFocus->spwndDefaultIme); ThreadUnlock(&tl); } } return TRUE; }

---

Variable Documentation

CONST WCHAR wszDefaultIme[] = L"Default IME" [static]

Definition at line 16 of file ntimm.c. Referenced by xxxCreateDefaultImeWindow().

---