10 Sep
2021
10 Sep
'21
2:39 p.m.
https://git.reactos.org/?p=reactos.git;a=commitdiff;h=b4557a60a98b4d188c058…
commit b4557a60a98b4d188c058388395177b36994572e
Author: Katayama Hirofumi MZ <katayama.hirofumi.mz(a)gmail.com>
AuthorDate: Fri Sep 10 23:39:15 2021 +0900
Commit: GitHub <noreply(a)github.com>
CommitDate: Fri Sep 10 23:39:15 2021 +0900
[IMM32] Restructure! (Retry) (#3952)
The imm.c file became big and bloated, so we split the source file. CORE-11700
- Split the IMM32 code and do formatting.
---
dll/win32/imm32/CMakeLists.txt | 15 +-
dll/win32/imm32/candidate.c | 406 ++++
dll/win32/imm32/guideline.c | 198 ++
dll/win32/imm32/ime.c | 1201 +++++++++++
dll/win32/imm32/imm.c | 4507 +++++-----------------------------------
dll/win32/imm32/keymsg.c | 688 ++++++
dll/win32/imm32/nt3.c | 205 ++
dll/win32/imm32/precomp.h | 103 +
dll/win32/imm32/regword.c | 520 +++++
dll/win32/imm32/utils.c | 276 +++
10 files changed, 4103 insertions(+), 4016 deletions(-)
diff --git a/dll/win32/imm32/CMakeLists.txt b/dll/win32/imm32/CMakeLists.txt
index 9ccdcd26f20..bb50a71ab63 100644
--- a/dll/win32/imm32/CMakeLists.txt
+++ b/dll/win32/imm32/CMakeLists.txt
@@ -1,14 +1,21 @@
-include_directories(${REACTOS_SOURCE_DIR}/sdk/include/reactos/wine)
-add_definitions(-D__WINESRC__)
+include_directories(
+ ${REACTOS_SOURCE_DIR}/sdk/include/reactos/wine
+ ${REACTOS_SOURCE_DIR}/win32ss/include)
-remove_definitions(-D_WIN32_WINNT=0x502)
-add_definitions(-D_WIN32_WINNT=0x600)
+add_definitions(-D__WINESRC__)
spec2def(imm32.dll imm32.spec ADD_IMPORTLIB)
list(APPEND SOURCE
+ candidate.c
+ guideline.c
+ ime.c
imm.c
+ keymsg.c
+ nt3.c
+ regword.c
+ utils.c
${CMAKE_CURRENT_BINARY_DIR}/imm32_stubs.c
${CMAKE_CURRENT_BINARY_DIR}/imm32.def)
diff --git a/dll/win32/imm32/candidate.c b/dll/win32/imm32/candidate.c
new file mode 100644
index 00000000000..43f4e8d03c1
--- /dev/null
+++ b/dll/win32/imm32/candidate.c
@@ -0,0 +1,406 @@
+/*
+ * PROJECT: ReactOS IMM32
+ * LICENSE: LGPL-2.1-or-later (https://spdx.org/licenses/LGPL-2.1-or-later)
+ * PURPOSE: Implementing IMM32 candidate lists
+ * COPYRIGHT: Copyright 2020-2021 Katayama Hirofumi MZ
<katayama.hirofumi.mz(a)gmail.com>
+ */
+
+#include "precomp.h"
+
+WINE_DEFAULT_DEBUG_CHANNEL(imm);
+
+DWORD APIENTRY
+CandidateListWideToAnsi(const CANDIDATELIST *pWideCL, LPCANDIDATELIST pAnsiCL, DWORD
dwBufLen,
+ UINT uCodePage)
+{
+ BOOL bUsedDefault;
+ DWORD dwSize, dwIndex, cbGot, cbLeft;
+ const BYTE *pbWide;
+ LPBYTE pbAnsi;
+ LPDWORD pibOffsets;
+
+ /* calculate total ansi size */
+ if (pWideCL->dwCount > 0)
+ {
+ dwSize = sizeof(CANDIDATELIST) + ((pWideCL->dwCount - 1) * sizeof(DWORD));
+ for (dwIndex = 0; dwIndex < pWideCL->dwCount; ++dwIndex)
+ {
+ pbWide = (const BYTE *)pWideCL + pWideCL->dwOffset[dwIndex];
+ cbGot = WideCharToMultiByte(uCodePage, 0, (LPCWSTR)pbWide, -1, NULL, 0,
+ NULL, &bUsedDefault);
+ dwSize += cbGot;
+ }
+ }
+ else
+ {
+ dwSize = sizeof(CANDIDATELIST);
+ }
+
+ dwSize = ROUNDUP4(dwSize);
+ if (dwBufLen == 0)
+ return dwSize;
+ if (dwBufLen < dwSize)
+ return 0;
+
+ /* store to ansi */
+ pAnsiCL->dwSize = dwBufLen;
+ pAnsiCL->dwStyle = pWideCL->dwStyle;
+ pAnsiCL->dwCount = pWideCL->dwCount;
+ pAnsiCL->dwSelection = pWideCL->dwSelection;
+ pAnsiCL->dwPageStart = pWideCL->dwPageStart;
+ pAnsiCL->dwPageSize = pWideCL->dwPageSize;
+
+ pibOffsets = pAnsiCL->dwOffset;
+ if (pWideCL->dwCount > 0)
+ {
+ pibOffsets[0] = sizeof(CANDIDATELIST) + ((pWideCL->dwCount - 1) *
sizeof(DWORD));
+ cbLeft = dwBufLen - pibOffsets[0];
+
+ for (dwIndex = 0; dwIndex < pWideCL->dwCount; ++dwIndex)
+ {
+ pbWide = (const BYTE *)pWideCL + pWideCL->dwOffset[dwIndex];
+ pbAnsi = (LPBYTE)pAnsiCL + pibOffsets[dwIndex];
+
+ /* convert to ansi */
+ cbGot = WideCharToMultiByte(uCodePage, 0, (LPCWSTR)pbWide, -1,
+ (LPSTR)pbAnsi, cbLeft, NULL, &bUsedDefault);
+ cbLeft -= cbGot;
+
+ if (dwIndex < pWideCL->dwCount - 1)
+ pibOffsets[dwIndex + 1] = pibOffsets[dwIndex] + cbGot;
+ }
+ }
+ else
+ {
+ pibOffsets[0] = sizeof(CANDIDATELIST);
+ }
+
+ return dwBufLen;
+}
+
+DWORD APIENTRY
+CandidateListAnsiToWide(const CANDIDATELIST *pAnsiCL, LPCANDIDATELIST pWideCL, DWORD
dwBufLen,
+ UINT uCodePage)
+{
+ DWORD dwSize, dwIndex, cchGot, cbGot, cbLeft;
+ const BYTE *pbAnsi;
+ LPBYTE pbWide;
+ LPDWORD pibOffsets;
+
+ /* calculate total wide size */
+ if (pAnsiCL->dwCount > 0)
+ {
+ dwSize = sizeof(CANDIDATELIST) + ((pAnsiCL->dwCount - 1) * sizeof(DWORD));
+ for (dwIndex = 0; dwIndex < pAnsiCL->dwCount; ++dwIndex)
+ {
+ pbAnsi = (const BYTE *)pAnsiCL + pAnsiCL->dwOffset[dwIndex];
+ cchGot = MultiByteToWideChar(uCodePage, MB_PRECOMPOSED, (LPCSTR)pbAnsi, -1,
NULL, 0);
+ dwSize += cchGot * sizeof(WCHAR);
+ }
+ }
+ else
+ {
+ dwSize = sizeof(CANDIDATELIST);
+ }
+
+ dwSize = ROUNDUP4(dwSize);
+ if (dwBufLen == 0)
+ return dwSize;
+ if (dwBufLen < dwSize)
+ return 0;
+
+ /* store to wide */
+ pWideCL->dwSize = dwBufLen;
+ pWideCL->dwStyle = pAnsiCL->dwStyle;
+ pWideCL->dwCount = pAnsiCL->dwCount;
+ pWideCL->dwSelection = pAnsiCL->dwSelection;
+ pWideCL->dwPageStart = pAnsiCL->dwPageStart;
+ pWideCL->dwPageSize = pAnsiCL->dwPageSize;
+
+ pibOffsets = pWideCL->dwOffset;
+ if (pAnsiCL->dwCount > 0)
+ {
+ pibOffsets[0] = sizeof(CANDIDATELIST) + ((pWideCL->dwCount - 1) *
sizeof(DWORD));
+ cbLeft = dwBufLen - pibOffsets[0];
+
+ for (dwIndex = 0; dwIndex < pAnsiCL->dwCount; ++dwIndex)
+ {
+ pbAnsi = (const BYTE *)pAnsiCL + pAnsiCL->dwOffset[dwIndex];
+ pbWide = (LPBYTE)pWideCL + pibOffsets[dwIndex];
+
+ /* convert to wide */
+ cchGot = MultiByteToWideChar(uCodePage, MB_PRECOMPOSED, (LPCSTR)pbAnsi, -1,
+ (LPWSTR)pbWide, cbLeft / sizeof(WCHAR));
+ cbGot = cchGot * sizeof(WCHAR);
+ cbLeft -= cbGot;
+
+ if (dwIndex + 1 < pAnsiCL->dwCount)
+ pibOffsets[dwIndex + 1] = pibOffsets[dwIndex] + cbGot;
+ }
+ }
+ else
+ {
+ pibOffsets[0] = sizeof(CANDIDATELIST);
+ }
+
+ return dwBufLen;
+}
+
+static DWORD APIENTRY
+ImmGetCandidateListAW(HIMC hIMC, DWORD dwIndex, LPCANDIDATELIST lpCandList, DWORD
dwBufLen,
+ BOOL bAnsi)
+{
+ DWORD ret = 0;
+ LPINPUTCONTEXT pIC;
+ PCLIENTIMC pClientImc;
+ LPCANDIDATEINFO pCI;
+ LPCANDIDATELIST pCL;
+ DWORD dwSize;
+
+ pClientImc = ImmLockClientImc(hIMC);
+ if (!pClientImc)
+ return 0;
+
+ pIC = ImmLockIMC(hIMC);
+ if (pIC == NULL)
+ {
+ ImmUnlockClientImc(pClientImc);
+ return 0;
+ }
+
+ pCI = ImmLockIMCC(pIC->hCandInfo);
+ if (pCI == NULL)
+ {
+ ImmUnlockIMC(hIMC);
+ ImmUnlockClientImc(pClientImc);
+ return 0;
+ }
+
+ if (pCI->dwSize < sizeof(CANDIDATEINFO) || pCI->dwCount <= dwIndex)
+ goto Quit;
+
+ /* get required size */
+ pCL = (LPCANDIDATELIST)((LPBYTE)pCI + pCI->dwOffset[dwIndex]);
+ if (bAnsi)
+ {
+ if (pClientImc->dwFlags & CLIENTIMC_WIDE)
+ dwSize = CandidateListAnsiToWide(pCL, NULL, 0, CP_ACP);
+ else
+ dwSize = pCL->dwSize;
+ }
+ else
+ {
+ if (pClientImc->dwFlags & CLIENTIMC_WIDE)
+ dwSize = pCL->dwSize;
+ else
+ dwSize = CandidateListWideToAnsi(pCL, NULL, 0, CP_ACP);
+ }
+
+ if (dwBufLen != 0 && dwSize != 0)
+ {
+ if (lpCandList == NULL || dwBufLen < dwSize)
+ goto Quit;
+
+ /* store */
+ if (bAnsi)
+ {
+ if (pClientImc->dwFlags & CLIENTIMC_WIDE)
+ CandidateListAnsiToWide(pCL, lpCandList, dwSize, CP_ACP);
+ else
+ RtlCopyMemory(lpCandList, pCL, dwSize);
+ }
+ else
+ {
+ if (pClientImc->dwFlags & CLIENTIMC_WIDE)
+ RtlCopyMemory(lpCandList, pCL, dwSize);
+ else
+ CandidateListWideToAnsi(pCL, lpCandList, dwSize, CP_ACP);
+ }
+ }
+
+ ret = dwSize;
+
+Quit:
+ ImmUnlockIMCC(pIC->hCandInfo);
+ ImmUnlockIMC(hIMC);
+ ImmUnlockClientImc(pClientImc);
+ return ret;
+}
+
+DWORD APIENTRY
+ImmGetCandidateListCountAW(HIMC hIMC, LPDWORD lpdwListCount, BOOL bAnsi)
+{
+ DWORD ret = 0, cbGot, dwIndex;
+ PCLIENTIMC pClientImc;
+ LPINPUTCONTEXT pIC;
+ const CANDIDATEINFO *pCI;
+ const BYTE *pb;
+ const CANDIDATELIST *pCL;
+ const DWORD *pdwOffsets;
+
+ if (lpdwListCount == NULL)
+ return 0;
+
+ *lpdwListCount = 0;
+
+ pClientImc = ImmLockClientImc(hIMC);
+ if (pClientImc == NULL)
+ return 0;
+
+ pIC = ImmLockIMC(hIMC);
+ if (pIC == NULL)
+ {
+ ImmUnlockClientImc(pClientImc);
+ return 0;
+ }
+
+ pCI = ImmLockIMCC(pIC->hCandInfo);
+ if (pCI == NULL)
+ {
+ ImmUnlockIMC(hIMC);
+ ImmUnlockClientImc(pClientImc);
+ return 0;
+ }
+
+ if (pCI->dwSize < sizeof(CANDIDATEINFO))
+ goto Quit;
+
+ *lpdwListCount = pCI->dwCount; /* the number of candidate lists */
+
+ /* calculate total size of candidate lists */
+ if (bAnsi)
+ {
+ if (pClientImc->dwFlags & CLIENTIMC_WIDE)
+ {
+ ret = ROUNDUP4(pCI->dwPrivateSize);
+ pdwOffsets = pCI->dwOffset;
+ for (dwIndex = 0; dwIndex < pCI->dwCount; ++dwIndex)
+ {
+ pb = (const BYTE *)pCI + pdwOffsets[dwIndex];
+ pCL = (const CANDIDATELIST *)pb;
+ cbGot = CandidateListWideToAnsi(pCL, NULL, 0, CP_ACP);
+ ret += cbGot;
+ }
+ }
+ else
+ {
+ ret = pCI->dwSize;
+ }
+ }
+ else
+ {
+ if (pClientImc->dwFlags & CLIENTIMC_WIDE)
+ {
+ ret = pCI->dwSize;
+ }
+ else
+ {
+ ret = ROUNDUP4(pCI->dwPrivateSize);
+ pdwOffsets = pCI->dwOffset;
+ for (dwIndex = 0; dwIndex < pCI->dwCount; ++dwIndex)
+ {
+ pb = (const BYTE *)pCI + pdwOffsets[dwIndex];
+ pCL = (const CANDIDATELIST *)pb;
+ cbGot = CandidateListAnsiToWide(pCL, NULL, 0, CP_ACP);
+ ret += cbGot;
+ }
+ }
+ }
+
+Quit:
+ ImmUnlockIMCC(pIC->hCandInfo);
+ ImmUnlockIMC(hIMC);
+ ImmUnlockClientImc(pClientImc);
+ return ret;
+}
+
+/***********************************************************************
+ * ImmGetCandidateListA (IMM32.@)
+ */
+DWORD WINAPI
+ImmGetCandidateListA(HIMC hIMC, DWORD dwIndex, LPCANDIDATELIST lpCandList, DWORD
dwBufLen)
+{
+ return ImmGetCandidateListAW(hIMC, dwIndex, lpCandList, dwBufLen, TRUE);
+}
+
+/***********************************************************************
+ * ImmGetCandidateListCountA (IMM32.@)
+ */
+DWORD WINAPI ImmGetCandidateListCountA(HIMC hIMC, LPDWORD lpdwListCount)
+{
+ return ImmGetCandidateListCountAW(hIMC, lpdwListCount, TRUE);
+}
+
+/***********************************************************************
+ * ImmGetCandidateListCountW (IMM32.@)
+ */
+DWORD WINAPI ImmGetCandidateListCountW(HIMC hIMC, LPDWORD lpdwListCount)
+{
+ return ImmGetCandidateListCountAW(hIMC, lpdwListCount, FALSE);
+}
+
+/***********************************************************************
+ * ImmGetCandidateListW (IMM32.@)
+ */
+DWORD WINAPI
+ImmGetCandidateListW(HIMC hIMC, DWORD dwIndex, LPCANDIDATELIST lpCandList, DWORD
dwBufLen)
+{
+ return ImmGetCandidateListAW(hIMC, dwIndex, lpCandList, dwBufLen, FALSE);
+}
+
+/***********************************************************************
+ * ImmGetCandidateWindow (IMM32.@)
+ */
+BOOL WINAPI
+ImmGetCandidateWindow(HIMC hIMC, DWORD dwIndex, LPCANDIDATEFORM lpCandidate)
+{
+ BOOL ret = FALSE;
+ LPINPUTCONTEXT pIC;
+ LPCANDIDATEFORM pCF;
+
+ TRACE("(%p, %lu, %p)\n", hIMC, dwIndex, lpCandidate);
+
+ pIC = ImmLockIMC(hIMC);
+ if (pIC == NULL)
+ return FALSE;
+
+ pCF = &pIC->cfCandForm[dwIndex];
+ if (pCF->dwIndex != IMM_INVALID_CANDFORM)
+ {
+ *lpCandidate = *pCF;
+ ret = TRUE;
+ }
+
+ ImmUnlockIMC(hIMC);
+ return ret;
+}
+
+/***********************************************************************
+ * ImmSetCandidateWindow (IMM32.@)
+ */
+BOOL WINAPI ImmSetCandidateWindow(HIMC hIMC, LPCANDIDATEFORM lpCandidate)
+{
+ HWND hWnd;
+ LPINPUTCONTEXT pIC;
+
+ TRACE("(%p, %p)\n", hIMC, lpCandidate);
+
+ if (lpCandidate->dwIndex >= MAX_CANDIDATEFORM)
+ return FALSE;
+
+ if (Imm32IsCrossThreadAccess(hIMC))
+ return FALSE;
+
+ pIC = ImmLockIMC(hIMC);
+ if (pIC == NULL)
+ return FALSE;
+
+ hWnd = pIC->hWnd;
+ pIC->cfCandForm[lpCandidate->dwIndex] = *lpCandidate;
+
+ ImmUnlockIMC(hIMC);
+
+ Imm32NotifyAction(hIMC, hWnd, NI_CONTEXTUPDATED, 0, IMC_SETCANDIDATEPOS,
+ IMN_SETCANDIDATEPOS, (1 << (BYTE)lpCandidate->dwIndex));
+ return TRUE;
+}
diff --git a/dll/win32/imm32/guideline.c b/dll/win32/imm32/guideline.c
new file mode 100644
index 00000000000..3a9a3c6bae1
--- /dev/null
+++ b/dll/win32/imm32/guideline.c
@@ -0,0 +1,198 @@
+/*
+ * PROJECT: ReactOS IMM32
+ * LICENSE: LGPL-2.1-or-later (https://spdx.org/licenses/LGPL-2.1-or-later)
+ * PURPOSE: Implementing IMM32 guidelines
+ * COPYRIGHT: Copyright 2020-2021 Katayama Hirofumi MZ
<katayama.hirofumi.mz(a)gmail.com>
+ */
+
+#include "precomp.h"
+
+WINE_DEFAULT_DEBUG_CHANNEL(imm);
+
+DWORD APIENTRY
+ImmGetGuideLineAW(HIMC hIMC, DWORD dwIndex, LPVOID lpBuf, DWORD dwBufLen, BOOL bAnsi)
+{
+ PCLIENTIMC pClientImc;
+ LPINPUTCONTEXT pIC;
+ LPGUIDELINE pGuideLine;
+ DWORD cb, ret = 0;
+ LPVOID pvStr, pvPrivate;
+ BOOL bUsedDefault;
+
+ pClientImc = ImmLockClientImc(hIMC);
+ if (!pClientImc)
+ return 0;
+
+ pIC = ImmLockIMC(hIMC);
+ if (!pIC)
+ {
+ ImmUnlockClientImc(pClientImc);
+ return 0;
+ }
+
+ pGuideLine = ImmLockIMCC(pIC->hGuideLine);
+ if (!pGuideLine)
+ {
+ ImmUnlockIMC(hIMC);
+ ImmUnlockClientImc(pClientImc);
+ return 0;
+ }
+
+ if (dwIndex == GGL_LEVEL)
+ {
+ ret = pGuideLine->dwLevel;
+ goto Quit;
+ }
+
+ if (dwIndex == GGL_INDEX)
+ {
+ ret = pGuideLine->dwIndex;
+ goto Quit;
+ }
+
+ if (dwIndex == GGL_STRING)
+ {
+ pvStr = (LPBYTE)pGuideLine + pGuideLine->dwStrOffset;
+
+ /* get size */
+ if (bAnsi)
+ {
+ if (pClientImc->dwFlags & CLIENTIMC_WIDE)
+ {
+ cb = WideCharToMultiByte(CP_ACP, 0, pvStr, pGuideLine->dwStrLen,
+ NULL, 0, NULL, &bUsedDefault);
+ }
+ else
+ {
+ cb = pGuideLine->dwStrLen * sizeof(CHAR);
+ }
+ }
+ else
+ {
+ if (pClientImc->dwFlags & CLIENTIMC_WIDE)
+ {
+ cb = pGuideLine->dwStrLen * sizeof(WCHAR);
+ }
+ else
+ {
+ cb = MultiByteToWideChar(CP_ACP, MB_PRECOMPOSED, pvStr,
pGuideLine->dwStrLen,
+ NULL, 0) * sizeof(WCHAR);
+ }
+ }
+
+ if (dwBufLen == 0 || cb == 0 || lpBuf == NULL || dwBufLen < cb)
+ {
+ ret = cb;
+ goto Quit;
+ }
+
+ /* store to buffer */
+ if (bAnsi)
+ {
+ if (pClientImc->dwFlags & CLIENTIMC_WIDE)
+ {
+ ret = WideCharToMultiByte(CP_ACP, 0, pvStr, pGuideLine->dwStrLen,
+ lpBuf, dwBufLen, NULL, &bUsedDefault);
+ goto Quit;
+ }
+ }
+ else
+ {
+ if (!(pClientImc->dwFlags & CLIENTIMC_WIDE))
+ {
+ ret = MultiByteToWideChar(CP_ACP, MB_PRECOMPOSED, pvStr,
pGuideLine->dwStrLen,
+ lpBuf, dwBufLen) * sizeof(WCHAR);
+ goto Quit;
+ }
+ }
+
+ RtlCopyMemory(lpBuf, pvStr, cb);
+ ret = cb;
+ goto Quit;
+ }
+
+ if (dwIndex == GGL_PRIVATE)
+ {
+ pvPrivate = (LPBYTE)pGuideLine + pGuideLine->dwPrivateOffset;
+
+ /* get size */
+ if (bAnsi)
+ {
+ if ((pClientImc->dwFlags & CLIENTIMC_WIDE) &&
+ pGuideLine->dwIndex == GL_ID_REVERSECONVERSION)
+ {
+ cb = CandidateListWideToAnsi(pvPrivate, NULL, 0, CP_ACP);
+ }
+ else
+ {
+ cb = pGuideLine->dwPrivateSize;
+ }
+ }
+ else
+ {
+ if (!(pClientImc->dwFlags & CLIENTIMC_WIDE) &&
+ pGuideLine->dwIndex == GL_ID_REVERSECONVERSION)
+ {
+ cb = CandidateListAnsiToWide(pvPrivate, NULL, 0, CP_ACP);
+ }
+ else
+ {
+ cb = pGuideLine->dwPrivateSize;
+ }
+ }
+
+ if (dwBufLen == 0 || cb == 0 || lpBuf == NULL || dwBufLen < cb)
+ {
+ ret = cb;
+ goto Quit;
+ }
+
+ /* store to buffer */
+ if (bAnsi)
+ {
+ if ((pClientImc->dwFlags & CLIENTIMC_WIDE) &&
+ pGuideLine->dwIndex == GL_ID_REVERSECONVERSION)
+ {
+ ret = CandidateListWideToAnsi(pvPrivate, lpBuf, cb, CP_ACP);
+ goto Quit;
+ }
+ }
+ else
+ {
+ if (!(pClientImc->dwFlags & CLIENTIMC_WIDE) &&
+ pGuideLine->dwIndex == GL_ID_REVERSECONVERSION)
+ {
+ ret = CandidateListAnsiToWide(pvPrivate, lpBuf, cb, CP_ACP);
+ goto Quit;
+ }
+ }
+
+ RtlCopyMemory(lpBuf, pvPrivate, cb);
+ ret = cb;
+ goto Quit;
+ }
+
+Quit:
+ ImmUnlockIMCC(pIC->hGuideLine);
+ ImmUnlockIMC(hIMC);
+ ImmUnlockClientImc(pClientImc);
+ return ret;
+}
+
+/***********************************************************************
+ * ImmGetGuideLineA (IMM32.@)
+ */
+DWORD WINAPI ImmGetGuideLineA(HIMC hIMC, DWORD dwIndex, LPSTR lpBuf, DWORD dwBufLen)
+{
+ TRACE("(%p, %lu, %p, %lu)\n", hIMC, dwIndex, lpBuf, dwBufLen);
+ return ImmGetGuideLineAW(hIMC, dwIndex, lpBuf, dwBufLen, TRUE);
+}
+
+/***********************************************************************
+ * ImmGetGuideLineW (IMM32.@)
+ */
+DWORD WINAPI ImmGetGuideLineW(HIMC hIMC, DWORD dwIndex, LPWSTR lpBuf, DWORD dwBufLen)
+{
+ TRACE("(%p, %lu, %p, %lu)\n", hIMC, dwIndex, lpBuf, dwBufLen);
+ return ImmGetGuideLineAW(hIMC, dwIndex, lpBuf, dwBufLen, FALSE);
+}
diff --git a/dll/win32/imm32/ime.c b/dll/win32/imm32/ime.c
new file mode 100644
index 00000000000..ba68a9ab3d1
--- /dev/null
+++ b/dll/win32/imm32/ime.c
@@ -0,0 +1,1201 @@
+/*
+ * PROJECT: ReactOS IMM32
+ * LICENSE: LGPL-2.1-or-later (https://spdx.org/licenses/LGPL-2.1-or-later)
+ * PURPOSE: Implementing IME manipulation of IMM32
+ * COPYRIGHT: Copyright 1998 Patrik Stridvall
+ * Copyright 2002, 2003, 2007 CodeWeavers, Aric Stewart
+ * Copyright 2017 James Tabor <james.tabor(a)reactos.org>
+ * Copyright 2018 Amine Khaldi <amine.khaldi(a)reactos.org>
+ * Copyright 2020 Oleg Dubinskiy <oleg.dubinskij2013(a)yandex.ua>
+ * Copyright 2020-2021 Katayama Hirofumi MZ
<katayama.hirofumi.mz(a)gmail.com>
+ */
+
+#include "precomp.h"
+
+WINE_DEFAULT_DEBUG_CHANNEL(imm);
+
+RTL_CRITICAL_SECTION g_csImeDpi;
+PIMEDPI g_pImeDpiList = NULL;
+
+PIMEDPI APIENTRY Imm32FindImeDpi(HKL hKL)
+{
+ PIMEDPI pImeDpi;
+
+ RtlEnterCriticalSection(&g_csImeDpi);
+ for (pImeDpi = g_pImeDpiList; pImeDpi != NULL; pImeDpi = pImeDpi->pNext)
+ {
+ if (pImeDpi->hKL == hKL)
+ break;
+ }
+ RtlLeaveCriticalSection(&g_csImeDpi);
+
+ return pImeDpi;
+}
+
+VOID APIENTRY Imm32FreeImeDpi(PIMEDPI pImeDpi, BOOL bDestroy)
+{
+ if (pImeDpi->hInst == NULL)
+ return;
+ if (bDestroy)
+ pImeDpi->ImeDestroy(0);
+ FreeLibrary(pImeDpi->hInst);
+ pImeDpi->hInst = NULL;
+}
+
+BOOL APIENTRY Imm32InquireIme(PIMEDPI pImeDpi)
+{
+ WCHAR szUIClass[64];
+ WNDCLASSW wcW;
+ DWORD dwSysInfoFlags = 0; // TODO: ???
+ LPIMEINFO pImeInfo = &pImeDpi->ImeInfo;
+
+ // TODO: NtUserGetThreadState(16);
+
+ if (!IS_IME_HKL(pImeDpi->hKL))
+ {
+ if (g_psi && (g_psi->dwSRVIFlags & SRVINFO_CICERO_ENABLED)
&&
+ pImeDpi->CtfImeInquireExW)
+ {
+ // TODO:
+ return FALSE;
+ }
+ }
+
+ if (!pImeDpi->ImeInquire(pImeInfo, szUIClass, dwSysInfoFlags))
+ return FALSE;
+
+ szUIClass[_countof(szUIClass) - 1] = 0;
+
+ if (pImeInfo->dwPrivateDataSize == 0)
+ pImeInfo->dwPrivateDataSize = 4;
+
+#define VALID_IME_PROP (IME_PROP_AT_CARET | \
+ IME_PROP_SPECIAL_UI | \
+ IME_PROP_CANDLIST_START_FROM_1 | \
+ IME_PROP_UNICODE | \
+ IME_PROP_COMPLETE_ON_UNSELECT | \
+ IME_PROP_END_UNLOAD | \
+ IME_PROP_KBD_CHAR_FIRST | \
+ IME_PROP_IGNORE_UPKEYS | \
+ IME_PROP_NEED_ALTKEY | \
+ IME_PROP_NO_KEYS_ON_CLOSE | \
+ IME_PROP_ACCEPT_WIDE_VKEY)
+#define VALID_CMODE_CAPS (IME_CMODE_ALPHANUMERIC | \
+ IME_CMODE_NATIVE | \
+ IME_CMODE_KATAKANA | \
+ IME_CMODE_LANGUAGE | \
+ IME_CMODE_FULLSHAPE | \
+ IME_CMODE_ROMAN | \
+ IME_CMODE_CHARCODE | \
+ IME_CMODE_HANJACONVERT | \
+ IME_CMODE_SOFTKBD | \
+ IME_CMODE_NOCONVERSION | \
+ IME_CMODE_EUDC | \
+ IME_CMODE_SYMBOL | \
+ IME_CMODE_FIXED)
+#define VALID_SMODE_CAPS (IME_SMODE_NONE | \
+ IME_SMODE_PLAURALCLAUSE | \
+ IME_SMODE_SINGLECONVERT | \
+ IME_SMODE_AUTOMATIC | \
+ IME_SMODE_PHRASEPREDICT | \
+ IME_SMODE_CONVERSATION)
+#define VALID_UI_CAPS (UI_CAP_2700 | \
+ UI_CAP_ROT90 | \
+ UI_CAP_ROTANY | \
+ UI_CAP_SOFTKBD)
+#define VALID_SCS_CAPS (SCS_CAP_COMPSTR | \
+ SCS_CAP_MAKEREAD | \
+ SCS_CAP_SETRECONVERTSTRING)
+#define VALID_SELECT_CAPS (SELECT_CAP_CONVERSION | SELECT_CAP_SENTENCE)
+
+ if (pImeInfo->fdwProperty & ~VALID_IME_PROP)
+ return FALSE;
+ if (pImeInfo->fdwConversionCaps & ~VALID_CMODE_CAPS)
+ return FALSE;
+ if (pImeInfo->fdwSentenceCaps & ~VALID_SMODE_CAPS)
+ return FALSE;
+ if (pImeInfo->fdwUICaps & ~VALID_UI_CAPS)
+ return FALSE;
+ if (pImeInfo->fdwSCSCaps & ~VALID_SCS_CAPS)
+ return FALSE;
+ if (pImeInfo->fdwSelectCaps & ~VALID_SELECT_CAPS)
+ return FALSE;
+
+#undef VALID_IME_PROP
+#undef VALID_CMODE_CAPS
+#undef VALID_SMODE_CAPS
+#undef VALID_UI_CAPS
+#undef VALID_SCS_CAPS
+#undef VALID_SELECT_CAPS
+
+ if (pImeInfo->fdwProperty & IME_PROP_UNICODE)
+ {
+ StringCchCopyW(pImeDpi->szUIClass, _countof(pImeDpi->szUIClass),
szUIClass);
+ }
+ else
+ {
+ if (pImeDpi->uCodePage != GetACP() && pImeDpi->uCodePage)
+ return FALSE;
+
+ MultiByteToWideChar(CP_ACP, MB_PRECOMPOSED, (LPSTR)szUIClass, -1,
+ pImeDpi->szUIClass, _countof(pImeDpi->szUIClass));
+ }
+
+ return GetClassInfoW(pImeDpi->hInst, pImeDpi->szUIClass, &wcW);
+}
+
+BOOL APIENTRY Imm32LoadImeInfo(PIMEINFOEX pImeInfoEx, PIMEDPI pImeDpi)
+{
+ WCHAR szPath[MAX_PATH];
+ HINSTANCE hIME;
+ FARPROC fn;
+
+ if (!Imm32GetSystemLibraryPath(szPath, _countof(szPath), pImeInfoEx->wszImeFile))
+ return FALSE;
+
+ hIME = GetModuleHandleW(szPath);
+ if (hIME == NULL)
+ {
+ hIME = LoadLibraryW(szPath);
+ if (hIME == NULL)
+ {
+ ERR("Imm32LoadImeInfo: LoadLibraryW(%S) failed\n", szPath);
+ return FALSE;
+ }
+ }
+ pImeDpi->hInst = hIME;
+
+#define DEFINE_IME_ENTRY(type, name, params, extended) \
+ do { \
+ fn = GetProcAddress(hIME, #name); \
+ if (fn) pImeDpi->name = (FN_##name)fn; \
+ else if (!extended) goto Failed; \
+ } while (0);
+#include "../../../win32ss/include/imetable.h"
+#undef DEFINE_IME_ENTRY
+
+ if (!Imm32InquireIme(pImeDpi))
+ {
+ ERR("Imm32LoadImeInfo: Imm32InquireIme failed\n");
+ goto Failed;
+ }
+
+ if (pImeInfoEx->fLoadFlag)
+ return TRUE;
+
+ NtUserSetImeOwnerWindow(pImeInfoEx, TRUE);
+ return TRUE;
+
+Failed:
+ FreeLibrary(pImeDpi->hInst);
+ pImeDpi->hInst = NULL;
+ return FALSE;
+}
+
+PIMEDPI APIENTRY Ime32LoadImeDpi(HKL hKL, BOOL bLock)
+{
+ IMEINFOEX ImeInfoEx;
+ CHARSETINFO ci;
+ PIMEDPI pImeDpiNew, pImeDpiFound;
+ UINT uCodePage;
+ LCID lcid;
+
+ if (!ImmGetImeInfoEx(&ImeInfoEx, ImeInfoExKeyboardLayout, &hKL) ||
+ ImeInfoEx.fLoadFlag == 1)
+ {
+ return NULL;
+ }
+
+ pImeDpiNew = Imm32HeapAlloc(HEAP_ZERO_MEMORY, sizeof(IMEDPI));
+ if (pImeDpiNew == NULL)
+ return NULL;
+
+ pImeDpiNew->hKL = hKL;
+
+ lcid = LOWORD(hKL);
+ if (TranslateCharsetInfo((LPDWORD)(DWORD_PTR)lcid, &ci, TCI_SRCLOCALE))
+ uCodePage = ci.ciACP;
+ else
+ uCodePage = CP_ACP;
+ pImeDpiNew->uCodePage = uCodePage;
+
+ if (!Imm32LoadImeInfo(&ImeInfoEx, pImeDpiNew))
+ {
+ HeapFree(g_hImm32Heap, 0, pImeDpiNew);
+ return FALSE;
+ }
+
+ RtlEnterCriticalSection(&g_csImeDpi);
+
+ pImeDpiFound = Imm32FindImeDpi(hKL);
+ if (pImeDpiFound)
+ {
+ if (!bLock)
+ pImeDpiFound->dwFlags &= ~IMEDPI_FLAG_LOCKED;
+
+ RtlLeaveCriticalSection(&g_csImeDpi);
+
+ Imm32FreeImeDpi(pImeDpiNew, FALSE);
+ HeapFree(g_hImm32Heap, 0, pImeDpiNew);
+ return pImeDpiFound;
+ }
+ else
+ {
+ if (bLock)
+ {
+ pImeDpiNew->dwFlags |= IMEDPI_FLAG_LOCKED;
+ pImeDpiNew->cLockObj = 1;
+ }
+
+ pImeDpiNew->pNext = g_pImeDpiList;
+ g_pImeDpiList = pImeDpiNew;
+
+ RtlLeaveCriticalSection(&g_csImeDpi);
+ return pImeDpiNew;
+ }
+}
+
+PIMEDPI APIENTRY ImmLockOrLoadImeDpi(HKL hKL)
+{
+ PW32CLIENTINFO pInfo;
+ PIMEDPI pImeDpi;
+
+ if (!IS_IME_HKL(hKL))
+ {
+ if (!g_psi || !(g_psi->dwSRVIFlags & SRVINFO_CICERO_ENABLED))
+ return NULL;
+
+ pInfo = (PW32CLIENTINFO)(NtCurrentTeb()->Win32ClientInfo);
+ if ((pInfo->W32ClientInfo[0] & 2))
+ return NULL;
+ }
+
+ pImeDpi = ImmLockImeDpi(hKL);
+ if (pImeDpi == NULL)
+ pImeDpi = Ime32LoadImeDpi(hKL, TRUE);
+ return pImeDpi;
+}
+
+/***********************************************************************
+ * ImmIsIME (IMM32.@)
+ */
+BOOL WINAPI ImmIsIME(HKL hKL)
+{
+ IMEINFOEX info;
+ TRACE("(%p)\n", hKL);
+ return !!ImmGetImeInfoEx(&info, ImeInfoExImeWindow, &hKL);
+}
+
+/***********************************************************************
+ * ImmGetDefaultIMEWnd (IMM32.@)
+ */
+HWND WINAPI ImmGetDefaultIMEWnd(HWND hWnd)
+{
+ if (!g_psi || !(g_psi->dwSRVIFlags & SRVINFO_IMM32))
+ return NULL;
+
+ // FIXME: NtUserGetThreadState and enum ThreadStateRoutines are broken.
+ if (hWnd == NULL)
+ return (HWND)NtUserGetThreadState(3);
+
+ return (HWND)NtUserQueryWindow(hWnd, QUERY_WINDOW_DEFAULT_IME);
+}
+
+/***********************************************************************
+ * ImmNotifyIME (IMM32.@)
+ */
+BOOL WINAPI ImmNotifyIME(HIMC hIMC, DWORD dwAction, DWORD dwIndex, DWORD dwValue)
+{
+ HKL hKL;
+ PIMEDPI pImeDpi;
+ BOOL ret;
+
+ TRACE("(%p, %lu, %lu, %lu)\n", hIMC, dwAction, dwIndex, dwValue);
+
+ if (hIMC && Imm32IsCrossThreadAccess(hIMC))
+ return FALSE;
+
+ hKL = GetKeyboardLayout(0);
+ pImeDpi = ImmLockImeDpi(hKL);
+ if (pImeDpi == NULL)
+ return FALSE;
+
+ ret = pImeDpi->NotifyIME(hIMC, dwAction, dwIndex, dwValue);
+ ImmUnlockImeDpi(pImeDpi);
+ return ret;
+}
+
+/***********************************************************************
+ * ImmDisableLegacyIME(IMM32.@)
+ */
+BOOL WINAPI ImmDisableLegacyIME(void)
+{
+ FIXME("stub\n");
+ return TRUE;
+}
+
+/***********************************************************************
+ * CtfImmIsTextFrameServiceDisabled(IMM32.@)
+ */
+BOOL WINAPI CtfImmIsTextFrameServiceDisabled(VOID)
+{
+ PTEB pTeb = NtCurrentTeb();
+ if (((PW32CLIENTINFO)pTeb->Win32ClientInfo)->CI_flags & CI_TFSDISABLED)
+ return TRUE;
+ return FALSE;
+}
+
+/***********************************************************************
+ * ImmGetImeInfoEx (IMM32.@)
+ */
+BOOL WINAPI
+ImmGetImeInfoEx(PIMEINFOEX pImeInfoEx, IMEINFOEXCLASS SearchType, PVOID pvSearchKey)
+{
+ BOOL bDisabled = FALSE;
+ HKL hKL;
+ PTEB pTeb;
+
+ switch (SearchType)
+ {
+ case ImeInfoExKeyboardLayout:
+ break;
+
+ case ImeInfoExImeWindow:
+ bDisabled = CtfImmIsTextFrameServiceDisabled();
+ SearchType = ImeInfoExKeyboardLayout;
+ break;
+
+ case ImeInfoExImeFileName:
+ StringCchCopyW(pImeInfoEx->wszImeFile,
_countof(pImeInfoEx->wszImeFile),
+ pvSearchKey);
+ goto Quit;
+ }
+
+ hKL = *(HKL*)pvSearchKey;
+ pImeInfoEx->hkl = hKL;
+
+ if (!IS_IME_HKL(hKL))
+ {
+ if (g_psi && (g_psi->dwSRVIFlags & SRVINFO_CICERO_ENABLED))
+ {
+ pTeb = NtCurrentTeb();
+ if (((PW32CLIENTINFO)pTeb->Win32ClientInfo)->W32ClientInfo[0] & 2)
+ return FALSE;
+ if (!bDisabled)
+ goto Quit;
+ }
+ return FALSE;
+ }
+
+Quit:
+ return NtUserGetImeInfoEx(pImeInfoEx, SearchType);
+}
+
+/***********************************************************************
+ * ImmLockImeDpi (IMM32.@)
+ */
+PIMEDPI WINAPI ImmLockImeDpi(HKL hKL)
+{
+ PIMEDPI pImeDpi = NULL;
+
+ TRACE("(%p)\n", hKL);
+
+ RtlEnterCriticalSection(&g_csImeDpi);
+
+ /* Find by hKL */
+ for (pImeDpi = g_pImeDpiList; pImeDpi; pImeDpi = pImeDpi->pNext)
+ {
+ if (pImeDpi->hKL == hKL) /* found */
+ {
+ /* lock if possible */
+ if (pImeDpi->dwFlags & IMEDPI_FLAG_UNKNOWN)
+ pImeDpi = NULL;
+ else
+ ++(pImeDpi->cLockObj);
+ break;
+ }
+ }
+
+ RtlLeaveCriticalSection(&g_csImeDpi);
+ return pImeDpi;
+}
+
+/***********************************************************************
+ * ImmUnlockImeDpi (IMM32.@)
+ */
+VOID WINAPI ImmUnlockImeDpi(PIMEDPI pImeDpi)
+{
+ PIMEDPI *ppEntry;
+
+ TRACE("(%p)\n", pImeDpi);
+
+ if (pImeDpi == NULL)
+ return;
+
+ RtlEnterCriticalSection(&g_csImeDpi);
+
+ /* unlock */
+ --(pImeDpi->cLockObj);
+ if (pImeDpi->cLockObj != 0)
+ {
+ RtlLeaveCriticalSection(&g_csImeDpi);
+ return;
+ }
+
+ if ((pImeDpi->dwFlags & IMEDPI_FLAG_UNKNOWN) == 0)
+ {
+ if ((pImeDpi->dwFlags & IMEDPI_FLAG_LOCKED) == 0 ||
+ (pImeDpi->ImeInfo.fdwProperty & IME_PROP_END_UNLOAD) == 0)
+ {
+ RtlLeaveCriticalSection(&g_csImeDpi);
+ return;
+ }
+ }
+
+ /* Remove from list */
+ for (ppEntry = &g_pImeDpiList; *ppEntry; ppEntry = &((*ppEntry)->pNext))
+ {
+ if (*ppEntry == pImeDpi) /* found */
+ {
+ *ppEntry = pImeDpi->pNext;
+ break;
+ }
+ }
+
+ Imm32FreeImeDpi(pImeDpi, TRUE);
+ HeapFree(g_hImm32Heap, 0, pImeDpi);
+
+ RtlLeaveCriticalSection(&g_csImeDpi);
+}
+
+/***********************************************************************
+ * ImmLoadIME (IMM32.@)
+ */
+BOOL WINAPI ImmLoadIME(HKL hKL)
+{
+ PW32CLIENTINFO pInfo;
+ PIMEDPI pImeDpi;
+
+ if (!IS_IME_HKL(hKL))
+ {
+ if (!g_psi || !(g_psi->dwSRVIFlags & SRVINFO_CICERO_ENABLED))
+ return FALSE;
+
+ pInfo = (PW32CLIENTINFO)(NtCurrentTeb()->Win32ClientInfo);
+ if ((pInfo->W32ClientInfo[0] & 2))
+ return FALSE;
+ }
+
+ pImeDpi = Imm32FindImeDpi(hKL);
+ if (pImeDpi == NULL)
+ pImeDpi = Ime32LoadImeDpi(hKL, FALSE);
+ return (pImeDpi != NULL);
+}
+
+/***********************************************************************
+ * ImmDisableIME (IMM32.@)
+ */
+BOOL WINAPI ImmDisableIME(DWORD dwThreadId)
+{
+ return NtUserDisableThreadIme(dwThreadId);
+}
+
+/***********************************************************************
+ * ImmGetDescriptionA (IMM32.@)
+ */
+UINT WINAPI ImmGetDescriptionA(HKL hKL, LPSTR lpszDescription, UINT uBufLen)
+{
+ IMEINFOEX info;
+ size_t cch;
+
+ TRACE("(%p,%p,%d)\n", hKL, lpszDescription, uBufLen);
+
+ if (!ImmGetImeInfoEx(&info, ImeInfoExKeyboardLayout, &hKL) ||
!IS_IME_HKL(hKL))
+ return 0;
+
+ StringCchLengthW(info.wszImeDescription, _countof(info.wszImeDescription),
&cch);
+ cch = WideCharToMultiByte(CP_ACP, 0, info.wszImeDescription, (INT)cch,
+ lpszDescription, uBufLen, NULL, NULL);
+ if (uBufLen)
+ lpszDescription[cch] = 0;
+ return (UINT)cch;
+}
+
+/***********************************************************************
+ * ImmGetDescriptionW (IMM32.@)
+ */
+UINT WINAPI ImmGetDescriptionW(HKL hKL, LPWSTR lpszDescription, UINT uBufLen)
+{
+ IMEINFOEX info;
+ size_t cch;
+
+ TRACE("(%p, %p, %d)\n", hKL, lpszDescription, uBufLen);
+
+ if (!ImmGetImeInfoEx(&info, ImeInfoExKeyboardLayout, &hKL) ||
!IS_IME_HKL(hKL))
+ return 0;
+
+ if (uBufLen != 0)
+ StringCchCopyW(lpszDescription, uBufLen, info.wszImeDescription);
+
+ StringCchLengthW(info.wszImeDescription, _countof(info.wszImeDescription),
&cch);
+ return (UINT)cch;
+}
+
+/***********************************************************************
+ * ImmGetIMEFileNameA (IMM32.@)
+ */
+UINT WINAPI ImmGetIMEFileNameA( HKL hKL, LPSTR lpszFileName, UINT uBufLen)
+{
+ BOOL bDefUsed;
+ IMEINFOEX info;
+ size_t cch;
+
+ TRACE("(%p, %p, %u)\n", hKL, lpszFileName, uBufLen);
+
+ if (!ImmGetImeInfoEx(&info, ImeInfoExKeyboardLayout, &hKL) ||
!IS_IME_HKL(hKL))
+ {
+ if (uBufLen > 0)
+ lpszFileName[0] = 0;
+ return 0;
+ }
+
+ StringCchLengthW(info.wszImeFile, _countof(info.wszImeFile), &cch);
+
+ cch = WideCharToMultiByte(CP_ACP, 0, info.wszImeFile, (INT)cch,
+ lpszFileName, uBufLen, NULL, &bDefUsed);
+ if (uBufLen == 0)
+ return (UINT)cch;
+
+ if (cch > uBufLen - 1)
+ cch = uBufLen - 1;
+
+ lpszFileName[cch] = 0;
+ return (UINT)cch;
+}
+
+/***********************************************************************
+ * ImmGetIMEFileNameW (IMM32.@)
+ */
+UINT WINAPI ImmGetIMEFileNameW(HKL hKL, LPWSTR lpszFileName, UINT uBufLen)
+{
+ IMEINFOEX info;
+ size_t cch;
+
+ TRACE("(%p, %p, %u)\n", hKL, lpszFileName, uBufLen);
+
+ if (!ImmGetImeInfoEx(&info, ImeInfoExKeyboardLayout, &hKL) ||
!IS_IME_HKL(hKL))
+ {
+ if (uBufLen > 0)
+ lpszFileName[0] = 0;
+ return 0;
+ }
+
+ StringCchLengthW(info.wszImeFile, _countof(info.wszImeFile), &cch);
+ if (uBufLen == 0)
+ return (UINT)cch;
+
+ StringCchCopyNW(lpszFileName, uBufLen, info.wszImeFile, cch);
+
+ if (cch > uBufLen - 1)
+ cch = uBufLen - 1;
+
+ lpszFileName[cch] = 0;
+ return (UINT)cch;
+}
+
+/***********************************************************************
+ * ImmGetProperty (IMM32.@)
+ */
+DWORD WINAPI ImmGetProperty(HKL hKL, DWORD fdwIndex)
+{
+ IMEINFOEX ImeInfoEx;
+ LPIMEINFO pImeInfo;
+ DWORD dwValue;
+ PIMEDPI pImeDpi = NULL;
+
+ TRACE("(%p, %lu)\n", hKL, fdwIndex);
+
+ if (!ImmGetImeInfoEx(&ImeInfoEx, ImeInfoExKeyboardLayout, &hKL))
+ return FALSE;
+
+ if (fdwIndex == IGP_GETIMEVERSION)
+ return ImeInfoEx.dwImeWinVersion;
+
+ if (ImeInfoEx.fLoadFlag != 2)
+ {
+ pImeDpi = ImmLockOrLoadImeDpi(hKL);
+ if (pImeDpi == NULL)
+ return FALSE;
+
+ pImeInfo = &pImeDpi->ImeInfo;
+ }
+ else
+ {
+ pImeInfo = &ImeInfoEx.ImeInfo;
+ }
+
+ switch (fdwIndex)
+ {
+ case IGP_PROPERTY: dwValue = pImeInfo->fdwProperty; break;
+ case IGP_CONVERSION: dwValue = pImeInfo->fdwConversionCaps; break;
+ case IGP_SENTENCE: dwValue = pImeInfo->fdwSentenceCaps; break;
+ case IGP_UI: dwValue = pImeInfo->fdwUICaps; break;
+ case IGP_SETCOMPSTR: dwValue = pImeInfo->fdwSCSCaps; break;
+ case IGP_SELECT: dwValue = pImeInfo->fdwSelectCaps; break;
+ default: dwValue = 0; break;
+ }
+
+ if (pImeDpi)
+ ImmUnlockImeDpi(pImeDpi);
+ return dwValue;
+}
+
+/***********************************************************************
+ * ImmGetOpenStatus (IMM32.@)
+ */
+BOOL WINAPI ImmGetOpenStatus(HIMC hIMC)
+{
+ BOOL ret;
+ LPINPUTCONTEXT pIC;
+
+ TRACE("(%p)\n", hIMC);
+
+ if (!hIMC)
+ return FALSE;
+
+ pIC = ImmLockIMC(hIMC);
+ if (!pIC)
+ return FALSE;
+
+ ret = pIC->fOpen;
+
+ ImmUnlockIMC(hIMC);
+ return ret;
+}
+
+/***********************************************************************
+ * ImmSetOpenStatus (IMM32.@)
+ */
+BOOL WINAPI ImmSetOpenStatus(HIMC hIMC, BOOL fOpen)
+{
+ DWORD dwConversion;
+ LPINPUTCONTEXT pIC;
+ HWND hWnd;
+ BOOL bHasChange = FALSE;
+
+ TRACE("(%p, %d)\n", hIMC, fOpen);
+
+ if (Imm32IsCrossThreadAccess(hIMC))
+ return FALSE;
+
+ pIC = ImmLockIMC(hIMC);
+ if (pIC == NULL)
+ return FALSE;
+
+ if (pIC->fOpen != fOpen)
+ {
+ pIC->fOpen = fOpen;
+ hWnd = pIC->hWnd;
+ dwConversion = pIC->fdwConversion;
+ bHasChange = TRUE;
+ }
+
+ ImmUnlockIMC(hIMC);
+
+ if (bHasChange)
+ {
+ Imm32NotifyAction(hIMC, hWnd, NI_CONTEXTUPDATED, 0,
+ IMC_SETOPENSTATUS, IMN_SETOPENSTATUS, 0);
+ NtUserNotifyIMEStatus(hWnd, hIMC, dwConversion);
+ }
+
+ return TRUE;
+}
+
+/***********************************************************************
+ * ImmGetStatusWindowPos (IMM32.@)
+ */
+BOOL WINAPI ImmGetStatusWindowPos(HIMC hIMC, LPPOINT lpptPos)
+{
+ LPINPUTCONTEXT pIC;
+ BOOL ret;
+
+ TRACE("(%p, %p)\n", hIMC, lpptPos);
+
+ pIC = ImmLockIMC(hIMC);
+ if (pIC == NULL)
+ return FALSE;
+
+ ret = !!(pIC->fdwInit & INIT_STATUSWNDPOS);
+ if (ret)
+ *lpptPos = pIC->ptStatusWndPos;
+
+ ImmUnlockIMC(hIMC);
+ return ret;
+}
+
+/***********************************************************************
+ * ImmSetStatusWindowPos (IMM32.@)
+ */
+BOOL WINAPI ImmSetStatusWindowPos(HIMC hIMC, LPPOINT lpptPos)
+{
+ LPINPUTCONTEXT pIC;
+ HWND hWnd;
+
+ TRACE("(%p, {%ld, %ld})\n", hIMC, lpptPos->x, lpptPos->y);
+
+ if (Imm32IsCrossThreadAccess(hIMC))
+ return FALSE;
+
+ pIC = ImmLockIMC(hIMC);
+ if (!pIC)
+ return FALSE;
+
+ hWnd = pIC->hWnd;
+ pIC->ptStatusWndPos = *lpptPos;
+ pIC->fdwInit |= INIT_STATUSWNDPOS;
+
+ ImmUnlockIMC(hIMC);
+
+ Imm32NotifyAction(hIMC, hWnd, NI_CONTEXTUPDATED, 0,
+ IMC_SETSTATUSWINDOWPOS, IMN_SETSTATUSWINDOWPOS, 0);
+ return TRUE;
+}
+
+/***********************************************************************
+ * ImmGetCompositionWindow (IMM32.@)
+ */
+BOOL WINAPI ImmGetCompositionWindow(HIMC hIMC, LPCOMPOSITIONFORM lpCompForm)
+{
+ LPINPUTCONTEXT pIC;
+ BOOL ret = FALSE;
+
+ TRACE("(%p, %p)\n", hIMC, lpCompForm);
+
+ pIC = ImmLockIMC(hIMC);
+ if (!pIC)
+ return FALSE;
+
+ if (pIC->fdwInit & INIT_COMPFORM)
+ {
+ *lpCompForm = pIC->cfCompForm;
+ ret = TRUE;
+ }
+
+ ImmUnlockIMC(hIMC);
+ return ret;
+}
+
+/***********************************************************************
+ * ImmSetCompositionWindow (IMM32.@)
+ */
+BOOL WINAPI ImmSetCompositionWindow(HIMC hIMC, LPCOMPOSITIONFORM lpCompForm)
+{
+ LPINPUTCONTEXT pIC;
+ HWND hWnd;
+
+ if (Imm32IsCrossThreadAccess(hIMC))
+ return FALSE;
+
+ pIC = ImmLockIMC(hIMC);
+ if (pIC == NULL)
+ return FALSE;
+
+ pIC->cfCompForm = *lpCompForm;
+ pIC->fdwInit |= INIT_COMPFORM;
+
+ hWnd = pIC->hWnd;
+
+ ImmUnlockIMC(hIMC);
+
+ Imm32NotifyAction(hIMC, hWnd, NI_CONTEXTUPDATED, 0,
+ IMC_SETCOMPOSITIONWINDOW, IMN_SETCOMPOSITIONWINDOW, 0);
+ return TRUE;
+}
+
+/***********************************************************************
+ * ImmGetCompositionFontA (IMM32.@)
+ */
+BOOL WINAPI ImmGetCompositionFontA(HIMC hIMC, LPLOGFONTA lplf)
+{
+ PCLIENTIMC pClientImc;
+ BOOL ret = FALSE, bWide;
+ LPINPUTCONTEXT pIC;
+
+ TRACE("(%p, %p)\n", hIMC, lplf);
+
+ pClientImc = ImmLockClientImc(hIMC);
+ if (pClientImc == NULL)
+ return FALSE;
+
+ bWide = (pClientImc->dwFlags & CLIENTIMC_WIDE);
+ ImmUnlockClientImc(pClientImc);
+
+ pIC = ImmLockIMC(hIMC);
+ if (pIC == NULL)
+ return FALSE;
+
+ if (pIC->fdwInit & INIT_LOGFONT)
+ {
+ if (bWide)
+ LogFontWideToAnsi(&pIC->lfFont.W, lplf);
+ else
+ *lplf = pIC->lfFont.A;
+
+ ret = TRUE;
+ }
+
+ ImmUnlockIMC(hIMC);
+ return ret;
+}
+
+/***********************************************************************
+ * ImmGetCompositionFontW (IMM32.@)
+ */
+BOOL WINAPI ImmGetCompositionFontW(HIMC hIMC, LPLOGFONTW lplf)
+{
+ PCLIENTIMC pClientImc;
+ BOOL bWide;
+ LPINPUTCONTEXT pIC;
+ BOOL ret = FALSE;
+
+ TRACE("(%p, %p)\n", hIMC, lplf);
+
+ pClientImc = ImmLockClientImc(hIMC);
+ if (pClientImc == NULL)
+ return FALSE;
+
+ bWide = (pClientImc->dwFlags & CLIENTIMC_WIDE);
+ ImmUnlockClientImc(pClientImc);
+
+ pIC = ImmLockIMC(hIMC);
+ if (pIC == NULL)
+ return FALSE;
+
+ if (pIC->fdwInit & INIT_LOGFONT)
+ {
+ if (bWide)
+ *lplf = pIC->lfFont.W;
+ else
+ LogFontAnsiToWide(&pIC->lfFont.A, lplf);
+
+ ret = TRUE;
+ }
+
+ ImmUnlockIMC(hIMC);
+ return ret;
+}
+
+/***********************************************************************
+ * ImmSetCompositionFontA (IMM32.@)
+ */
+BOOL WINAPI ImmSetCompositionFontA(HIMC hIMC, LPLOGFONTA lplf)
+{
+ LOGFONTW lfW;
+ PCLIENTIMC pClientImc;
+ BOOL bWide;
+ LPINPUTCONTEXTDX pIC;
+ LCID lcid;
+ HWND hWnd;
+ PTEB pTeb;
+
+ TRACE("(%p, %p)\n", hIMC, lplf);
+
+ if (Imm32IsCrossThreadAccess(hIMC))
+ return FALSE;
+
+ pClientImc = ImmLockClientImc(hIMC);
+ if (pClientImc == NULL)
+ return FALSE;
+
+ bWide = (pClientImc->dwFlags & CLIENTIMC_WIDE);
+ ImmUnlockClientImc(pClientImc);
+
+ if (bWide)
+ {
+ LogFontAnsiToWide(lplf, &lfW);
+ return ImmSetCompositionFontW(hIMC, &lfW);
+ }
+
+ pIC = (LPINPUTCONTEXTDX)ImmLockIMC(hIMC);
+ if (pIC == NULL)
+ return FALSE;
+
+ pTeb = NtCurrentTeb();
+ if (pTeb->Win32ClientInfo[2] < 0x400)
+ {
+ lcid = GetSystemDefaultLCID();
+ if (PRIMARYLANGID(lcid) == LANG_JAPANESE && !(pIC->dwUIFlags & 2)
&&
+ pIC->cfCompForm.dwStyle != CFS_DEFAULT)
+ {
+ PostMessageA(pIC->hWnd, WM_IME_REPORT, IR_CHANGECONVERT, 0);
+ }
+ }
+
+ pIC->lfFont.A = *lplf;
+ pIC->fdwInit |= INIT_LOGFONT;
+ hWnd = pIC->hWnd;
+
+ ImmUnlockIMC(hIMC);
+
+ Imm32NotifyAction(hIMC, hWnd, NI_CONTEXTUPDATED, 0, IMC_SETCOMPOSITIONFONT,
+ IMN_SETCOMPOSITIONFONT, 0);
+ return TRUE;
+}
+
+/***********************************************************************
+ * ImmSetCompositionFontW (IMM32.@)
+ */
+BOOL WINAPI ImmSetCompositionFontW(HIMC hIMC, LPLOGFONTW lplf)
+{
+ LOGFONTA lfA;
+ PCLIENTIMC pClientImc;
+ BOOL bWide;
+ HWND hWnd;
+ LPINPUTCONTEXTDX pIC;
+ PTEB pTeb;
+ LCID lcid;
+
+ TRACE("(%p, %p)\n", hIMC, lplf);
+
+ if (Imm32IsCrossThreadAccess(hIMC))
+ return FALSE;
+
+ pClientImc = ImmLockClientImc(hIMC);
+ if (pClientImc == NULL)
+ return FALSE;
+
+ bWide = (pClientImc->dwFlags & CLIENTIMC_WIDE);
+ ImmUnlockClientImc(pClientImc);
+
+ if (!bWide)
+ {
+ LogFontWideToAnsi(lplf, &lfA);
+ return ImmSetCompositionFontA(hIMC, &lfA);
+ }
+
+ pIC = (LPINPUTCONTEXTDX)ImmLockIMC(hIMC);
+ if (pIC == NULL)
+ return FALSE;
+
+ pTeb = NtCurrentTeb();
+ if (pTeb->Win32ClientInfo[2] < 0x400)
+ {
+ lcid = GetSystemDefaultLCID();
+ if (PRIMARYLANGID(lcid) == LANG_JAPANESE &&
+ !(pIC->dwUIFlags & 2) &&
+ pIC->cfCompForm.dwStyle != CFS_DEFAULT)
+ {
+ PostMessageW(pIC->hWnd, WM_IME_REPORT, IR_CHANGECONVERT, 0);
+ }
+ }
+
+ pIC->lfFont.W = *lplf;
+ pIC->fdwInit |= INIT_LOGFONT;
+ hWnd = pIC->hWnd;
+
+ ImmUnlockIMC(hIMC);
+
+ Imm32NotifyAction(hIMC, hWnd, NI_CONTEXTUPDATED, 0, IMC_SETCOMPOSITIONFONT,
+ IMN_SETCOMPOSITIONFONT, 0);
+ return TRUE;
+}
+
+/***********************************************************************
+ * ImmGetConversionListA (IMM32.@)
+ */
+DWORD WINAPI
+ImmGetConversionListA(HKL hKL, HIMC hIMC, LPCSTR pSrc, LPCANDIDATELIST lpDst,
+ DWORD dwBufLen, UINT uFlag)
+{
+ DWORD ret = 0;
+ UINT cb;
+ LPWSTR pszSrcW = NULL;
+ LPCANDIDATELIST pCL = NULL;
+ PIMEDPI pImeDpi;
+
+ TRACE("(%p, %p, %s, %p, %lu, 0x%lX)\n", hKL, hIMC, debugstr_a(pSrc),
+ lpDst, dwBufLen, uFlag);
+
+ pImeDpi = ImmLockOrLoadImeDpi(hKL);
+ if (pImeDpi == NULL)
+ return 0;
+
+ if (!(pImeDpi->ImeInfo.fdwProperty & IME_PROP_UNICODE))
+ {
+ ret = pImeDpi->ImeConversionList(hIMC, pSrc, lpDst, dwBufLen, uFlag);
+ ImmUnlockImeDpi(pImeDpi);
+ return ret;
+ }
+
+ if (pSrc)
+ {
+ pszSrcW = Imm32WideFromAnsi(pSrc);
+ if (pszSrcW == NULL)
+ goto Quit;
+ }
+
+ cb = pImeDpi->ImeConversionList(hIMC, pszSrcW, NULL, 0, uFlag);
+ if (cb == 0)
+ goto Quit;
+
+ pCL = Imm32HeapAlloc(0, cb);
+ if (pCL == NULL)
+ goto Quit;
+
+ cb = pImeDpi->ImeConversionList(hIMC, pszSrcW, pCL, cb, uFlag);
+ if (cb == 0)
+ goto Quit;
+
+ ret = CandidateListWideToAnsi(pCL, lpDst, dwBufLen, CP_ACP);
+
+Quit:
+ if (pszSrcW)
+ HeapFree(g_hImm32Heap, 0, pszSrcW);
+ if (pCL)
+ HeapFree(g_hImm32Heap, 0, pCL);
+ ImmUnlockImeDpi(pImeDpi);
+ return ret;
+}
+
+/***********************************************************************
+ * ImmGetConversionListW (IMM32.@)
+ */
+DWORD WINAPI
+ImmGetConversionListW(HKL hKL, HIMC hIMC, LPCWSTR pSrc, LPCANDIDATELIST lpDst,
+ DWORD dwBufLen, UINT uFlag)
+{
+ DWORD ret = 0;
+ INT cb;
+ PIMEDPI pImeDpi;
+ LPCANDIDATELIST pCL = NULL;
+ LPSTR pszSrcA = NULL;
+
+ TRACE("(%p, %p, %s, %p, %lu, 0x%lX)\n", hKL, hIMC, debugstr_w(pSrc),
+ lpDst, dwBufLen, uFlag);
+
+ pImeDpi = ImmLockOrLoadImeDpi(hKL);
+ if (!pImeDpi)
+ return 0;
+
+ if (pImeDpi->ImeInfo.fdwProperty & IME_PROP_UNICODE)
+ {
+ ret = pImeDpi->ImeConversionList(hIMC, pSrc, lpDst, dwBufLen, uFlag);
+ ImmUnlockImeDpi(pImeDpi);
+ return ret;
+ }
+
+ if (pSrc)
+ {
+ pszSrcA = Imm32AnsiFromWide(pSrc);
+ if (pszSrcA == NULL)
+ goto Quit;
+ }
+
+ cb = pImeDpi->ImeConversionList(hIMC, pszSrcA, NULL, 0, uFlag);
+ if (cb == 0)
+ goto Quit;
+
+ pCL = Imm32HeapAlloc(0, cb);
+ if (!pCL)
+ goto Quit;
+
+ cb = pImeDpi->ImeConversionList(hIMC, pszSrcA, pCL, cb, uFlag);
+ if (!cb)
+ goto Quit;
+
+ ret = CandidateListAnsiToWide(pCL, lpDst, dwBufLen, CP_ACP);
+
+Quit:
+ if (pszSrcA)
+ HeapFree(g_hImm32Heap, 0, pszSrcA);
+ if (pCL)
+ HeapFree(g_hImm32Heap, 0, pCL);
+ ImmUnlockImeDpi(pImeDpi);
+ return ret;
+}
+
+/***********************************************************************
+ * ImmGetConversionStatus (IMM32.@)
+ */
+BOOL WINAPI ImmGetConversionStatus(HIMC hIMC, LPDWORD lpfdwConversion, LPDWORD
lpfdwSentence)
+{
+ LPINPUTCONTEXT pIC;
+
+ TRACE("(%p %p %p)\n", hIMC, lpfdwConversion, lpfdwSentence);
+
+ pIC = ImmLockIMC(hIMC);
+ if (!pIC)
+ return FALSE;
+
+ if (lpfdwConversion)
+ *lpfdwConversion = pIC->fdwConversion;
+ if (lpfdwSentence)
+ *lpfdwSentence = pIC->fdwSentence;
+
+ ImmUnlockIMC(hIMC);
+ return TRUE;
+}
+
+/***********************************************************************
+ * ImmSetConversionStatus (IMM32.@)
+ */
+BOOL WINAPI ImmSetConversionStatus(HIMC hIMC, DWORD fdwConversion, DWORD fdwSentence)
+{
+ HKL hKL;
+ LPINPUTCONTEXT pIC;
+ DWORD dwOldConversion, dwOldSentence;
+ BOOL fConversionChange = FALSE, fSentenceChange = FALSE;
+ HWND hWnd;
+
+ TRACE("(%p, 0x%lX, 0x%lX)\n", hIMC, fdwConversion, fdwSentence);
+
+ hKL = GetKeyboardLayout(0);
+ if (!IS_IME_HKL(hKL))
+ {
+ if (g_psi && (g_psi->dwSRVIFlags & SRVINFO_CICERO_ENABLED))
+ {
+ FIXME("Cicero\n");
+ return FALSE;
+ }
+ }
+
+ if (Imm32IsCrossThreadAccess(hIMC))
+ return FALSE;
+
+ pIC = ImmLockIMC(hIMC);
+ if (pIC == NULL)
+ return FALSE;
+
+ if (pIC->fdwConversion != fdwConversion)
+ {
+ dwOldConversion = pIC->fdwConversion;
+ pIC->fdwConversion = fdwConversion;
+ fConversionChange = TRUE;
+ }
+
+ if (pIC->fdwSentence != fdwSentence)
+ {
+ dwOldSentence = pIC->fdwSentence;
+ pIC->fdwSentence = fdwSentence;
+ fSentenceChange = TRUE;
+ }
+
+ hWnd = pIC->hWnd;
+ ImmUnlockIMC(hIMC);
+
+ if (fConversionChange)
+ {
+ Imm32NotifyAction(hIMC, hWnd, NI_CONTEXTUPDATED, dwOldConversion,
+ IMC_SETCONVERSIONMODE, IMN_SETCONVERSIONMODE, 0);
+ NtUserNotifyIMEStatus(hWnd, hIMC, fdwConversion);
+ }
+
+ if (fSentenceChange)
+ {
+ Imm32NotifyAction(hIMC, hWnd, NI_CONTEXTUPDATED, dwOldSentence,
+ IMC_SETSENTENCEMODE, IMN_SETSENTENCEMODE, 0);
+ }
+
+ return TRUE;
+}
diff --git a/dll/win32/imm32/imm.c b/dll/win32/imm32/imm.c
index 1dc41f8e362..38dd4b55b57 100644
--- a/dll/win32/imm32/imm.c
+++ b/dll/win32/imm32/imm.c
@@ -10,88 +10,14 @@
* Copyright 2020-2021 Katayama Hirofumi MZ
<katayama.hirofumi.mz(a)gmail.com>
*/
-#include <stdarg.h>
-#include <stdio.h>
-
-#define WIN32_NO_STATUS
-#include <windef.h>
-#include <winbase.h>
-#include <wingdi.h>
-#include <winuser.h>
-#include <winerror.h>
-#include <wine/debug.h>
-#include <imm.h>
-#include <ddk/imm.h>
-#include <winnls.h>
-#include <winreg.h>
-#include <wine/list.h>
-#include <stdlib.h>
-#include <ndk/umtypes.h>
-#include <ndk/pstypes.h>
-#include <ndk/rtlfuncs.h>
-#include "../../../win32ss/include/ntuser.h"
-#include "../../../win32ss/include/ntwin32.h"
-#include <undocuser.h>
-#include <imm32_undoc.h>
-#include <strsafe.h>
+#include "precomp.h"
WINE_DEFAULT_DEBUG_CHANNEL(imm);
-#define IMM_INIT_MAGIC 0x19650412
-#define IMM_INVALID_CANDFORM ULONG_MAX
-#define INVALID_HOTKEY_ID 0xFFFFFFFF
-#define MAX_CANDIDATEFORM 4
-
-#define LANGID_CHINESE_SIMPLIFIED MAKELANGID(LANG_CHINESE, SUBLANG_CHINESE_SIMPLIFIED)
-#define LANGID_CHINESE_TRADITIONAL MAKELANGID(LANG_CHINESE, SUBLANG_CHINESE_TRADITIONAL)
-#define LANGID_JAPANESE MAKELANGID(LANG_JAPANESE, SUBLANG_DEFAULT)
-
-#define REGKEY_KEYBOARD_LAYOUTS \
- L"System\\CurrentControlSet\\Control\\Keyboard Layouts"
-#define REGKEY_IMM \
- L"Software\\Microsoft\\Windows NT\\CurrentVersion\\IMM"
-
-#define ROUNDUP4(n) (((n) + 3) & ~3) /* DWORD alignment */
-
HMODULE g_hImm32Inst = NULL;
-RTL_CRITICAL_SECTION g_csImeDpi;
-PIMEDPI g_pImeDpiList = NULL;
PSERVERINFO g_psi = NULL;
SHAREDINFO g_SharedInfo = { NULL };
BYTE g_bClientRegd = FALSE;
-HANDLE g_hImm32Heap = NULL;
-
-static PWND FASTCALL ValidateHwndNoErr(HWND hwnd)
-{
- PCLIENTINFO ClientInfo = GetWin32ClientInfo();
- INT index;
- PUSER_HANDLE_TABLE ht;
- PUSER_HANDLE_ENTRY he;
- WORD generation;
-
- /* See if the window is cached */
- if (hwnd == ClientInfo->CallbackWnd.hWnd)
- return ClientInfo->CallbackWnd.pWnd;
-
- if (!NtUserValidateHandleSecure(hwnd))
- return NULL;
-
- ht = g_SharedInfo.aheList; /* handle table */
- ASSERT(ht);
- /* ReactOS-Specific! */
- ASSERT(g_SharedInfo.ulSharedDelta != 0);
- he = (PUSER_HANDLE_ENTRY)((ULONG_PTR)ht->handles - g_SharedInfo.ulSharedDelta);
-
- index = (LOWORD(hwnd) - FIRST_USER_HANDLE) >> 1;
- if (index < 0 || index >= ht->nb_handles || he[index].type != TYPE_WINDOW)
- return NULL;
-
- generation = HIWORD(hwnd);
- if (generation != he[index].generation && generation && generation !=
0xFFFF)
- return NULL;
-
- return (PWND)&he[index];
-}
static BOOL APIENTRY Imm32InitInstance(HMODULE hMod)
{
@@ -111,568 +37,15 @@ static BOOL APIENTRY Imm32InitInstance(HMODULE hMod)
return TRUE;
}
-LPVOID APIENTRY Imm32HeapAlloc(DWORD dwFlags, DWORD dwBytes)
-{
- if (!g_hImm32Heap)
- {
- g_hImm32Heap = RtlGetProcessHeap();
- if (g_hImm32Heap == NULL)
- return NULL;
- }
- return HeapAlloc(g_hImm32Heap, dwFlags, dwBytes);
-}
-
-static LPWSTR APIENTRY Imm32WideFromAnsi(LPCSTR pszA)
-{
- INT cch = lstrlenA(pszA);
- LPWSTR pszW = Imm32HeapAlloc(0, (cch + 1) * sizeof(WCHAR));
- if (pszW == NULL)
- return NULL;
- cch = MultiByteToWideChar(CP_ACP, MB_PRECOMPOSED, pszA, cch, pszW, cch + 1);
- pszW[cch] = 0;
- return pszW;
-}
-
-static LPSTR APIENTRY Imm32AnsiFromWide(LPCWSTR pszW)
-{
- INT cchW = lstrlenW(pszW);
- INT cchA = (cchW + 1) * sizeof(WCHAR);
- LPSTR pszA = Imm32HeapAlloc(0, cchA);
- if (!pszA)
- return NULL;
- cchA = WideCharToMultiByte(CP_ACP, 0, pszW, cchW, pszA, cchA, NULL, NULL);
- pszA[cchA] = 0;
- return pszA;
-}
-
-static inline BOOL Imm32IsCrossThreadAccess(HIMC hIMC)
-{
- DWORD dwImeThreadId = NtUserQueryInputContext(hIMC, 1);
- DWORD dwThreadId = GetCurrentThreadId();
- return (dwImeThreadId != dwThreadId);
-}
-
-static BOOL Imm32IsCrossProcessAccess(HWND hWnd)
-{
- return (NtUserQueryWindow(hWnd, QUERY_WINDOW_UNIQUE_PROCESS_ID) !=
- (DWORD_PTR)NtCurrentTeb()->ClientId.UniqueProcess);
-}
-
-static VOID APIENTRY Imm32FreeImeDpi(PIMEDPI pImeDpi, BOOL bDestroy)
-{
- if (pImeDpi->hInst == NULL)
- return;
- if (bDestroy)
- pImeDpi->ImeDestroy(0);
- FreeLibrary(pImeDpi->hInst);
- pImeDpi->hInst = NULL;
-}
-
-static BOOL APIENTRY
-Imm32NotifyAction(HIMC hIMC, HWND hwnd, DWORD dwAction, DWORD_PTR dwIndex, DWORD_PTR
dwValue,
- DWORD_PTR dwCommand, DWORD_PTR dwData)
-{
- DWORD dwLayout;
- HKL hKL;
- PIMEDPI pImeDpi;
-
- if (dwAction)
- {
- dwLayout = NtUserQueryInputContext(hIMC, 1);
- if (dwLayout)
- {
- /* find keyboard layout and lock it */
- hKL = GetKeyboardLayout(dwLayout);
- pImeDpi = ImmLockImeDpi(hKL);
- if (pImeDpi)
- {
- /* do notify */
- pImeDpi->NotifyIME(hIMC, dwAction, dwIndex, dwValue);
-
- ImmUnlockImeDpi(pImeDpi); /* unlock */
- }
- }
- }
-
- if (hwnd && dwCommand)
- SendMessageW(hwnd, WM_IME_NOTIFY, dwCommand, dwData);
-
- return TRUE;
-}
-
-static PIMEDPI APIENTRY Imm32FindImeDpi(HKL hKL)
-{
- PIMEDPI pImeDpi;
-
- RtlEnterCriticalSection(&g_csImeDpi);
- for (pImeDpi = g_pImeDpiList; pImeDpi != NULL; pImeDpi = pImeDpi->pNext)
- {
- if (pImeDpi->hKL == hKL)
- break;
- }
- RtlLeaveCriticalSection(&g_csImeDpi);
-
- return pImeDpi;
-}
-
-static BOOL Imm32GetSystemLibraryPath(LPWSTR pszPath, DWORD cchPath, LPCWSTR
pszFileName)
-{
- if (!pszFileName[0] || !GetSystemDirectoryW(pszPath, cchPath))
- return FALSE;
- StringCchCatW(pszPath, cchPath, L"\\");
- StringCchCatW(pszPath, cchPath, pszFileName);
- return TRUE;
-}
-
-static BOOL APIENTRY Imm32InquireIme(PIMEDPI pImeDpi)
-{
- WCHAR szUIClass[64];
- WNDCLASSW wcW;
- DWORD dwSysInfoFlags = 0; // TODO: ???
- LPIMEINFO pImeInfo = &pImeDpi->ImeInfo;
-
- // TODO: NtUserGetThreadState(16);
-
- if (!IS_IME_HKL(pImeDpi->hKL))
- {
- if (g_psi && (g_psi->dwSRVIFlags & SRVINFO_CICERO_ENABLED)
&&
- pImeDpi->CtfImeInquireExW)
- {
- // TODO:
- return FALSE;
- }
- }
-
- if (!pImeDpi->ImeInquire(pImeInfo, szUIClass, dwSysInfoFlags))
- return FALSE;
-
- szUIClass[_countof(szUIClass) - 1] = 0;
-
- if (pImeInfo->dwPrivateDataSize == 0)
- pImeInfo->dwPrivateDataSize = 4;
-
-#define VALID_IME_PROP (IME_PROP_AT_CARET | \
- IME_PROP_SPECIAL_UI | \
- IME_PROP_CANDLIST_START_FROM_1 | \
- IME_PROP_UNICODE | \
- IME_PROP_COMPLETE_ON_UNSELECT | \
- IME_PROP_END_UNLOAD | \
- IME_PROP_KBD_CHAR_FIRST | \
- IME_PROP_IGNORE_UPKEYS | \
- IME_PROP_NEED_ALTKEY | \
- IME_PROP_NO_KEYS_ON_CLOSE | \
- IME_PROP_ACCEPT_WIDE_VKEY)
-#define VALID_CMODE_CAPS (IME_CMODE_ALPHANUMERIC | \
- IME_CMODE_NATIVE | \
- IME_CMODE_KATAKANA | \
- IME_CMODE_LANGUAGE | \
- IME_CMODE_FULLSHAPE | \
- IME_CMODE_ROMAN | \
- IME_CMODE_CHARCODE | \
- IME_CMODE_HANJACONVERT | \
- IME_CMODE_SOFTKBD | \
- IME_CMODE_NOCONVERSION | \
- IME_CMODE_EUDC | \
- IME_CMODE_SYMBOL | \
- IME_CMODE_FIXED)
-#define VALID_SMODE_CAPS (IME_SMODE_NONE | \
- IME_SMODE_PLAURALCLAUSE | \
- IME_SMODE_SINGLECONVERT | \
- IME_SMODE_AUTOMATIC | \
- IME_SMODE_PHRASEPREDICT | \
- IME_SMODE_CONVERSATION)
-#define VALID_UI_CAPS (UI_CAP_2700 | \
- UI_CAP_ROT90 | \
- UI_CAP_ROTANY | \
- UI_CAP_SOFTKBD)
-#define VALID_SCS_CAPS (SCS_CAP_COMPSTR | \
- SCS_CAP_MAKEREAD | \
- SCS_CAP_SETRECONVERTSTRING)
-#define VALID_SELECT_CAPS (SELECT_CAP_CONVERSION | SELECT_CAP_SENTENCE)
-
- if (pImeInfo->fdwProperty & ~VALID_IME_PROP)
- return FALSE;
- if (pImeInfo->fdwConversionCaps & ~VALID_CMODE_CAPS)
- return FALSE;
- if (pImeInfo->fdwSentenceCaps & ~VALID_SMODE_CAPS)
- return FALSE;
- if (pImeInfo->fdwUICaps & ~VALID_UI_CAPS)
- return FALSE;
- if (pImeInfo->fdwSCSCaps & ~VALID_SCS_CAPS)
- return FALSE;
- if (pImeInfo->fdwSelectCaps & ~VALID_SELECT_CAPS)
- return FALSE;
-
-#undef VALID_IME_PROP
-#undef VALID_CMODE_CAPS
-#undef VALID_SMODE_CAPS
-#undef VALID_UI_CAPS
-#undef VALID_SCS_CAPS
-#undef VALID_SELECT_CAPS
-
- if (pImeInfo->fdwProperty & IME_PROP_UNICODE)
- {
- StringCchCopyW(pImeDpi->szUIClass, _countof(pImeDpi->szUIClass),
szUIClass);
- }
- else
- {
- if (pImeDpi->uCodePage != GetACP() && pImeDpi->uCodePage)
- return FALSE;
-
- MultiByteToWideChar(CP_ACP, MB_PRECOMPOSED, (LPSTR)szUIClass, -1,
- pImeDpi->szUIClass, _countof(pImeDpi->szUIClass));
- }
-
- return GetClassInfoW(pImeDpi->hInst, pImeDpi->szUIClass, &wcW);
-}
-
-static BOOL APIENTRY Imm32LoadImeInfo(PIMEINFOEX pImeInfoEx, PIMEDPI pImeDpi)
-{
- WCHAR szPath[MAX_PATH];
- HINSTANCE hIME;
- FARPROC fn;
-
- if (!Imm32GetSystemLibraryPath(szPath, _countof(szPath), pImeInfoEx->wszImeFile))
- return FALSE;
-
- hIME = GetModuleHandleW(szPath);
- if (hIME == NULL)
- {
- hIME = LoadLibraryW(szPath);
- if (hIME == NULL)
- {
- ERR("Imm32LoadImeInfo: LoadLibraryW(%S) failed\n", szPath);
- return FALSE;
- }
- }
- pImeDpi->hInst = hIME;
-
-#define DEFINE_IME_ENTRY(type, name, params, extended) \
- do { \
- fn = GetProcAddress(hIME, #name); \
- if (fn) pImeDpi->name = (FN_##name)fn; \
- else if (!extended) goto Failed; \
- } while (0);
-#include "../../../win32ss/include/imetable.h"
-#undef DEFINE_IME_ENTRY
-
- if (!Imm32InquireIme(pImeDpi))
- {
- ERR("Imm32LoadImeInfo: Imm32InquireIme failed\n");
- goto Failed;
- }
-
- if (pImeInfoEx->fLoadFlag)
- return TRUE;
-
- NtUserSetImeOwnerWindow(pImeInfoEx, TRUE);
- return TRUE;
-
-Failed:
- FreeLibrary(pImeDpi->hInst);
- pImeDpi->hInst = NULL;
- return FALSE;
-}
-
-#ifdef IMP_SUPPORT /* 3.x support */
-static DWORD APIENTRY
-ImpJTransCompA(LPINPUTCONTEXTDX pIC, LPCOMPOSITIONSTRING pCS,
- const TRANSMSG *pSrc, LPTRANSMSG pDest)
-{
- // FIXME
- *pDest = *pSrc;
- return 1;
-}
-
-static DWORD APIENTRY
-ImpJTransCompW(LPINPUTCONTEXTDX pIC, LPCOMPOSITIONSTRING pCS,
- const TRANSMSG *pSrc, LPTRANSMSG pDest)
-{
- // FIXME
- *pDest = *pSrc;
- return 1;
-}
-
-typedef LRESULT (WINAPI *FN_SendMessage)(HWND, UINT, WPARAM, LPARAM);
-
-static DWORD APIENTRY
-ImpJTrans(DWORD dwCount, LPTRANSMSG pTrans, LPINPUTCONTEXTDX pIC,
- LPCOMPOSITIONSTRING pCS, BOOL bAnsi)
-{
- DWORD ret = 0;
- HWND hWnd, hwndDefIME;
- LPTRANSMSG pTempList, pEntry, pNext;
- DWORD dwIndex, iCandForm, dwNumber, cbTempList;
- HGLOBAL hGlobal;
- CANDIDATEFORM CandForm;
- FN_SendMessage pSendMessage;
-
- hWnd = pIC->hWnd;
- hwndDefIME = ImmGetDefaultIMEWnd(hWnd);
- pSendMessage = (IsWindowUnicode(hWnd) ? SendMessageW : SendMessageA);
-
- // clone the message list
- cbTempList = (dwCount + 1) * sizeof(TRANSMSG);
- pTempList = Imm32HeapAlloc(HEAP_ZERO_MEMORY, cbTempList);
- if (pTempList == NULL)
- return 0;
- RtlCopyMemory(pTempList, pTrans, dwCount * sizeof(TRANSMSG));
-
- if (pIC->dwUIFlags & 0x2)
- {
- // find WM_IME_ENDCOMPOSITION
- pEntry = pTempList;
- for (dwIndex = 0; dwIndex < dwCount; ++dwIndex, ++pEntry)
- {
- if (pEntry->message == WM_IME_ENDCOMPOSITION)
- break;
- }
-
- if (pEntry->message == WM_IME_ENDCOMPOSITION) // if found
- {
- // move WM_IME_ENDCOMPOSITION to the end of the list
- for (pNext = pEntry + 1; pNext->message != 0; ++pEntry, ++pNext)
- *pEntry = *pNext;
-
- pEntry->message = WM_IME_ENDCOMPOSITION;
- pEntry->wParam = 0;
- pEntry->lParam = 0;
- }
- }
-
- for (pEntry = pTempList; pEntry->message != 0; ++pEntry)
- {
- switch (pEntry->message)
- {
- case WM_IME_STARTCOMPOSITION:
- if (!(pIC->dwUIFlags & 0x2))
- {
- // send IR_OPENCONVERT
- if (pIC->cfCompForm.dwStyle != CFS_DEFAULT)
- pSendMessage(hWnd, WM_IME_REPORT, IR_OPENCONVERT, 0);
-
- goto DoDefault;
- }
- break;
-
- case WM_IME_ENDCOMPOSITION:
- if (pIC->dwUIFlags & 0x2)
- {
- // send IR_UNDETERMINE
- hGlobal = GlobalAlloc(GHND | GMEM_SHARE, sizeof(UNDETERMINESTRUCT));
- if (hGlobal)
- {
- pSendMessage(hWnd, WM_IME_REPORT, IR_UNDETERMINE,
(LPARAM)hGlobal);
- GlobalFree(hGlobal);
- }
- }
- else
- {
- // send IR_CLOSECONVERT
- if (pIC->cfCompForm.dwStyle != CFS_DEFAULT)
- pSendMessage(hWnd, WM_IME_REPORT, IR_CLOSECONVERT, 0);
-
- goto DoDefault;
- }
- break;
-
- case WM_IME_COMPOSITION:
- if (bAnsi)
- dwNumber = ImpJTransCompA(pIC, pCS, pEntry, pTrans);
- else
- dwNumber = ImpJTransCompW(pIC, pCS, pEntry, pTrans);
-
- ret += dwNumber;
- pTrans += dwNumber;
-
- // send IR_CHANGECONVERT
- if (!(pIC->dwUIFlags & 0x2))
- {
- if (pIC->cfCompForm.dwStyle != CFS_DEFAULT)
- pSendMessage(hWnd, WM_IME_REPORT, IR_CHANGECONVERT, 0);
- }
- break;
-
- case WM_IME_NOTIFY:
- if (pEntry->wParam == IMN_OPENCANDIDATE)
- {
- if (IsWindow(hWnd) && (pIC->dwUIFlags & 0x2))
- {
- // send IMC_SETCANDIDATEPOS
- for (iCandForm = 0; iCandForm < MAX_CANDIDATEFORM;
++iCandForm)
- {
- if (!(pEntry->lParam & (1 << iCandForm)))
- continue;
-
- CandForm.dwIndex = iCandForm;
- CandForm.dwStyle = CFS_EXCLUDE;
- CandForm.ptCurrentPos = pIC->cfCompForm.ptCurrentPos;
- CandForm.rcArea = pIC->cfCompForm.rcArea;
- pSendMessage(hwndDefIME, WM_IME_CONTROL,
IMC_SETCANDIDATEPOS,
- (LPARAM)&CandForm);
- }
- }
- }
-
- if (!(pIC->dwUIFlags & 0x2))
- goto DoDefault;
-
- // send a WM_IME_NOTIFY notification to the default ime window
- pSendMessage(hwndDefIME, pEntry->message, pEntry->wParam,
pEntry->lParam);
- break;
-
-DoDefault:
- default:
- // default processing
- *pTrans++ = *pEntry;
- ++ret;
- break;
- }
- }
-
- HeapFree(g_hImm32Heap, 0, pTempList);
- return ret;
-}
-
-static DWORD APIENTRY
-ImpKTrans(DWORD dwCount, LPTRANSMSG pEntries, LPINPUTCONTEXTDX pIC,
- LPCOMPOSITIONSTRING pCS, BOOL bAnsi)
-{
- return dwCount; // FIXME
-}
-
-static DWORD APIENTRY
-ImpTrans(DWORD dwCount, LPTRANSMSG pEntries, HIMC hIMC, BOOL bAnsi, WORD wLang)
-{
- BOOL ret = FALSE;
- LPINPUTCONTEXTDX pIC;
- LPCOMPOSITIONSTRING pCS;
-
- pIC = (LPINPUTCONTEXTDX)ImmLockIMC(hIMC);
- if (pIC == NULL)
- return 0;
-
- pCS = ImmLockIMCC(pIC->hCompStr);
- if (pCS)
- {
- if (wLang == LANG_JAPANESE)
- ret = ImpJTrans(dwCount, pEntries, pIC, pCS, bAnsi);
- else if (wLang == LANG_KOREAN)
- ret = ImpKTrans(dwCount, pEntries, pIC, pCS, bAnsi);
- ImmUnlockIMCC(pIC->hCompStr);
- }
-
- ImmUnlockIMC(hIMC);
- return ret;
-}
-#endif /* def IMP_SUPPORT */
-
-static PIMEDPI APIENTRY Ime32LoadImeDpi(HKL hKL, BOOL bLock)
-{
- IMEINFOEX ImeInfoEx;
- CHARSETINFO ci;
- PIMEDPI pImeDpiNew, pImeDpiFound;
- UINT uCodePage;
- LCID lcid;
-
- if (!ImmGetImeInfoEx(&ImeInfoEx, ImeInfoExKeyboardLayout, &hKL) ||
- ImeInfoEx.fLoadFlag == 1)
- {
- return NULL;
- }
-
- pImeDpiNew = Imm32HeapAlloc(HEAP_ZERO_MEMORY, sizeof(IMEDPI));
- if (pImeDpiNew == NULL)
- return NULL;
-
- pImeDpiNew->hKL = hKL;
-
- lcid = LOWORD(hKL);
- if (TranslateCharsetInfo((LPDWORD)(DWORD_PTR)lcid, &ci, TCI_SRCLOCALE))
- uCodePage = ci.ciACP;
- else
- uCodePage = CP_ACP;
- pImeDpiNew->uCodePage = uCodePage;
-
- if (!Imm32LoadImeInfo(&ImeInfoEx, pImeDpiNew))
- {
- HeapFree(g_hImm32Heap, 0, pImeDpiNew);
- return FALSE;
- }
-
- RtlEnterCriticalSection(&g_csImeDpi);
-
- pImeDpiFound = Imm32FindImeDpi(hKL);
- if (pImeDpiFound)
- {
- if (!bLock)
- pImeDpiFound->dwFlags &= ~IMEDPI_FLAG_LOCKED;
-
- RtlLeaveCriticalSection(&g_csImeDpi);
-
- Imm32FreeImeDpi(pImeDpiNew, FALSE);
- HeapFree(g_hImm32Heap, 0, pImeDpiNew);
- return pImeDpiFound;
- }
- else
- {
- if (bLock)
- {
- pImeDpiNew->dwFlags |= IMEDPI_FLAG_LOCKED;
- pImeDpiNew->cLockObj = 1;
- }
-
- pImeDpiNew->pNext = g_pImeDpiList;
- g_pImeDpiList = pImeDpiNew;
-
- RtlLeaveCriticalSection(&g_csImeDpi);
- return pImeDpiNew;
- }
-}
-
/***********************************************************************
- * ImmLoadIME (IMM32.@)
+ * ImmRegisterClient(IMM32.@)
+ * ( Undocumented, called from user32.dll )
*/
-BOOL WINAPI ImmLoadIME(HKL hKL)
-{
- PW32CLIENTINFO pInfo;
- PIMEDPI pImeDpi;
-
- if (!IS_IME_HKL(hKL))
- {
- if (!g_psi || !(g_psi->dwSRVIFlags & SRVINFO_CICERO_ENABLED))
- return FALSE;
-
- pInfo = (PW32CLIENTINFO)(NtCurrentTeb()->Win32ClientInfo);
- if ((pInfo->W32ClientInfo[0] & 2))
- return FALSE;
- }
-
- pImeDpi = Imm32FindImeDpi(hKL);
- if (pImeDpi == NULL)
- pImeDpi = Ime32LoadImeDpi(hKL, FALSE);
- return (pImeDpi != NULL);
-}
-
-PIMEDPI APIENTRY ImmLockOrLoadImeDpi(HKL hKL)
+BOOL WINAPI ImmRegisterClient(PSHAREDINFO ptr, HINSTANCE hMod)
{
- PW32CLIENTINFO pInfo;
- PIMEDPI pImeDpi;
-
- if (!IS_IME_HKL(hKL))
- {
- if (!g_psi || !(g_psi->dwSRVIFlags & SRVINFO_CICERO_ENABLED))
- return NULL;
-
- pInfo = (PW32CLIENTINFO)(NtCurrentTeb()->Win32ClientInfo);
- if ((pInfo->W32ClientInfo[0] & 2))
- return NULL;
- }
-
- pImeDpi = ImmLockImeDpi(hKL);
- if (pImeDpi == NULL)
- pImeDpi = Ime32LoadImeDpi(hKL, TRUE);
- return pImeDpi;
+ g_SharedInfo = *ptr;
+ g_psi = g_SharedInfo.psi;
+ return Imm32InitInstance(hMod);
}
/***********************************************************************
@@ -730,7 +103,8 @@ HKL WINAPI ImmLoadLayout(HKL hKL, PIMEINFOEX pImeInfoEx)
return hKL;
}
-typedef struct _tagImmHkl{
+typedef struct _tagImmHkl
+{
struct list entry;
HKL hkl;
HMODULE hIME;
@@ -760,19 +134,20 @@ typedef struct _tagImmHkl{
typedef struct tagInputContextData
{
- DWORD dwLock;
- INPUTCONTEXT IMC;
- DWORD threadID;
-
- ImmHkl *immKbd;
- UINT lastVK;
- BOOL threadDefault;
- DWORD magic;
+ DWORD dwLock;
+ INPUTCONTEXT IMC;
+ DWORD threadID;
+
+ ImmHkl *immKbd;
+ UINT lastVK;
+ BOOL threadDefault;
+ DWORD magic;
} InputContextData;
#define WINE_IMC_VALID_MAGIC 0x56434D49
-typedef struct _tagIMMThreadData {
+typedef struct _tagIMMThreadData
+{
struct list entry;
DWORD threadID;
HIMC defaultContext;
@@ -790,18 +165,6 @@ static const WCHAR szImeFileW[] =
{'I','m','e','
','F','i','l','e',0};
static const WCHAR szLayoutTextW[] =
{'L','a','y','o','u','t','
','T','e','x','t',0};
static const WCHAR szImeRegFmt[] =
{'S','y','s','t','e','m','\\','C','u','r','r','e','n','t','C','o','n','t','r','o','l','S','e','t','\\','C','o','n','t','r','o','l','\\','K','e','y','b','o','a','r','d','
','L','a','y','o','u','t','s','\\','%','0','8','l','x',0};
-static const WCHAR szwIME[] = {'I','M','E',0};
-static const WCHAR szwDefaultIME[] =
{'D','e','f','a','u','l','t','
','I','M','E',0};
-
-static CRITICAL_SECTION threaddata_cs;
-static CRITICAL_SECTION_DEBUG critsect_debug =
-{
- 0, 0, &threaddata_cs,
- { &critsect_debug.ProcessLocksList, &critsect_debug.ProcessLocksList },
- 0, 0, { (DWORD_PTR)(__FILE__ ": threaddata_cs") }
-};
-static CRITICAL_SECTION threaddata_cs = { &critsect_debug, -1, 0, 0, 0, 0 };
-
static inline BOOL is_himc_ime_unicode(const InputContextData *data)
{
return !!(data->immKbd->imeInfo.fdwProperty & IME_PROP_UNICODE);
@@ -1038,7 +401,6 @@ HIMC WINAPI ImmAssociateContext(HWND hWnd, HIMC hIMC)
return old;
}
-
/*
* Helper function for ImmAssociateContextEx
*/
@@ -1087,8 +449,7 @@ BOOL WINAPI ImmAssociateContextEx(HWND hWnd, HIMC hIMC, DWORD
dwFlags)
/***********************************************************************
* ImmConfigureIMEA (IMM32.@)
*/
-BOOL WINAPI ImmConfigureIMEA(
- HKL hKL, HWND hWnd, DWORD dwMode, LPVOID lpData)
+BOOL WINAPI ImmConfigureIMEA(HKL hKL, HWND hWnd, DWORD dwMode, LPVOID lpData)
{
ImmHkl *immHkl = IMM_GetImmHkl(hKL);
@@ -1122,8 +483,7 @@ BOOL WINAPI ImmConfigureIMEA(
/***********************************************************************
* ImmConfigureIMEW (IMM32.@)
*/
-BOOL WINAPI ImmConfigureIMEW(
- HKL hKL, HWND hWnd, DWORD dwMode, LPVOID lpData)
+BOOL WINAPI ImmConfigureIMEW(HKL hKL, HWND hWnd, DWORD dwMode, LPVOID lpData)
{
ImmHkl *immHkl = IMM_GetImmHkl(hKL);
@@ -1285,232 +645,25 @@ BOOL WINAPI ImmDestroyContext(HIMC hIMC)
return Imm32CleanupContext(hIMC, hKL, FALSE);
}
-/***********************************************************************
- * ImmDisableIME (IMM32.@)
- */
-BOOL WINAPI ImmDisableIME(DWORD dwThreadId)
+static inline BOOL EscapeRequiresWA(UINT uEscape)
{
- return NtUserDisableThreadIme(dwThreadId);
+ if (uEscape == IME_ESC_GET_EUDC_DICTIONARY ||
+ uEscape == IME_ESC_SET_EUDC_DICTIONARY ||
+ uEscape == IME_ESC_IME_NAME ||
+ uEscape == IME_ESC_GETHELPFILENAME)
+ return TRUE;
+ return FALSE;
}
-/*
- * These functions absorb the difference between Ansi and Wide.
+/***********************************************************************
+ * ImmEscapeA (IMM32.@)
*/
-typedef struct ENUM_WORD_A2W
-{
- REGISTERWORDENUMPROCW lpfnEnumProc;
- LPVOID lpData;
- UINT ret;
-} ENUM_WORD_A2W, *LPENUM_WORD_A2W;
-
-typedef struct ENUM_WORD_W2A
-{
- REGISTERWORDENUMPROCA lpfnEnumProc;
- LPVOID lpData;
- UINT ret;
-} ENUM_WORD_W2A, *LPENUM_WORD_W2A;
-
-static INT CALLBACK
-Imm32EnumWordProcA2W(LPCSTR pszReadingA, DWORD dwStyle, LPCSTR pszRegisterA, LPVOID
lpData)
+LRESULT WINAPI ImmEscapeA(HKL hKL, HIMC hIMC, UINT uEscape, LPVOID lpData)
{
- INT ret = 0;
- LPENUM_WORD_A2W lpEnumData = lpData;
- LPWSTR pszReadingW = NULL, pszRegisterW = NULL;
-
- if (pszReadingA)
- {
- pszReadingW = Imm32WideFromAnsi(pszReadingA);
- if (pszReadingW == NULL)
- goto Quit;
- }
+ ImmHkl *immHkl = IMM_GetImmHkl(hKL);
+ TRACE("(%p, %p, %d, %p):\n", hKL, hIMC, uEscape, lpData);
- if (pszRegisterA)
- {
- pszRegisterW = Imm32WideFromAnsi(pszRegisterA);
- if (pszRegisterW == NULL)
- goto Quit;
- }
-
- ret = lpEnumData->lpfnEnumProc(pszReadingW, dwStyle, pszRegisterW,
lpEnumData->lpData);
- lpEnumData->ret = ret;
-
-Quit:
- if (pszReadingW)
- HeapFree(g_hImm32Heap, 0, pszReadingW);
- if (pszRegisterW)
- HeapFree(g_hImm32Heap, 0, pszRegisterW);
- return ret;
-}
-
-static INT CALLBACK
-Imm32EnumWordProcW2A(LPCWSTR pszReadingW, DWORD dwStyle, LPCWSTR pszRegisterW, LPVOID
lpData)
-{
- INT ret = 0;
- LPENUM_WORD_W2A lpEnumData = lpData;
- LPSTR pszReadingA = NULL, pszRegisterA = NULL;
-
- if (pszReadingW)
- {
- pszReadingA = Imm32AnsiFromWide(pszReadingW);
- if (pszReadingW == NULL)
- goto Quit;
- }
-
- if (pszRegisterW)
- {
- pszRegisterA = Imm32AnsiFromWide(pszRegisterW);
- if (pszRegisterA == NULL)
- goto Quit;
- }
-
- ret = lpEnumData->lpfnEnumProc(pszReadingA, dwStyle, pszRegisterA,
lpEnumData->lpData);
- lpEnumData->ret = ret;
-
-Quit:
- if (pszReadingA)
- HeapFree(g_hImm32Heap, 0, pszReadingA);
- if (pszRegisterA)
- HeapFree(g_hImm32Heap, 0, pszRegisterA);
- return ret;
-}
-
-/***********************************************************************
- * ImmEnumRegisterWordA (IMM32.@)
- */
-UINT WINAPI ImmEnumRegisterWordA(
- HKL hKL, REGISTERWORDENUMPROCA lpfnEnumProc,
- LPCSTR lpszReading, DWORD dwStyle,
- LPCSTR lpszRegister, LPVOID lpData)
-{
- UINT ret = 0;
- LPWSTR pszReadingW = NULL, pszRegisterW = NULL;
- ENUM_WORD_W2A EnumDataW2A;
- PIMEDPI pImeDpi;
-
- TRACE("(%p, %p, %s, 0x%lX, %s, %p)", hKL, lpfnEnumProc,
debugstr_a(lpszReading),
- dwStyle, debugstr_a(lpszRegister), lpData);
-
- pImeDpi = ImmLockOrLoadImeDpi(hKL);
- if (!pImeDpi)
- return 0;
-
- if (!(pImeDpi->ImeInfo.fdwProperty & IME_PROP_UNICODE))
- {
- ret = pImeDpi->ImeEnumRegisterWord(lpfnEnumProc, lpszReading, dwStyle,
- lpszRegister, lpData);
- ImmUnlockImeDpi(pImeDpi);
- return ret;
- }
-
- if (lpszReading)
- {
- pszReadingW = Imm32WideFromAnsi(lpszReading);
- if (pszReadingW == NULL)
- goto Quit;
- }
-
- if (lpszRegister)
- {
- pszRegisterW = Imm32WideFromAnsi(lpszRegister);
- if (pszRegisterW == NULL)
- goto Quit;
- }
-
- EnumDataW2A.lpfnEnumProc = lpfnEnumProc;
- EnumDataW2A.lpData = lpData;
- EnumDataW2A.ret = 0;
- pImeDpi->ImeEnumRegisterWord(Imm32EnumWordProcW2A, pszReadingW, dwStyle,
- pszRegisterW, &EnumDataW2A);
- ret = EnumDataW2A.ret;
-
-Quit:
- if (pszReadingW)
- HeapFree(g_hImm32Heap, 0, pszReadingW);
- if (pszRegisterW)
- HeapFree(g_hImm32Heap, 0, pszRegisterW);
- ImmUnlockImeDpi(pImeDpi);
- return ret;
-}
-
-/***********************************************************************
- * ImmEnumRegisterWordW (IMM32.@)
- */
-UINT WINAPI ImmEnumRegisterWordW(
- HKL hKL, REGISTERWORDENUMPROCW lpfnEnumProc,
- LPCWSTR lpszReading, DWORD dwStyle,
- LPCWSTR lpszRegister, LPVOID lpData)
-{
- UINT ret = 0;
- LPSTR pszReadingA = NULL, pszRegisterA = NULL;
- ENUM_WORD_A2W EnumDataA2W;
- PIMEDPI pImeDpi;
-
- TRACE("(%p, %p, %s, 0x%lX, %s, %p)", hKL, lpfnEnumProc,
debugstr_w(lpszReading),
- dwStyle, debugstr_w(lpszRegister), lpData);
-
- pImeDpi = ImmLockOrLoadImeDpi(hKL);
- if (!pImeDpi)
- return 0;
-
- if (pImeDpi->ImeInfo.fdwProperty & IME_PROP_UNICODE)
- {
- ret = pImeDpi->ImeEnumRegisterWord(lpfnEnumProc, lpszReading, dwStyle,
- lpszRegister, lpData);
- ImmUnlockImeDpi(pImeDpi);
- return ret;
- }
-
- if (lpszReading)
- {
- pszReadingA = Imm32AnsiFromWide(lpszReading);
- if (pszReadingA == NULL)
- goto Quit;
- }
-
- if (lpszRegister)
- {
- pszRegisterA = Imm32AnsiFromWide(lpszRegister);
- if (pszRegisterA == NULL)
- goto Quit;
- }
-
- EnumDataA2W.lpfnEnumProc = lpfnEnumProc;
- EnumDataA2W.lpData = lpData;
- EnumDataA2W.ret = 0;
- pImeDpi->ImeEnumRegisterWord(Imm32EnumWordProcA2W, pszReadingA, dwStyle,
- pszRegisterA, &EnumDataA2W);
- ret = EnumDataA2W.ret;
-
-Quit:
- if (pszReadingA)
- HeapFree(g_hImm32Heap, 0, pszReadingA);
- if (pszRegisterA)
- HeapFree(g_hImm32Heap, 0, pszRegisterA);
- ImmUnlockImeDpi(pImeDpi);
- return ret;
-}
-
-static inline BOOL EscapeRequiresWA(UINT uEscape)
-{
- if (uEscape == IME_ESC_GET_EUDC_DICTIONARY ||
- uEscape == IME_ESC_SET_EUDC_DICTIONARY ||
- uEscape == IME_ESC_IME_NAME ||
- uEscape == IME_ESC_GETHELPFILENAME)
- return TRUE;
- return FALSE;
-}
-
-/***********************************************************************
- * ImmEscapeA (IMM32.@)
- */
-LRESULT WINAPI ImmEscapeA(
- HKL hKL, HIMC hIMC,
- UINT uEscape, LPVOID lpData)
-{
- ImmHkl *immHkl = IMM_GetImmHkl(hKL);
- TRACE("(%p, %p, %d, %p):\n", hKL, hIMC, uEscape, lpData);
-
- if (immHkl->hIME && immHkl->pImeEscape)
+ if (immHkl->hIME && immHkl->pImeEscape)
{
if (!EscapeRequiresWA(uEscape) || !is_kbd_ime_unicode(immHkl))
return immHkl->pImeEscape(hIMC,uEscape,lpData);
@@ -1538,9 +691,7 @@ LRESULT WINAPI ImmEscapeA(
/***********************************************************************
* ImmEscapeW (IMM32.@)
*/
-LRESULT WINAPI ImmEscapeW(
- HKL hKL, HIMC hIMC,
- UINT uEscape, LPVOID lpData)
+LRESULT WINAPI ImmEscapeW(HKL hKL, HIMC hIMC, UINT uEscape, LPVOID lpData)
{
ImmHkl *immHkl = IMM_GetImmHkl(hKL);
TRACE("(%p, %p, %d, %p):\n", hKL, hIMC, uEscape, lpData);
@@ -1576,266 +727,6 @@ static PCLIENTIMC APIENTRY Imm32GetClientImcCache(void)
return NULL;
}
-static DWORD APIENTRY Imm32AllocAndBuildHimcList(DWORD dwThreadId, HIMC **pphList)
-{
-#define INITIAL_COUNT 0x40
-#define MAX_RETRY 10
- NTSTATUS Status;
- DWORD dwCount = INITIAL_COUNT, cRetry = 0;
- HIMC *phNewList;
-
- phNewList = Imm32HeapAlloc(0, dwCount * sizeof(HIMC));
- if (phNewList == NULL)
- return 0;
-
- Status = NtUserBuildHimcList(dwThreadId, dwCount, phNewList, &dwCount);
- while (Status == STATUS_BUFFER_TOO_SMALL)
- {
- HeapFree(g_hImm32Heap, 0, phNewList);
- if (cRetry++ >= MAX_RETRY)
- return 0;
-
- phNewList = Imm32HeapAlloc(0, dwCount * sizeof(HIMC));
- if (phNewList == NULL)
- return 0;
-
- Status = NtUserBuildHimcList(dwThreadId, dwCount, phNewList, &dwCount);
- }
-
- if (NT_ERROR(Status) || !dwCount)
- {
- HeapFree(g_hImm32Heap, 0, phNewList);
- return 0;
- }
-
- *pphList = phNewList;
- return dwCount;
-#undef INITIAL_COUNT
-#undef MAX_RETRY
-}
-
-static BOOL APIENTRY Imm32ImeNonImeToggle(HIMC hIMC, HKL hKL, HWND hWnd, LANGID LangID)
-{
- LPINPUTCONTEXT pIC;
- BOOL fOpen;
-
- if (hWnd != NULL)
- return FALSE;
-
- if (!IS_IME_HKL(hKL) || LOWORD(hKL) != LangID)
- {
- FIXME("We have to do something here\n");
- return TRUE;
- }
-
- pIC = ImmLockIMC(hIMC);
- if (pIC == NULL)
- return TRUE;
-
- fOpen = pIC->fOpen;
- ImmUnlockIMC(hIMC);
-
- if (!fOpen)
- {
- ImmSetOpenStatus(hIMC, TRUE);
- return TRUE;
- }
-
- FIXME("We have to do something here\n");
- return TRUE;
-}
-
-static BOOL APIENTRY Imm32CShapeToggle(HIMC hIMC, HKL hKL, HWND hWnd)
-{
- LPINPUTCONTEXT pIC;
- BOOL fOpen;
- DWORD dwConversion, dwSentence;
-
- if (hWnd == NULL || !IS_IME_HKL(hKL))
- return FALSE;
-
- pIC = ImmLockIMC(hIMC);
- if (pIC == NULL)
- return TRUE;
-
- fOpen = pIC->fOpen;
- if (fOpen)
- {
- dwConversion = (pIC->fdwConversion ^ IME_CMODE_FULLSHAPE);
- dwSentence = pIC->fdwSentence;
- }
-
- ImmUnlockIMC(hIMC);
-
- if (fOpen)
- ImmSetConversionStatus(hIMC, dwConversion, dwSentence);
- else
- ImmSetOpenStatus(hIMC, TRUE);
-
- return TRUE;
-}
-
-static BOOL APIENTRY Imm32CSymbolToggle(HIMC hIMC, HKL hKL, HWND hWnd)
-{
- LPINPUTCONTEXT pIC;
- BOOL fOpen;
- DWORD dwConversion, dwSentence;
-
- if (hWnd == NULL || !IS_IME_HKL(hKL))
- return FALSE;
-
- pIC = ImmLockIMC(hIMC);
- if (pIC == NULL)
- return TRUE;
-
- fOpen = pIC->fOpen;
- if (fOpen)
- {
- dwConversion = (pIC->fdwConversion ^ IME_CMODE_SYMBOL);
- dwSentence = pIC->fdwSentence;
- }
-
- ImmUnlockIMC(hIMC);
-
- if (fOpen)
- ImmSetConversionStatus(hIMC, dwConversion, dwSentence);
- else
- ImmSetOpenStatus(hIMC, TRUE);
-
- return TRUE;
-}
-
-static BOOL APIENTRY Imm32JCloseOpen(HIMC hIMC, HKL hKL, HWND hWnd)
-{
- BOOL fOpen;
-
- if (ImmIsIME(hKL) && LOWORD(hKL) == LANGID_JAPANESE)
- {
- fOpen = ImmGetOpenStatus(hIMC);
- ImmSetOpenStatus(hIMC, !fOpen);
- return TRUE;
- }
-
- FIXME("We have to do something here\n");
- return TRUE;
-}
-
-static BOOL APIENTRY Imm32KShapeToggle(HIMC hIMC)
-{
- LPINPUTCONTEXT pIC;
- DWORD dwConversion, dwSentence;
-
- pIC = ImmLockIMC(hIMC);
- if (pIC == NULL)
- return FALSE;
-
- dwConversion = (pIC->fdwConversion ^ IME_CMODE_FULLSHAPE);
- dwSentence = pIC->fdwSentence;
- ImmSetConversionStatus(hIMC, dwConversion, dwSentence);
-
- if (pIC->fdwConversion & (IME_CMODE_FULLSHAPE | IME_CMODE_NATIVE))
- ImmSetOpenStatus(hIMC, TRUE);
- else
- ImmSetOpenStatus(hIMC, FALSE);
-
- ImmUnlockIMC(hIMC);
- return TRUE;
-}
-
-static BOOL APIENTRY Imm32KHanjaConvert(HIMC hIMC)
-{
- LPINPUTCONTEXT pIC;
- DWORD dwConversion, dwSentence;
-
- pIC = ImmLockIMC(hIMC);
- if (!pIC)
- return FALSE;
-
- dwConversion = (pIC->fdwConversion ^ IME_CMODE_HANJACONVERT);
- dwSentence = pIC->fdwSentence;
- ImmUnlockIMC(hIMC);
-
- ImmSetConversionStatus(hIMC, dwConversion, dwSentence);
- return TRUE;
-}
-
-static BOOL APIENTRY Imm32KEnglish(HIMC hIMC)
-{
- LPINPUTCONTEXT pIC;
- DWORD dwConversion, dwSentence;
- BOOL fOpen;
-
- pIC = ImmLockIMC(hIMC);
- if (pIC == NULL)
- return FALSE;
-
- dwConversion = (pIC->fdwConversion ^ IME_CMODE_NATIVE);
- dwSentence = pIC->fdwSentence;
- ImmSetConversionStatus(hIMC, dwConversion, dwSentence);
-
- fOpen = ((pIC->fdwConversion & (IME_CMODE_FULLSHAPE | IME_CMODE_NATIVE)) !=
0);
- ImmSetOpenStatus(hIMC, fOpen);
-
- ImmUnlockIMC(hIMC);
- return TRUE;
-}
-
-static BOOL APIENTRY Imm32ProcessHotKey(HWND hWnd, HIMC hIMC, HKL hKL, DWORD dwHotKeyID)
-{
- PIMEDPI pImeDpi;
- BOOL ret;
-
- if (hIMC && Imm32IsCrossThreadAccess(hIMC))
- return FALSE;
-
- switch (dwHotKeyID)
- {
- case IME_CHOTKEY_IME_NONIME_TOGGLE:
- return Imm32ImeNonImeToggle(hIMC, hKL, hWnd, LANGID_CHINESE_SIMPLIFIED);
-
- case IME_CHOTKEY_SHAPE_TOGGLE:
- return Imm32CShapeToggle(hIMC, hKL, hWnd);
-
- case IME_CHOTKEY_SYMBOL_TOGGLE:
- return Imm32CSymbolToggle(hIMC, hKL, hWnd);
-
- case IME_JHOTKEY_CLOSE_OPEN:
- return Imm32JCloseOpen(hIMC, hKL, hWnd);
-
- case IME_KHOTKEY_SHAPE_TOGGLE:
- return Imm32KShapeToggle(hIMC);
-
- case IME_KHOTKEY_HANJACONVERT:
- return Imm32KHanjaConvert(hIMC);
-
- case IME_KHOTKEY_ENGLISH:
- return Imm32KEnglish(hIMC);
-
- case IME_THOTKEY_IME_NONIME_TOGGLE:
- return Imm32ImeNonImeToggle(hIMC, hKL, hWnd, LANGID_CHINESE_TRADITIONAL);
-
- case IME_THOTKEY_SHAPE_TOGGLE:
- return Imm32CShapeToggle(hIMC, hKL, hWnd);
-
- case IME_THOTKEY_SYMBOL_TOGGLE:
- return Imm32CSymbolToggle(hIMC, hKL, hWnd);
-
- default:
- break;
- }
-
- if (dwHotKeyID < IME_HOTKEY_PRIVATE_FIRST || IME_HOTKEY_PRIVATE_LAST <
dwHotKeyID)
- return FALSE;
-
- pImeDpi = ImmLockImeDpi(hKL);
- if (pImeDpi == NULL)
- return FALSE;
-
- ret = (BOOL)pImeDpi->ImeEscape(hIMC, IME_ESC_PRIVATE_HOTKEY, &dwHotKeyID);
- ImmUnlockImeDpi(pImeDpi);
- return ret;
-}
-
/***********************************************************************
* ImmLockClientImc (IMM32.@)
*/
@@ -1934,671 +825,210 @@ Quit:
return hIMC;
}
-static DWORD APIENTRY
-CandidateListWideToAnsi(const CANDIDATELIST *pWideCL, LPCANDIDATELIST pAnsiCL, DWORD
dwBufLen,
- UINT uCodePage)
+
+/* Helpers for the GetCompositionString functions */
+
+/* Source encoding is defined by context, source length is always given in respective
characters. Destination buffer
+ length is always in bytes. */
+static INT
+CopyCompStringIMEtoClient(const InputContextData *data, const void *src, INT src_len,
void *dst,
+ INT dst_len, BOOL unicode)
{
- BOOL bUsedDefault;
- DWORD dwSize, dwIndex, cbGot, cbLeft;
- const BYTE *pbWide;
- LPBYTE pbAnsi;
- LPDWORD pibOffsets;
-
- /* calculate total ansi size */
- if (pWideCL->dwCount > 0)
+ int char_size = unicode ? sizeof(WCHAR) : sizeof(char);
+ INT ret;
+
+ if (is_himc_ime_unicode(data) ^ unicode)
{
- dwSize = sizeof(CANDIDATELIST) + ((pWideCL->dwCount - 1) * sizeof(DWORD));
- for (dwIndex = 0; dwIndex < pWideCL->dwCount; ++dwIndex)
- {
- pbWide = (const BYTE *)pWideCL + pWideCL->dwOffset[dwIndex];
- cbGot = WideCharToMultiByte(uCodePage, 0, (LPCWSTR)pbWide, -1, NULL, 0,
- NULL, &bUsedDefault);
- dwSize += cbGot;
- }
+ if (unicode)
+ ret = MultiByteToWideChar(CP_ACP, 0, src, src_len, dst, dst_len /
sizeof(WCHAR));
+ else
+ ret = WideCharToMultiByte(CP_ACP, 0, src, src_len, dst, dst_len, NULL,
NULL);
+ ret *= char_size;
}
else
{
- dwSize = sizeof(CANDIDATELIST);
+ if (dst_len)
+ {
+ ret = min(src_len * char_size, dst_len);
+ memcpy(dst, src, ret);
+ }
+ else
+ ret = src_len * char_size;
}
- dwSize = ROUNDUP4(dwSize);
- if (dwBufLen == 0)
- return dwSize;
- if (dwBufLen < dwSize)
- return 0;
-
- /* store to ansi */
- pAnsiCL->dwSize = dwBufLen;
- pAnsiCL->dwStyle = pWideCL->dwStyle;
- pAnsiCL->dwCount = pWideCL->dwCount;
- pAnsiCL->dwSelection = pWideCL->dwSelection;
- pAnsiCL->dwPageStart = pWideCL->dwPageStart;
- pAnsiCL->dwPageSize = pWideCL->dwPageSize;
+ return ret;
+}
- pibOffsets = pAnsiCL->dwOffset;
- if (pWideCL->dwCount > 0)
+/* Composition string encoding is defined by context, returned attributes correspond to
string, converted according to
+ passed mode. String length is in characters, attributes are in byte arrays. */
+static INT
+CopyCompAttrIMEtoClient(const InputContextData *data, const BYTE *src, INT src_len, const
void *comp_string,
+ INT str_len, BYTE *dst, INT dst_len, BOOL unicode)
+{
+ union
{
- pibOffsets[0] = sizeof(CANDIDATELIST) + ((pWideCL->dwCount - 1) *
sizeof(DWORD));
- cbLeft = dwBufLen - pibOffsets[0];
-
- for (dwIndex = 0; dwIndex < pWideCL->dwCount; ++dwIndex)
- {
- pbWide = (const BYTE *)pWideCL + pWideCL->dwOffset[dwIndex];
- pbAnsi = (LPBYTE)pAnsiCL + pibOffsets[dwIndex];
+ const void *str;
+ const WCHAR *strW;
+ const char *strA;
+ } string;
+ INT rc;
- /* convert to ansi */
- cbGot = WideCharToMultiByte(uCodePage, 0, (LPCWSTR)pbWide, -1,
- (LPSTR)pbAnsi, cbLeft, NULL, &bUsedDefault);
- cbLeft -= cbGot;
+ string.str = comp_string;
- if (dwIndex < pWideCL->dwCount - 1)
- pibOffsets[dwIndex + 1] = pibOffsets[dwIndex] + cbGot;
- }
- }
- else
+ if (is_himc_ime_unicode(data) && !unicode)
{
- pibOffsets[0] = sizeof(CANDIDATELIST);
- }
+ rc = WideCharToMultiByte(CP_ACP, 0, string.strW, str_len, NULL, 0, NULL, NULL);
+ if (dst_len)
+ {
+ int i, j = 0, k = 0;
- return dwBufLen;
-}
+ if (rc < dst_len)
+ dst_len = rc;
+ for (i = 0; i < str_len; ++i)
+ {
+ int len;
-static DWORD APIENTRY
-CandidateListAnsiToWide(const CANDIDATELIST *pAnsiCL, LPCANDIDATELIST pWideCL, DWORD
dwBufLen,
- UINT uCodePage)
-{
- DWORD dwSize, dwIndex, cchGot, cbGot, cbLeft;
- const BYTE *pbAnsi;
- LPBYTE pbWide;
- LPDWORD pibOffsets;
+ len = WideCharToMultiByte(CP_ACP, 0, string.strW + i, 1, NULL, 0, NULL,
NULL);
+ for (; len > 0; --len)
+ {
+ dst[j++] = src[k];
- /* calculate total wide size */
- if (pAnsiCL->dwCount > 0)
- {
- dwSize = sizeof(CANDIDATELIST) + ((pAnsiCL->dwCount - 1) * sizeof(DWORD));
- for (dwIndex = 0; dwIndex < pAnsiCL->dwCount; ++dwIndex)
- {
- pbAnsi = (const BYTE *)pAnsiCL + pAnsiCL->dwOffset[dwIndex];
- cchGot = MultiByteToWideChar(uCodePage, MB_PRECOMPOSED, (LPCSTR)pbAnsi, -1,
NULL, 0);
- dwSize += cchGot * sizeof(WCHAR);
+ if (j >= dst_len)
+ goto end;
+ }
+ ++k;
+ }
+ end:
+ rc = j;
}
}
- else
- {
- dwSize = sizeof(CANDIDATELIST);
- }
-
- dwSize = ROUNDUP4(dwSize);
- if (dwBufLen == 0)
- return dwSize;
- if (dwBufLen < dwSize)
- return 0;
-
- /* store to wide */
- pWideCL->dwSize = dwBufLen;
- pWideCL->dwStyle = pAnsiCL->dwStyle;
- pWideCL->dwCount = pAnsiCL->dwCount;
- pWideCL->dwSelection = pAnsiCL->dwSelection;
- pWideCL->dwPageStart = pAnsiCL->dwPageStart;
- pWideCL->dwPageSize = pAnsiCL->dwPageSize;
-
- pibOffsets = pWideCL->dwOffset;
- if (pAnsiCL->dwCount > 0)
+ else if (!is_himc_ime_unicode(data) && unicode)
{
- pibOffsets[0] = sizeof(CANDIDATELIST) + ((pWideCL->dwCount - 1) *
sizeof(DWORD));
- cbLeft = dwBufLen - pibOffsets[0];
-
- for (dwIndex = 0; dwIndex < pAnsiCL->dwCount; ++dwIndex)
+ rc = MultiByteToWideChar(CP_ACP, 0, string.strA, str_len, NULL, 0);
+ if (dst_len)
{
- pbAnsi = (const BYTE *)pAnsiCL + pAnsiCL->dwOffset[dwIndex];
- pbWide = (LPBYTE)pWideCL + pibOffsets[dwIndex];
+ int i, j = 0;
+
+ if (rc < dst_len)
+ dst_len = rc;
+ for (i = 0; i < str_len; ++i)
+ {
+ if (IsDBCSLeadByte(string.strA[i]))
+ continue;
- /* convert to wide */
- cchGot = MultiByteToWideChar(uCodePage, MB_PRECOMPOSED, (LPCSTR)pbAnsi, -1,
- (LPWSTR)pbWide, cbLeft / sizeof(WCHAR));
- cbGot = cchGot * sizeof(WCHAR);
- cbLeft -= cbGot;
+ dst[j++] = src[i];
- if (dwIndex + 1 < pAnsiCL->dwCount)
- pibOffsets[dwIndex + 1] = pibOffsets[dwIndex] + cbGot;
+ if (j >= dst_len)
+ break;
+ }
+ rc = j;
}
}
else
{
- pibOffsets[0] = sizeof(CANDIDATELIST);
+ memcpy(dst, src, min(src_len, dst_len));
+ rc = src_len;
}
- return dwBufLen;
+ return rc;
}
-static DWORD APIENTRY
-ImmGetCandidateListAW(HIMC hIMC, DWORD dwIndex, LPCANDIDATELIST lpCandList, DWORD
dwBufLen,
- BOOL bAnsi)
+static INT
+CopyCompClauseIMEtoClient(InputContextData *data, LPBYTE source, INT slen, LPBYTE
ssource,
+ LPBYTE target, INT tlen, BOOL unicode )
{
- DWORD ret = 0;
- LPINPUTCONTEXT pIC;
- PCLIENTIMC pClientImc;
- LPCANDIDATEINFO pCI;
- LPCANDIDATELIST pCL;
- DWORD dwSize;
-
- pClientImc = ImmLockClientImc(hIMC);
- if (!pClientImc)
- return 0;
-
- pIC = ImmLockIMC(hIMC);
- if (pIC == NULL)
- {
- ImmUnlockClientImc(pClientImc);
- return 0;
- }
-
- pCI = ImmLockIMCC(pIC->hCandInfo);
- if (pCI == NULL)
- {
- ImmUnlockIMC(hIMC);
- ImmUnlockClientImc(pClientImc);
- return 0;
- }
-
- if (pCI->dwSize < sizeof(CANDIDATEINFO) || pCI->dwCount <= dwIndex)
- goto Quit;
-
- /* get required size */
- pCL = (LPCANDIDATELIST)((LPBYTE)pCI + pCI->dwOffset[dwIndex]);
- if (bAnsi)
- {
- if (pClientImc->dwFlags & CLIENTIMC_WIDE)
- dwSize = CandidateListAnsiToWide(pCL, NULL, 0, CP_ACP);
- else
- dwSize = pCL->dwSize;
- }
- else
- {
- if (pClientImc->dwFlags & CLIENTIMC_WIDE)
- dwSize = pCL->dwSize;
- else
- dwSize = CandidateListWideToAnsi(pCL, NULL, 0, CP_ACP);
- }
+ INT rc;
- if (dwBufLen != 0 && dwSize != 0)
+ if (is_himc_ime_unicode(data) && !unicode)
{
- if (lpCandList == NULL || dwBufLen < dwSize)
- goto Quit;
-
- /* store */
- if (bAnsi)
+ if (tlen)
{
- if (pClientImc->dwFlags & CLIENTIMC_WIDE)
- CandidateListAnsiToWide(pCL, lpCandList, dwSize, CP_ACP);
- else
- RtlCopyMemory(lpCandList, pCL, dwSize);
+ int i;
+
+ if (slen < tlen)
+ tlen = slen;
+ tlen /= sizeof (DWORD);
+ for (i = 0; i < tlen; ++i)
+ {
+ ((DWORD *)target)[i] = WideCharToMultiByte(CP_ACP, 0, (LPWSTR)ssource,
+ ((DWORD *)source)[i],
+ NULL, 0,
+ NULL, NULL);
+ }
+ rc = sizeof (DWORD) * i;
}
else
- {
- if (pClientImc->dwFlags & CLIENTIMC_WIDE)
- RtlCopyMemory(lpCandList, pCL, dwSize);
- else
- CandidateListWideToAnsi(pCL, lpCandList, dwSize, CP_ACP);
- }
- }
-
- ret = dwSize;
-
-Quit:
- ImmUnlockIMCC(pIC->hCandInfo);
- ImmUnlockIMC(hIMC);
- ImmUnlockClientImc(pClientImc);
- return ret;
-}
-
-DWORD APIENTRY ImmGetCandidateListCountAW(HIMC hIMC, LPDWORD lpdwListCount, BOOL bAnsi)
-{
- DWORD ret = 0, cbGot, dwIndex;
- PCLIENTIMC pClientImc;
- LPINPUTCONTEXT pIC;
- const CANDIDATEINFO *pCI;
- const BYTE *pb;
- const CANDIDATELIST *pCL;
- const DWORD *pdwOffsets;
-
- if (lpdwListCount == NULL)
- return 0;
-
- *lpdwListCount = 0;
-
- pClientImc = ImmLockClientImc(hIMC);
- if (pClientImc == NULL)
- return 0;
-
- pIC = ImmLockIMC(hIMC);
- if (pIC == NULL)
- {
- ImmUnlockClientImc(pClientImc);
- return 0;
- }
-
- pCI = ImmLockIMCC(pIC->hCandInfo);
- if (pCI == NULL)
- {
- ImmUnlockIMC(hIMC);
- ImmUnlockClientImc(pClientImc);
- return 0;
+ rc = slen;
}
-
- if (pCI->dwSize < sizeof(CANDIDATEINFO))
- goto Quit;
-
- *lpdwListCount = pCI->dwCount; /* the number of candidate lists */
-
- /* calculate total size of candidate lists */
- if (bAnsi)
+ else if (!is_himc_ime_unicode(data) && unicode)
{
- if (pClientImc->dwFlags & CLIENTIMC_WIDE)
+ if (tlen)
{
- ret = ROUNDUP4(pCI->dwPrivateSize);
- pdwOffsets = pCI->dwOffset;
- for (dwIndex = 0; dwIndex < pCI->dwCount; ++dwIndex)
+ int i;
+
+ if (slen < tlen)
+ tlen = slen;
+ tlen /= sizeof (DWORD);
+ for (i = 0; i < tlen; ++i)
{
- pb = (const BYTE *)pCI + pdwOffsets[dwIndex];
- pCL = (const CANDIDATELIST *)pb;
- cbGot = CandidateListWideToAnsi(pCL, NULL, 0, CP_ACP);
- ret += cbGot;
+ ((DWORD *)target)[i] = MultiByteToWideChar(CP_ACP, 0, (LPSTR)ssource,
+ ((DWORD *)source)[i],
+ NULL, 0);
}
+ rc = sizeof (DWORD) * i;
}
else
- {
- ret = pCI->dwSize;
- }
+ rc = slen;
}
else
{
- if (pClientImc->dwFlags & CLIENTIMC_WIDE)
- {
- ret = pCI->dwSize;
- }
- else
- {
- ret = ROUNDUP4(pCI->dwPrivateSize);
- pdwOffsets = pCI->dwOffset;
- for (dwIndex = 0; dwIndex < pCI->dwCount; ++dwIndex)
- {
- pb = (const BYTE *)pCI + pdwOffsets[dwIndex];
- pCL = (const CANDIDATELIST *)pb;
- cbGot = CandidateListAnsiToWide(pCL, NULL, 0, CP_ACP);
- ret += cbGot;
- }
- }
+ memcpy( target, source, min(slen,tlen));
+ rc = slen;
}
-Quit:
- ImmUnlockIMCC(pIC->hCandInfo);
- ImmUnlockIMC(hIMC);
- ImmUnlockClientImc(pClientImc);
- return ret;
-}
-
-/***********************************************************************
- * ImmGetCandidateListA (IMM32.@)
- */
-DWORD WINAPI ImmGetCandidateListA(
- HIMC hIMC, DWORD dwIndex,
- LPCANDIDATELIST lpCandList, DWORD dwBufLen)
-{
- return ImmGetCandidateListAW(hIMC, dwIndex, lpCandList, dwBufLen, TRUE);
-}
-
-/***********************************************************************
- * ImmGetCandidateListCountA (IMM32.@)
- */
-DWORD WINAPI ImmGetCandidateListCountA(
- HIMC hIMC, LPDWORD lpdwListCount)
-{
- return ImmGetCandidateListCountAW(hIMC, lpdwListCount, TRUE);
-}
-
-/***********************************************************************
- * ImmGetCandidateListCountW (IMM32.@)
- */
-DWORD WINAPI ImmGetCandidateListCountW(
- HIMC hIMC, LPDWORD lpdwListCount)
-{
- return ImmGetCandidateListCountAW(hIMC, lpdwListCount, FALSE);
-}
-
-/***********************************************************************
- * ImmGetCandidateListW (IMM32.@)
- */
-DWORD WINAPI ImmGetCandidateListW(
- HIMC hIMC, DWORD dwIndex,
- LPCANDIDATELIST lpCandList, DWORD dwBufLen)
-{
- return ImmGetCandidateListAW(hIMC, dwIndex, lpCandList, dwBufLen, FALSE);
+ return rc;
}
-/***********************************************************************
- * ImmGetCandidateWindow (IMM32.@)
- */
-BOOL WINAPI ImmGetCandidateWindow(
- HIMC hIMC, DWORD dwIndex, LPCANDIDATEFORM lpCandidate)
+static INT
+CopyCompOffsetIMEtoClient(InputContextData *data, DWORD offset, LPBYTE ssource, BOOL
unicode)
{
- BOOL ret = FALSE;
- LPINPUTCONTEXT pIC;
- LPCANDIDATEFORM pCF;
-
- TRACE("(%p, %lu, %p)\n", hIMC, dwIndex, lpCandidate);
-
- pIC = ImmLockIMC(hIMC);
- if (pIC == NULL)
- return FALSE;
+ int rc;
- pCF = &pIC->cfCandForm[dwIndex];
- if (pCF->dwIndex != IMM_INVALID_CANDFORM)
+ if (is_himc_ime_unicode(data) && !unicode)
{
- *lpCandidate = *pCF;
- ret = TRUE;
+ rc = WideCharToMultiByte(CP_ACP, 0, (LPWSTR)ssource, offset, NULL, 0, NULL,
NULL);
}
+ else if (!is_himc_ime_unicode(data) && unicode)
+ {
+ rc = MultiByteToWideChar(CP_ACP, 0, (LPSTR)ssource, offset, NULL, 0);
+ }
+ else
+ rc = offset;
- ImmUnlockIMC(hIMC);
- return ret;
-}
-
-static VOID APIENTRY LogFontAnsiToWide(const LOGFONTA *plfA, LPLOGFONTW plfW)
-{
- size_t cch;
- RtlCopyMemory(plfW, plfA, offsetof(LOGFONTA, lfFaceName));
- StringCchLengthA(plfA->lfFaceName, _countof(plfA->lfFaceName), &cch);
- cch = MultiByteToWideChar(CP_ACP, MB_PRECOMPOSED, plfA->lfFaceName, (INT)cch,
- plfW->lfFaceName, _countof(plfW->lfFaceName));
- if (cch > _countof(plfW->lfFaceName) - 1)
- cch = _countof(plfW->lfFaceName) - 1;
- plfW->lfFaceName[cch] = 0;
-}
-
-static VOID APIENTRY LogFontWideToAnsi(const LOGFONTW *plfW, LPLOGFONTA plfA)
-{
- size_t cch;
- RtlCopyMemory(plfA, plfW, offsetof(LOGFONTW, lfFaceName));
- StringCchLengthW(plfW->lfFaceName, _countof(plfW->lfFaceName), &cch);
- cch = WideCharToMultiByte(CP_ACP, 0, plfW->lfFaceName, (INT)cch,
- plfA->lfFaceName, _countof(plfA->lfFaceName), NULL,
NULL);
- if (cch > _countof(plfA->lfFaceName) - 1)
- cch = _countof(plfA->lfFaceName) - 1;
- plfA->lfFaceName[cch] = 0;
+ return rc;
}
-/***********************************************************************
- * ImmGetCompositionFontA (IMM32.@)
- */
-BOOL WINAPI ImmGetCompositionFontA(HIMC hIMC, LPLOGFONTA lplf)
+static LONG
+ImmGetCompositionStringT(HIMC hIMC, DWORD dwIndex, LPVOID lpBuf,
+ DWORD dwBufLen, BOOL unicode)
{
- PCLIENTIMC pClientImc;
- BOOL ret = FALSE, bWide;
- LPINPUTCONTEXT pIC;
+ LONG rc = 0;
+ InputContextData *data = get_imc_data(hIMC);
+ LPCOMPOSITIONSTRING compstr;
+ LPBYTE compdata;
- TRACE("(%p, %p)\n", hIMC, lplf);
+ TRACE("(%p, 0x%x, %p, %d)\n", hIMC, dwIndex, lpBuf, dwBufLen);
- pClientImc = ImmLockClientImc(hIMC);
- if (pClientImc == NULL)
- return FALSE;
+ if (!data)
+ return FALSE;
- bWide = (pClientImc->dwFlags & CLIENTIMC_WIDE);
- ImmUnlockClientImc(pClientImc);
+ if (!data->IMC.hCompStr)
+ return FALSE;
- pIC = ImmLockIMC(hIMC);
- if (pIC == NULL)
- return FALSE;
+ compdata = ImmLockIMCC(data->IMC.hCompStr);
+ compstr = (LPCOMPOSITIONSTRING)compdata;
- if (pIC->fdwInit & INIT_LOGFONT)
- {
- if (bWide)
- LogFontWideToAnsi(&pIC->lfFont.W, lplf);
- else
- *lplf = pIC->lfFont.A;
-
- ret = TRUE;
- }
-
- ImmUnlockIMC(hIMC);
- return ret;
-}
-
-/***********************************************************************
- * ImmGetCompositionFontW (IMM32.@)
- */
-BOOL WINAPI ImmGetCompositionFontW(HIMC hIMC, LPLOGFONTW lplf)
-{
- PCLIENTIMC pClientImc;
- BOOL bWide;
- LPINPUTCONTEXT pIC;
- BOOL ret = FALSE;
-
- TRACE("(%p, %p)\n", hIMC, lplf);
-
- pClientImc = ImmLockClientImc(hIMC);
- if (pClientImc == NULL)
- return FALSE;
-
- bWide = (pClientImc->dwFlags & CLIENTIMC_WIDE);
- ImmUnlockClientImc(pClientImc);
-
- pIC = ImmLockIMC(hIMC);
- if (pIC == NULL)
- return FALSE;
-
- if (pIC->fdwInit & INIT_LOGFONT)
- {
- if (bWide)
- *lplf = pIC->lfFont.W;
- else
- LogFontAnsiToWide(&pIC->lfFont.A, lplf);
-
- ret = TRUE;
- }
-
- ImmUnlockIMC(hIMC);
- return ret;
-}
-
-
-/* Helpers for the GetCompositionString functions */
-
-/* Source encoding is defined by context, source length is always given in respective
characters. Destination buffer
- length is always in bytes. */
-static INT CopyCompStringIMEtoClient(const InputContextData *data, const void *src, INT
src_len, void *dst,
- INT dst_len, BOOL unicode)
-{
- int char_size = unicode ? sizeof(WCHAR) : sizeof(char);
- INT ret;
-
- if (is_himc_ime_unicode(data) ^ unicode)
- {
- if (unicode)
- ret = MultiByteToWideChar(CP_ACP, 0, src, src_len, dst, dst_len /
sizeof(WCHAR));
- else
- ret = WideCharToMultiByte(CP_ACP, 0, src, src_len, dst, dst_len, NULL,
NULL);
- ret *= char_size;
- }
- else
- {
- if (dst_len)
- {
- ret = min(src_len * char_size, dst_len);
- memcpy(dst, src, ret);
- }
- else
- ret = src_len * char_size;
- }
-
- return ret;
-}
-
-/* Composition string encoding is defined by context, returned attributes correspond to
string, converted according to
- passed mode. String length is in characters, attributes are in byte arrays. */
-static INT CopyCompAttrIMEtoClient(const InputContextData *data, const BYTE *src, INT
src_len, const void *comp_string,
- INT str_len, BYTE *dst, INT dst_len, BOOL unicode)
-{
- union
- {
- const void *str;
- const WCHAR *strW;
- const char *strA;
- } string;
- INT rc;
-
- string.str = comp_string;
-
- if (is_himc_ime_unicode(data) && !unicode)
- {
- rc = WideCharToMultiByte(CP_ACP, 0, string.strW, str_len, NULL, 0, NULL, NULL);
- if (dst_len)
- {
- int i, j = 0, k = 0;
-
- if (rc < dst_len)
- dst_len = rc;
- for (i = 0; i < str_len; ++i)
- {
- int len;
-
- len = WideCharToMultiByte(CP_ACP, 0, string.strW + i, 1, NULL, 0, NULL,
NULL);
- for (; len > 0; --len)
- {
- dst[j++] = src[k];
-
- if (j >= dst_len)
- goto end;
- }
- ++k;
- }
- end:
- rc = j;
- }
- }
- else if (!is_himc_ime_unicode(data) && unicode)
- {
- rc = MultiByteToWideChar(CP_ACP, 0, string.strA, str_len, NULL, 0);
- if (dst_len)
- {
- int i, j = 0;
-
- if (rc < dst_len)
- dst_len = rc;
- for (i = 0; i < str_len; ++i)
- {
- if (IsDBCSLeadByte(string.strA[i]))
- continue;
-
- dst[j++] = src[i];
-
- if (j >= dst_len)
- break;
- }
- rc = j;
- }
- }
- else
- {
- memcpy(dst, src, min(src_len, dst_len));
- rc = src_len;
- }
-
- return rc;
-}
-
-static INT CopyCompClauseIMEtoClient(InputContextData *data, LPBYTE source, INT slen,
LPBYTE ssource,
- LPBYTE target, INT tlen, BOOL unicode )
-{
- INT rc;
-
- if (is_himc_ime_unicode(data) && !unicode)
- {
- if (tlen)
- {
- int i;
-
- if (slen < tlen)
- tlen = slen;
- tlen /= sizeof (DWORD);
- for (i = 0; i < tlen; ++i)
- {
- ((DWORD *)target)[i] = WideCharToMultiByte(CP_ACP, 0, (LPWSTR)ssource,
- ((DWORD *)source)[i],
- NULL, 0,
- NULL, NULL);
- }
- rc = sizeof (DWORD) * i;
- }
- else
- rc = slen;
- }
- else if (!is_himc_ime_unicode(data) && unicode)
- {
- if (tlen)
- {
- int i;
-
- if (slen < tlen)
- tlen = slen;
- tlen /= sizeof (DWORD);
- for (i = 0; i < tlen; ++i)
- {
- ((DWORD *)target)[i] = MultiByteToWideChar(CP_ACP, 0, (LPSTR)ssource,
- ((DWORD *)source)[i],
- NULL, 0);
- }
- rc = sizeof (DWORD) * i;
- }
- else
- rc = slen;
- }
- else
- {
- memcpy( target, source, min(slen,tlen));
- rc = slen;
- }
-
- return rc;
-}
-
-static INT CopyCompOffsetIMEtoClient(InputContextData *data, DWORD offset, LPBYTE
ssource, BOOL unicode)
-{
- int rc;
-
- if (is_himc_ime_unicode(data) && !unicode)
- {
- rc = WideCharToMultiByte(CP_ACP, 0, (LPWSTR)ssource, offset, NULL, 0, NULL,
NULL);
- }
- else if (!is_himc_ime_unicode(data) && unicode)
- {
- rc = MultiByteToWideChar(CP_ACP, 0, (LPSTR)ssource, offset, NULL, 0);
- }
- else
- rc = offset;
-
- return rc;
-}
-
-static LONG ImmGetCompositionStringT( HIMC hIMC, DWORD dwIndex, LPVOID lpBuf,
- DWORD dwBufLen, BOOL unicode)
-{
- LONG rc = 0;
- InputContextData *data = get_imc_data(hIMC);
- LPCOMPOSITIONSTRING compstr;
- LPBYTE compdata;
-
- TRACE("(%p, 0x%x, %p, %d)\n", hIMC, dwIndex, lpBuf, dwBufLen);
-
- if (!data)
- return FALSE;
-
- if (!data->IMC.hCompStr)
- return FALSE;
-
- compdata = ImmLockIMCC(data->IMC.hCompStr);
- compstr = (LPCOMPOSITIONSTRING)compdata;
-
- switch (dwIndex)
+ switch (dwIndex)
{
case GCS_RESULTSTR:
TRACE("GCS_RESULTSTR\n");
@@ -2673,47 +1103,19 @@ static LONG ImmGetCompositionStringT( HIMC hIMC, DWORD dwIndex,
LPVOID lpBuf,
/***********************************************************************
* ImmGetCompositionStringA (IMM32.@)
*/
-LONG WINAPI ImmGetCompositionStringA(
- HIMC hIMC, DWORD dwIndex, LPVOID lpBuf, DWORD dwBufLen)
+LONG WINAPI ImmGetCompositionStringA(HIMC hIMC, DWORD dwIndex, LPVOID lpBuf, DWORD
dwBufLen)
{
return ImmGetCompositionStringT(hIMC, dwIndex, lpBuf, dwBufLen, FALSE);
}
-
/***********************************************************************
* ImmGetCompositionStringW (IMM32.@)
*/
-LONG WINAPI ImmGetCompositionStringW(
- HIMC hIMC, DWORD dwIndex,
- LPVOID lpBuf, DWORD dwBufLen)
+LONG WINAPI ImmGetCompositionStringW(HIMC hIMC, DWORD dwIndex, LPVOID lpBuf, DWORD
dwBufLen)
{
return ImmGetCompositionStringT(hIMC, dwIndex, lpBuf, dwBufLen, TRUE);
}
-/***********************************************************************
- * ImmGetCompositionWindow (IMM32.@)
- */
-BOOL WINAPI ImmGetCompositionWindow(HIMC hIMC, LPCOMPOSITIONFORM lpCompForm)
-{
- LPINPUTCONTEXT pIC;
- BOOL ret = FALSE;
-
- TRACE("(%p, %p)\n", hIMC, lpCompForm);
-
- pIC = ImmLockIMC(hIMC);
- if (!pIC)
- return FALSE;
-
- if (pIC->fdwInit & INIT_COMPFORM)
- {
- *lpCompForm = pIC->cfCompForm;
- ret = TRUE;
- }
-
- ImmUnlockIMC(hIMC);
- return ret;
-}
-
/***********************************************************************
* ImmGetContext (IMM32.@)
*/
@@ -2726,1806 +1128,96 @@ HIMC WINAPI ImmGetContext(HWND hWnd)
}
/***********************************************************************
- * ImmGetConversionListA (IMM32.@)
+ * CtfImmIsCiceroEnabled (IMM32.@)
*/
-DWORD WINAPI ImmGetConversionListA(
- HKL hKL, HIMC hIMC,
- LPCSTR pSrc, LPCANDIDATELIST lpDst,
- DWORD dwBufLen, UINT uFlag)
+BOOL WINAPI CtfImmIsCiceroEnabled(VOID)
{
- DWORD ret = 0;
- UINT cb;
- LPWSTR pszSrcW = NULL;
- LPCANDIDATELIST pCL = NULL;
- PIMEDPI pImeDpi;
-
- TRACE("(%p, %p, %s, %p, %lu, 0x%lX)\n", hKL, hIMC, debugstr_a(pSrc),
- lpDst, dwBufLen, uFlag);
-
- pImeDpi = ImmLockOrLoadImeDpi(hKL);
- if (pImeDpi == NULL)
- return 0;
+ return (g_psi && (g_psi->dwSRVIFlags & SRVINFO_CICERO_ENABLED));
+}
- if (!(pImeDpi->ImeInfo.fdwProperty & IME_PROP_UNICODE))
- {
- ret = pImeDpi->ImeConversionList(hIMC, pSrc, lpDst, dwBufLen, uFlag);
- ImmUnlockImeDpi(pImeDpi);
- return ret;
- }
+/***********************************************************************
+ * ImmInstallIMEA (IMM32.@)
+ */
+HKL WINAPI ImmInstallIMEA(LPCSTR lpszIMEFileName, LPCSTR lpszLayoutText)
+{
+ HKL hKL = NULL;
+ LPWSTR pszFileNameW = NULL, pszLayoutTextW = NULL;
- if (pSrc)
- {
- pszSrcW = Imm32WideFromAnsi(pSrc);
- if (pszSrcW == NULL)
- goto Quit;
- }
+ TRACE("(%s, %s)\n", debugstr_a(lpszIMEFileName),
debugstr_a(lpszLayoutText));
- cb = pImeDpi->ImeConversionList(hIMC, pszSrcW, NULL, 0, uFlag);
- if (cb == 0)
+ pszFileNameW = Imm32WideFromAnsi(lpszIMEFileName);
+ if (pszFileNameW == NULL)
goto Quit;
- pCL = Imm32HeapAlloc(0, cb);
- if (pCL == NULL)
+ pszLayoutTextW = Imm32WideFromAnsi(lpszLayoutText);
+ if (pszLayoutTextW == NULL)
goto Quit;
- cb = pImeDpi->ImeConversionList(hIMC, pszSrcW, pCL, cb, uFlag);
- if (cb == 0)
- goto Quit;
-
- ret = CandidateListWideToAnsi(pCL, lpDst, dwBufLen, CP_ACP);
-
-Quit:
- if (pszSrcW)
- HeapFree(g_hImm32Heap, 0, pszSrcW);
- if (pCL)
- HeapFree(g_hImm32Heap, 0, pCL);
- ImmUnlockImeDpi(pImeDpi);
- return ret;
-}
-
-/***********************************************************************
- * ImmGetConversionListW (IMM32.@)
- */
-DWORD WINAPI ImmGetConversionListW(
- HKL hKL, HIMC hIMC,
- LPCWSTR pSrc, LPCANDIDATELIST lpDst,
- DWORD dwBufLen, UINT uFlag)
-{
- DWORD ret = 0;
- INT cb;
- PIMEDPI pImeDpi;
- LPCANDIDATELIST pCL = NULL;
- LPSTR pszSrcA = NULL;
-
- TRACE("(%p, %p, %s, %p, %lu, 0x%lX)\n", hKL, hIMC, debugstr_w(pSrc),
- lpDst, dwBufLen, uFlag);
-
- pImeDpi = ImmLockOrLoadImeDpi(hKL);
- if (!pImeDpi)
- return 0;
-
- if (pImeDpi->ImeInfo.fdwProperty & IME_PROP_UNICODE)
- {
- ret = pImeDpi->ImeConversionList(hIMC, pSrc, lpDst, dwBufLen, uFlag);
- ImmUnlockImeDpi(pImeDpi);
- return ret;
- }
-
- if (pSrc)
- {
- pszSrcA = Imm32AnsiFromWide(pSrc);
- if (pszSrcA == NULL)
- goto Quit;
- }
-
- cb = pImeDpi->ImeConversionList(hIMC, pszSrcA, NULL, 0, uFlag);
- if (cb == 0)
- goto Quit;
-
- pCL = Imm32HeapAlloc(0, cb);
- if (!pCL)
- goto Quit;
-
- cb = pImeDpi->ImeConversionList(hIMC, pszSrcA, pCL, cb, uFlag);
- if (!cb)
- goto Quit;
-
- ret = CandidateListAnsiToWide(pCL, lpDst, dwBufLen, CP_ACP);
-
-Quit:
- if (pszSrcA)
- HeapFree(g_hImm32Heap, 0, pszSrcA);
- if (pCL)
- HeapFree(g_hImm32Heap, 0, pCL);
- ImmUnlockImeDpi(pImeDpi);
- return ret;
-}
-
-/***********************************************************************
- * ImmGetConversionStatus (IMM32.@)
- */
-BOOL WINAPI ImmGetConversionStatus(
- HIMC hIMC, LPDWORD lpfdwConversion, LPDWORD lpfdwSentence)
-{
- LPINPUTCONTEXT pIC;
-
- TRACE("(%p %p %p)\n", hIMC, lpfdwConversion, lpfdwSentence);
-
- pIC = ImmLockIMC(hIMC);
- if (!pIC)
- return FALSE;
-
- if (lpfdwConversion)
- *lpfdwConversion = pIC->fdwConversion;
- if (lpfdwSentence)
- *lpfdwSentence = pIC->fdwSentence;
-
- ImmUnlockIMC(hIMC);
- return TRUE;
-}
-
-/***********************************************************************
- * ImmGetDefaultIMEWnd (IMM32.@)
- */
-HWND WINAPI ImmGetDefaultIMEWnd(HWND hWnd)
-{
- if (!g_psi || !(g_psi->dwSRVIFlags & SRVINFO_IMM32))
- return NULL;
-
- // FIXME: NtUserGetThreadState and enum ThreadStateRoutines are broken.
- if (hWnd == NULL)
- return (HWND)NtUserGetThreadState(3);
-
- return (HWND)NtUserQueryWindow(hWnd, QUERY_WINDOW_DEFAULT_IME);
-}
-
-/***********************************************************************
- * CtfImmIsCiceroEnabled (IMM32.@)
- */
-BOOL WINAPI CtfImmIsCiceroEnabled(VOID)
-{
- return (g_psi && (g_psi->dwSRVIFlags & SRVINFO_CICERO_ENABLED));
-}
-
-/***********************************************************************
- * ImmGetDescriptionA (IMM32.@)
- */
-UINT WINAPI ImmGetDescriptionA(
- HKL hKL, LPSTR lpszDescription, UINT uBufLen)
-{
- IMEINFOEX info;
- size_t cch;
-
- TRACE("(%p,%p,%d)\n", hKL, lpszDescription, uBufLen);
-
- if (!ImmGetImeInfoEx(&info, ImeInfoExKeyboardLayout, &hKL) ||
!IS_IME_HKL(hKL))
- return 0;
-
- StringCchLengthW(info.wszImeDescription, _countof(info.wszImeDescription),
&cch);
- cch = WideCharToMultiByte(CP_ACP, 0, info.wszImeDescription, (INT)cch,
- lpszDescription, uBufLen, NULL, NULL);
- if (uBufLen)
- lpszDescription[cch] = 0;
- return (UINT)cch;
-}
-
-/***********************************************************************
- * ImmGetDescriptionW (IMM32.@)
- */
-UINT WINAPI ImmGetDescriptionW(HKL hKL, LPWSTR lpszDescription, UINT uBufLen)
-{
- IMEINFOEX info;
- size_t cch;
-
- TRACE("(%p, %p, %d)\n", hKL, lpszDescription, uBufLen);
-
- if (!ImmGetImeInfoEx(&info, ImeInfoExKeyboardLayout, &hKL) ||
!IS_IME_HKL(hKL))
- return 0;
-
- if (uBufLen != 0)
- StringCchCopyW(lpszDescription, uBufLen, info.wszImeDescription);
-
- StringCchLengthW(info.wszImeDescription, _countof(info.wszImeDescription),
&cch);
- return (UINT)cch;
-}
-
-static DWORD APIENTRY
-ImmGetGuideLineAW(HIMC hIMC, DWORD dwIndex, LPVOID lpBuf, DWORD dwBufLen, BOOL bAnsi)
-{
- PCLIENTIMC pClientImc;
- LPINPUTCONTEXT pIC;
- LPGUIDELINE pGuideLine;
- DWORD cb, ret = 0;
- LPVOID pvStr, pvPrivate;
- BOOL bUsedDefault;
-
- pClientImc = ImmLockClientImc(hIMC);
- if (!pClientImc)
- return 0;
-
- pIC = ImmLockIMC(hIMC);
- if (!pIC)
- {
- ImmUnlockClientImc(pClientImc);
- return 0;
- }
-
- pGuideLine = ImmLockIMCC(pIC->hGuideLine);
- if (!pGuideLine)
- {
- ImmUnlockIMC(hIMC);
- ImmUnlockClientImc(pClientImc);
- return 0;
- }
-
- if (dwIndex == GGL_LEVEL)
- {
- ret = pGuideLine->dwLevel;
- goto Quit;
- }
-
- if (dwIndex == GGL_INDEX)
- {
- ret = pGuideLine->dwIndex;
- goto Quit;
- }
-
- if (dwIndex == GGL_STRING)
- {
- pvStr = (LPBYTE)pGuideLine + pGuideLine->dwStrOffset;
-
- /* get size */
- if (bAnsi)
- {
- if (pClientImc->dwFlags & CLIENTIMC_WIDE)
- {
- cb = WideCharToMultiByte(CP_ACP, 0, pvStr, pGuideLine->dwStrLen,
- NULL, 0, NULL, &bUsedDefault);
- }
- else
- {
- cb = pGuideLine->dwStrLen * sizeof(CHAR);
- }
- }
- else
- {
- if (pClientImc->dwFlags & CLIENTIMC_WIDE)
- {
- cb = pGuideLine->dwStrLen * sizeof(WCHAR);
- }
- else
- {
- cb = MultiByteToWideChar(CP_ACP, MB_PRECOMPOSED, pvStr,
pGuideLine->dwStrLen,
- NULL, 0) * sizeof(WCHAR);
- }
- }
-
- if (dwBufLen == 0 || cb == 0 || lpBuf == NULL || dwBufLen < cb)
- {
- ret = cb;
- goto Quit;
- }
-
- /* store to buffer */
- if (bAnsi)
- {
- if (pClientImc->dwFlags & CLIENTIMC_WIDE)
- {
- ret = WideCharToMultiByte(CP_ACP, 0, pvStr, pGuideLine->dwStrLen,
- lpBuf, dwBufLen, NULL, &bUsedDefault);
- goto Quit;
- }
- }
- else
- {
- if (!(pClientImc->dwFlags & CLIENTIMC_WIDE))
- {
- ret = MultiByteToWideChar(CP_ACP, MB_PRECOMPOSED, pvStr,
pGuideLine->dwStrLen,
- lpBuf, dwBufLen) * sizeof(WCHAR);
- goto Quit;
- }
- }
-
- RtlCopyMemory(lpBuf, pvStr, cb);
- ret = cb;
- goto Quit;
- }
-
- if (dwIndex == GGL_PRIVATE)
- {
- pvPrivate = (LPBYTE)pGuideLine + pGuideLine->dwPrivateOffset;
-
- /* get size */
- if (bAnsi)
- {
- if ((pClientImc->dwFlags & CLIENTIMC_WIDE) &&
- pGuideLine->dwIndex == GL_ID_REVERSECONVERSION)
- {
- cb = CandidateListWideToAnsi(pvPrivate, NULL, 0, CP_ACP);
- }
- else
- {
- cb = pGuideLine->dwPrivateSize;
- }
- }
- else
- {
- if (!(pClientImc->dwFlags & CLIENTIMC_WIDE) &&
- pGuideLine->dwIndex == GL_ID_REVERSECONVERSION)
- {
- cb = CandidateListAnsiToWide(pvPrivate, NULL, 0, CP_ACP);
- }
- else
- {
- cb = pGuideLine->dwPrivateSize;
- }
- }
-
- if (dwBufLen == 0 || cb == 0 || lpBuf == NULL || dwBufLen < cb)
- {
- ret = cb;
- goto Quit;
- }
-
- /* store to buffer */
- if (bAnsi)
- {
- if ((pClientImc->dwFlags & CLIENTIMC_WIDE) &&
- pGuideLine->dwIndex == GL_ID_REVERSECONVERSION)
- {
- ret = CandidateListWideToAnsi(pvPrivate, lpBuf, cb, CP_ACP);
- goto Quit;
- }
- }
- else
- {
- if (!(pClientImc->dwFlags & CLIENTIMC_WIDE) &&
- pGuideLine->dwIndex == GL_ID_REVERSECONVERSION)
- {
- ret = CandidateListAnsiToWide(pvPrivate, lpBuf, cb, CP_ACP);
- goto Quit;
- }
- }
-
- RtlCopyMemory(lpBuf, pvPrivate, cb);
- ret = cb;
- goto Quit;
- }
-
-Quit:
- ImmUnlockIMCC(pIC->hGuideLine);
- ImmUnlockIMC(hIMC);
- ImmUnlockClientImc(pClientImc);
- return ret;
-}
-
-/***********************************************************************
- * ImmGetGuideLineA (IMM32.@)
- */
-DWORD WINAPI ImmGetGuideLineA(
- HIMC hIMC, DWORD dwIndex, LPSTR lpBuf, DWORD dwBufLen)
-{
- TRACE("(%p, %lu, %p, %lu)\n", hIMC, dwIndex, lpBuf, dwBufLen);
- return ImmGetGuideLineAW(hIMC, dwIndex, lpBuf, dwBufLen, TRUE);
-}
-
-/***********************************************************************
- * ImmGetGuideLineW (IMM32.@)
- */
-DWORD WINAPI ImmGetGuideLineW(HIMC hIMC, DWORD dwIndex, LPWSTR lpBuf, DWORD dwBufLen)
-{
- TRACE("(%p, %lu, %p, %lu)\n", hIMC, dwIndex, lpBuf, dwBufLen);
- return ImmGetGuideLineAW(hIMC, dwIndex, lpBuf, dwBufLen, FALSE);
-}
-
-/***********************************************************************
- * ImmGetIMEFileNameA (IMM32.@)
- */
-UINT WINAPI ImmGetIMEFileNameA( HKL hKL, LPSTR lpszFileName, UINT uBufLen)
-{
- BOOL bDefUsed;
- IMEINFOEX info;
- size_t cch;
-
- TRACE("(%p, %p, %u)\n", hKL, lpszFileName, uBufLen);
-
- if (!ImmGetImeInfoEx(&info, ImeInfoExKeyboardLayout, &hKL) ||
!IS_IME_HKL(hKL))
- {
- if (uBufLen > 0)
- lpszFileName[0] = 0;
- return 0;
- }
-
- StringCchLengthW(info.wszImeFile, _countof(info.wszImeFile), &cch);
-
- cch = WideCharToMultiByte(CP_ACP, 0, info.wszImeFile, (INT)cch,
- lpszFileName, uBufLen, NULL, &bDefUsed);
- if (uBufLen == 0)
- return (UINT)cch;
-
- if (cch > uBufLen - 1)
- cch = uBufLen - 1;
-
- lpszFileName[cch] = 0;
- return (UINT)cch;
-}
-
-/***********************************************************************
- * ImmGetIMEFileNameW (IMM32.@)
- */
-UINT WINAPI ImmGetIMEFileNameW(HKL hKL, LPWSTR lpszFileName, UINT uBufLen)
-{
- IMEINFOEX info;
- size_t cch;
-
- TRACE("(%p, %p, %u)\n", hKL, lpszFileName, uBufLen);
-
- if (!ImmGetImeInfoEx(&info, ImeInfoExKeyboardLayout, &hKL) ||
!IS_IME_HKL(hKL))
- {
- if (uBufLen > 0)
- lpszFileName[0] = 0;
- return 0;
- }
-
- StringCchLengthW(info.wszImeFile, _countof(info.wszImeFile), &cch);
- if (uBufLen == 0)
- return (UINT)cch;
-
- StringCchCopyNW(lpszFileName, uBufLen, info.wszImeFile, cch);
-
- if (cch > uBufLen - 1)
- cch = uBufLen - 1;
-
- lpszFileName[cch] = 0;
- return (UINT)cch;
-}
-
-/***********************************************************************
- * ImmGetOpenStatus (IMM32.@)
- */
-BOOL WINAPI ImmGetOpenStatus(HIMC hIMC)
-{
- BOOL ret;
- LPINPUTCONTEXT pIC;
-
- TRACE("(%p)\n", hIMC);
-
- if (!hIMC)
- return FALSE;
-
- pIC = ImmLockIMC(hIMC);
- if (!pIC)
- return FALSE;
-
- ret = pIC->fOpen;
-
- ImmUnlockIMC(hIMC);
- return ret;
-}
-
-/***********************************************************************
- * ImmGetProperty (IMM32.@)
- */
-DWORD WINAPI ImmGetProperty(HKL hKL, DWORD fdwIndex)
-{
- IMEINFOEX ImeInfoEx;
- LPIMEINFO pImeInfo;
- DWORD dwValue;
- PIMEDPI pImeDpi = NULL;
-
- TRACE("(%p, %lu)\n", hKL, fdwIndex);
-
- if (!ImmGetImeInfoEx(&ImeInfoEx, ImeInfoExKeyboardLayout, &hKL))
- return FALSE;
-
- if (fdwIndex == IGP_GETIMEVERSION)
- return ImeInfoEx.dwImeWinVersion;
-
- if (ImeInfoEx.fLoadFlag != 2)
- {
- pImeDpi = ImmLockOrLoadImeDpi(hKL);
- if (pImeDpi == NULL)
- return FALSE;
-
- pImeInfo = &pImeDpi->ImeInfo;
- }
- else
- {
- pImeInfo = &ImeInfoEx.ImeInfo;
- }
-
- switch (fdwIndex)
- {
- case IGP_PROPERTY: dwValue = pImeInfo->fdwProperty; break;
- case IGP_CONVERSION: dwValue = pImeInfo->fdwConversionCaps; break;
- case IGP_SENTENCE: dwValue = pImeInfo->fdwSentenceCaps; break;
- case IGP_UI: dwValue = pImeInfo->fdwUICaps; break;
- case IGP_SETCOMPSTR: dwValue = pImeInfo->fdwSCSCaps; break;
- case IGP_SELECT: dwValue = pImeInfo->fdwSelectCaps; break;
- default: dwValue = 0; break;
- }
-
- if (pImeDpi)
- ImmUnlockImeDpi(pImeDpi);
- return dwValue;
-}
-
-/***********************************************************************
- * ImmGetRegisterWordStyleA (IMM32.@)
- */
-UINT WINAPI ImmGetRegisterWordStyleA(
- HKL hKL, UINT nItem, LPSTYLEBUFA lpStyleBuf)
-{
- UINT iItem, ret = 0;
- PIMEDPI pImeDpi;
- LPSTYLEBUFA pDestA;
- LPSTYLEBUFW pSrcW, pNewStylesW = NULL;
- size_t cchW;
- INT cchA;
-
- TRACE("(%p, %u, %p)\n", hKL, nItem, lpStyleBuf);
-
- pImeDpi = ImmLockOrLoadImeDpi(hKL);
- if (!pImeDpi)
- return 0;
-
- if (!(pImeDpi->ImeInfo.fdwProperty & IME_PROP_UNICODE))
- {
- ret = pImeDpi->ImeGetRegisterWordStyle(nItem, lpStyleBuf);
- goto Quit;
- }
-
- if (nItem > 0)
- {
- pNewStylesW = Imm32HeapAlloc(0, nItem * sizeof(STYLEBUFW));
- if (!pNewStylesW)
- goto Quit;
- }
-
- ret = pImeDpi->ImeGetRegisterWordStyle(nItem, pNewStylesW);
-
- if (nItem > 0)
- {
- /* lpStyleBuf <-- pNewStylesW */
- for (iItem = 0; iItem < ret; ++iItem)
- {
- pSrcW = &pNewStylesW[iItem];
- pDestA = &lpStyleBuf[iItem];
- pDestA->dwStyle = pSrcW->dwStyle;
- StringCchLengthW(pSrcW->szDescription, _countof(pSrcW->szDescription),
&cchW);
- cchA = WideCharToMultiByte(CP_ACP, MB_PRECOMPOSED,
- pSrcW->szDescription, (INT)cchW,
- pDestA->szDescription,
_countof(pDestA->szDescription),
- NULL, NULL);
- if (cchA > _countof(pDestA->szDescription) - 1)
- cchA = _countof(pDestA->szDescription) - 1;
- pDestA->szDescription[cchA] = 0;
- }
- }
-
-Quit:
- if (pNewStylesW)
- HeapFree(g_hImm32Heap, 0, pNewStylesW);
- ImmUnlockImeDpi(pImeDpi);
- return ret;
-}
-
-/***********************************************************************
- * ImmGetRegisterWordStyleW (IMM32.@)
- */
-UINT WINAPI ImmGetRegisterWordStyleW(
- HKL hKL, UINT nItem, LPSTYLEBUFW lpStyleBuf)
-{
- UINT iItem, ret = 0;
- PIMEDPI pImeDpi;
- LPSTYLEBUFA pSrcA, pNewStylesA = NULL;
- LPSTYLEBUFW pDestW;
- size_t cchA;
- INT cchW;
-
- TRACE("(%p, %u, %p)\n", hKL, nItem, lpStyleBuf);
-
- pImeDpi = ImmLockOrLoadImeDpi(hKL);
- if (!pImeDpi)
- return 0;
-
- if (pImeDpi->ImeInfo.fdwProperty & IME_PROP_UNICODE)
- {
- ret = pImeDpi->ImeGetRegisterWordStyle(nItem, lpStyleBuf);
- goto Quit;
- }
-
- if (nItem > 0)
- {
- pNewStylesA = Imm32HeapAlloc(0, nItem * sizeof(STYLEBUFA));
- if (!pNewStylesA)
- goto Quit;
- }
-
- ret = pImeDpi->ImeGetRegisterWordStyle(nItem, pNewStylesA);
-
- if (nItem > 0)
- {
- /* lpStyleBuf <-- pNewStylesA */
- for (iItem = 0; iItem < ret; ++iItem)
- {
- pSrcA = &pNewStylesA[iItem];
- pDestW = &lpStyleBuf[iItem];
- pDestW->dwStyle = pSrcA->dwStyle;
- StringCchLengthA(pSrcA->szDescription, _countof(pSrcA->szDescription),
&cchA);
- cchW = MultiByteToWideChar(CP_ACP, MB_PRECOMPOSED,
- pSrcA->szDescription, (INT)cchA,
- pDestW->szDescription,
_countof(pDestW->szDescription));
- if (cchW > _countof(pDestW->szDescription) - 1)
- cchW = _countof(pDestW->szDescription) - 1;
- pDestW->szDescription[cchW] = 0;
- }
- }
-
-Quit:
- if (pNewStylesA)
- HeapFree(g_hImm32Heap, 0, pNewStylesA);
- ImmUnlockImeDpi(pImeDpi);
- return ret;
-}
-
-/***********************************************************************
- * ImmGetStatusWindowPos (IMM32.@)
- */
-BOOL WINAPI ImmGetStatusWindowPos(HIMC hIMC, LPPOINT lpptPos)
-{
- LPINPUTCONTEXT pIC;
- BOOL ret;
-
- TRACE("(%p, %p)\n", hIMC, lpptPos);
-
- pIC = ImmLockIMC(hIMC);
- if (pIC == NULL)
- return FALSE;
-
- ret = !!(pIC->fdwInit & INIT_STATUSWNDPOS);
- if (ret)
- *lpptPos = pIC->ptStatusWndPos;
-
- ImmUnlockIMC(hIMC);
- return ret;
-}
-
-/***********************************************************************
- * ImmGetVirtualKey (IMM32.@)
- */
-UINT WINAPI ImmGetVirtualKey(HWND hWnd)
-{
- HIMC hIMC;
- LPINPUTCONTEXTDX pIC;
- UINT ret = VK_PROCESSKEY;
-
- TRACE("(%p)\n", hWnd);
-
- hIMC = ImmGetContext(hWnd);
- pIC = (LPINPUTCONTEXTDX)ImmLockIMC(hIMC);
- if (!pIC)
- return ret;
-
- if (pIC->bNeedsTrans)
- ret = pIC->nVKey;
-
- ImmUnlockIMC(hIMC);
- return ret;
-}
-
-/***********************************************************************
- * ImmInstallIMEA (IMM32.@)
- */
-HKL WINAPI ImmInstallIMEA(
- LPCSTR lpszIMEFileName, LPCSTR lpszLayoutText)
-{
- HKL hKL = NULL;
- LPWSTR pszFileNameW = NULL, pszLayoutTextW = NULL;
-
- TRACE("(%s, %s)\n", debugstr_a(lpszIMEFileName),
debugstr_a(lpszLayoutText));
-
- pszFileNameW = Imm32WideFromAnsi(lpszIMEFileName);
- if (pszFileNameW == NULL)
- goto Quit;
-
- pszLayoutTextW = Imm32WideFromAnsi(lpszLayoutText);
- if (pszLayoutTextW == NULL)
- goto Quit;
-
- hKL = ImmInstallIMEW(pszFileNameW, pszLayoutTextW);
-
-Quit:
- if (pszFileNameW)
- HeapFree(g_hImm32Heap, 0, pszFileNameW);
- if (pszLayoutTextW)
- HeapFree(g_hImm32Heap, 0, pszLayoutTextW);
- return hKL;
-}
-
-/***********************************************************************
- * ImmInstallIMEW (IMM32.@)
- */
-HKL WINAPI ImmInstallIMEW(
- LPCWSTR lpszIMEFileName, LPCWSTR lpszLayoutText)
-{
- INT lcid = GetUserDefaultLCID();
- INT count;
- HKL hkl;
- DWORD rc;
- HKEY hkey;
- WCHAR regKey[ARRAY_SIZE(szImeRegFmt)+8];
-
- TRACE ("(%s, %s):\n", debugstr_w(lpszIMEFileName),
- debugstr_w(lpszLayoutText));
-
- /* Start with 2. e001 will be blank and so default to the wine internal IME */
- count = 2;
-
- while (count < 0xfff)
- {
- DWORD disposition = 0;
-
- hkl = (HKL)MAKELPARAM( lcid, 0xe000 | count );
- wsprintfW( regKey, szImeRegFmt, (ULONG_PTR)hkl);
-
- rc = RegCreateKeyExW(HKEY_LOCAL_MACHINE, regKey, 0, NULL, 0, KEY_WRITE, NULL,
&hkey, &disposition);
- if (rc == ERROR_SUCCESS && disposition == REG_CREATED_NEW_KEY)
- break;
- else if (rc == ERROR_SUCCESS)
- RegCloseKey(hkey);
-
- count++;
- }
-
- if (count == 0xfff)
- {
- WARN("Unable to find slot to install IME\n");
- return 0;
- }
-
- if (rc == ERROR_SUCCESS)
- {
- rc = RegSetValueExW(hkey, szImeFileW, 0, REG_SZ, (const BYTE*)lpszIMEFileName,
- (lstrlenW(lpszIMEFileName) + 1) * sizeof(WCHAR));
- if (rc == ERROR_SUCCESS)
- rc = RegSetValueExW(hkey, szLayoutTextW, 0, REG_SZ, (const
BYTE*)lpszLayoutText,
- (lstrlenW(lpszLayoutText) + 1) * sizeof(WCHAR));
- RegCloseKey(hkey);
- return hkl;
- }
- else
- {
- WARN("Unable to set IME registry values\n");
- return 0;
- }
-}
-
-/***********************************************************************
- * ImmIsIME (IMM32.@)
- */
-BOOL WINAPI ImmIsIME(HKL hKL)
-{
- IMEINFOEX info;
- TRACE("(%p)\n", hKL);
- return !!ImmGetImeInfoEx(&info, ImeInfoExImeWindow, &hKL);
-}
-
-static BOOL APIENTRY
-ImmIsUIMessageAW(HWND hWndIME, UINT msg, WPARAM wParam, LPARAM lParam, BOOL bAnsi)
-{
- switch (msg)
- {
- case WM_IME_STARTCOMPOSITION: case WM_IME_ENDCOMPOSITION:
- case WM_IME_COMPOSITION: case WM_IME_SETCONTEXT: case WM_IME_NOTIFY:
- case WM_IME_COMPOSITIONFULL: case WM_IME_SELECT: case WM_IME_SYSTEM:
- break;
- default:
- return FALSE;
- }
-
- if (!hWndIME)
- return TRUE;
-
- if (bAnsi)
- SendMessageA(hWndIME, msg, wParam, lParam);
- else
- SendMessageW(hWndIME, msg, wParam, lParam);
-
- return TRUE;
-}
-
-/***********************************************************************
- * ImmIsUIMessageA (IMM32.@)
- */
-BOOL WINAPI ImmIsUIMessageA(
- HWND hWndIME, UINT msg, WPARAM wParam, LPARAM lParam)
-{
- TRACE("(%p, 0x%X, %p, %p)\n", hWndIME, msg, wParam, lParam);
- return ImmIsUIMessageAW(hWndIME, msg, wParam, lParam, TRUE);
-}
-
-/***********************************************************************
- * ImmIsUIMessageW (IMM32.@)
- */
-BOOL WINAPI ImmIsUIMessageW(
- HWND hWndIME, UINT msg, WPARAM wParam, LPARAM lParam)
-{
- TRACE("(%p, 0x%X, %p, %p)\n", hWndIME, msg, wParam, lParam);
- return ImmIsUIMessageAW(hWndIME, msg, wParam, lParam, FALSE);
-}
-
-/***********************************************************************
- * ImmNotifyIME (IMM32.@)
- */
-BOOL WINAPI ImmNotifyIME(
- HIMC hIMC, DWORD dwAction, DWORD dwIndex, DWORD dwValue)
-{
- HKL hKL;
- PIMEDPI pImeDpi;
- BOOL ret;
-
- TRACE("(%p, %lu, %lu, %lu)\n", hIMC, dwAction, dwIndex, dwValue);
-
- if (hIMC && Imm32IsCrossThreadAccess(hIMC))
- return FALSE;
-
- hKL = GetKeyboardLayout(0);
- pImeDpi = ImmLockImeDpi(hKL);
- if (pImeDpi == NULL)
- return FALSE;
-
- ret = pImeDpi->NotifyIME(hIMC, dwAction, dwIndex, dwValue);
- ImmUnlockImeDpi(pImeDpi);
- return ret;
-}
-
-/***********************************************************************
- * ImmRegisterWordA (IMM32.@)
- */
-BOOL WINAPI ImmRegisterWordA(
- HKL hKL, LPCSTR lpszReading, DWORD dwStyle, LPCSTR lpszRegister)
-{
- BOOL ret = FALSE;
- PIMEDPI pImeDpi;
- LPWSTR pszReadingW = NULL, pszRegisterW = NULL;
-
- TRACE("(%p, %s, 0x%lX, %s)\n", hKL, debugstr_a(lpszReading), dwStyle,
- debugstr_a(lpszRegister));
-
- pImeDpi = ImmLockOrLoadImeDpi(hKL);
- if (!pImeDpi)
- return FALSE;
-
- if (!(pImeDpi->ImeInfo.fdwProperty & IME_PROP_UNICODE))
- {
- ret = pImeDpi->ImeRegisterWord(lpszReading, dwStyle, lpszRegister);
- ImmUnlockImeDpi(pImeDpi);
- return ret;
- }
-
- if (lpszReading)
- {
- pszReadingW = Imm32WideFromAnsi(lpszReading);
- if (pszReadingW == NULL)
- goto Quit;
- }
-
- if (lpszRegister)
- {
- pszRegisterW = Imm32WideFromAnsi(lpszRegister);
- if (pszRegisterW == NULL)
- goto Quit;
- }
-
- ret = pImeDpi->ImeRegisterWord(pszReadingW, dwStyle, pszRegisterW);
-
-Quit:
- if (pszReadingW)
- HeapFree(g_hImm32Heap, 0, pszReadingW);
- if (pszRegisterW)
- HeapFree(g_hImm32Heap, 0, pszRegisterW);
- ImmUnlockImeDpi(pImeDpi);
- return ret;
-}
-
-/***********************************************************************
- * ImmRegisterWordW (IMM32.@)
- */
-BOOL WINAPI ImmRegisterWordW(
- HKL hKL, LPCWSTR lpszReading, DWORD dwStyle, LPCWSTR lpszRegister)
-{
- BOOL ret = FALSE;
- PIMEDPI pImeDpi;
- LPSTR pszReadingA = NULL, pszRegisterA = NULL;
-
- TRACE("(%p, %s, 0x%lX, %s)\n", hKL, debugstr_w(lpszReading), dwStyle,
- debugstr_w(lpszRegister));
-
- pImeDpi = ImmLockOrLoadImeDpi(hKL);
- if (!pImeDpi)
- return FALSE;
-
- if (pImeDpi->ImeInfo.fdwProperty & IME_PROP_UNICODE)
- {
- ret = pImeDpi->ImeRegisterWord(lpszReading, dwStyle, lpszRegister);
- ImmUnlockImeDpi(pImeDpi);
- return ret;
- }
-
- if (lpszReading)
- {
- pszReadingA = Imm32AnsiFromWide(lpszReading);
- if (!pszReadingA)
- goto Quit;
- }
-
- if (lpszRegister)
- {
- pszRegisterA = Imm32AnsiFromWide(lpszRegister);
- if (!pszRegisterA)
- goto Quit;
- }
-
- ret = pImeDpi->ImeRegisterWord(pszReadingA, dwStyle, pszRegisterA);
-
-Quit:
- if (pszReadingA)
- HeapFree(g_hImm32Heap, 0, pszReadingA);
- if (pszRegisterA)
- HeapFree(g_hImm32Heap, 0, pszRegisterA);
- ImmUnlockImeDpi(pImeDpi);
- return ret;
-}
-
-/***********************************************************************
- * ImmReleaseContext (IMM32.@)
- */
-BOOL WINAPI ImmReleaseContext(HWND hWnd, HIMC hIMC)
-{
- TRACE("(%p, %p)\n", hWnd, hIMC);
- UNREFERENCED_PARAMETER(hWnd);
- UNREFERENCED_PARAMETER(hIMC);
... 3516 lines suppressed ...
1205
days inactive
1205
days old
0 comments
1 participants
participants (1)
-
Katayama Hirofumi MZ