[reactos] 01/01: [IMM32][IMM32_WINETEST] Re-implement ImmSetCompositionStringA/W (#4040)
17 Oct
2021
17 Oct
'21
10:32 a.m.
https://git.reactos.org/?p=reactos.git;a=commitdiff;h=aa8fc872a098d261e13e4…
commit aa8fc872a098d261e13e48aeb32fb85808e36d1d
Author: Katayama Hirofumi MZ <katayama.hirofumi.mz(a)gmail.com>
AuthorDate: Sun Oct 17 19:32:48 2021 +0900
Commit: GitHub <noreply(a)github.com>
CommitDate: Sun Oct 17 19:32:48 2021 +0900
[IMM32][IMM32_WINETEST] Re-implement ImmSetCompositionStringA/W (#4040)
- Modify ImmSetCompositionStringA and ImmSetCompositionStringW prototypes (removing
const of two arguments).
- Add Imm32OpenICAndCS helper function.
- Implement Imm32SetCompositionStringAW function.
- Modify imm32_winetest (due to removal of const).
CORE-11700
---
dll/win32/imm32/compstr.c | 372 ++++++++++++++++++++++++++++++-
modules/rostests/winetests/imm32/imm32.c | 8 +
sdk/include/psdk/imm.h | 8 +-
3 files changed, 372 insertions(+), 16 deletions(-)
diff --git a/dll/win32/imm32/compstr.c b/dll/win32/imm32/compstr.c
index df0726c2fa2..7fa9a0e4111 100644
--- a/dll/win32/imm32/compstr.c
+++ b/dll/win32/imm32/compstr.c
@@ -14,12 +14,37 @@
WINE_DEFAULT_DEBUG_CHANNEL(imm);
+BOOL APIENTRY
+Imm32OpenICAndCS(HIMC hIMC, LPINPUTCONTEXT *ppIC, LPCOMPOSITIONSTRING *ppCS)
+{
+ LPINPUTCONTEXT pIC;
+ LPCOMPOSITIONSTRING pCS;
+
+ *ppIC = NULL;
+ *ppCS = NULL;
+
+ pIC = ImmLockIMC(hIMC);
+ if (!pIC)
+ return FALSE;
+
+ pCS = ImmLockIMCC(pIC->hCompStr);
+ if (!pCS)
+ {
+ ImmUnlockIMC(hIMC);
+ return FALSE;
+ }
+
+ *ppIC = pIC;
+ *ppCS = pCS;
+ return TRUE;
+}
+
static inline LONG APIENTRY
Imm32CompStrAnsiToWide(LPCSTR psz, DWORD cb, LPWSTR lpBuf, DWORD dwBufLen, UINT
uCodePage)
{
DWORD ret = MultiByteToWideChar(uCodePage, MB_PRECOMPOSED, psz, cb / sizeof(CHAR),
lpBuf, dwBufLen / sizeof(WCHAR));
- if ((ret + 1) * sizeof(WCHAR) <= dwBufLen)
+ if (lpBuf && (ret + 1) * sizeof(WCHAR) <= dwBufLen)
lpBuf[ret] = 0;
return ret * sizeof(WCHAR);
}
@@ -29,7 +54,7 @@ Imm32CompStrWideToAnsi(LPCWSTR psz, DWORD cb, LPSTR lpBuf, DWORD
dwBufLen, UINT
{
DWORD ret = WideCharToMultiByte(uCodePage, 0, psz, cb / sizeof(WCHAR),
lpBuf, dwBufLen / sizeof(CHAR), NULL, NULL);
- if ((ret + 1) * sizeof(CHAR) <= dwBufLen)
+ if (lpBuf && (ret + 1) * sizeof(CHAR) <= dwBufLen)
lpBuf[ret] = 0;
return ret * sizeof(CHAR);
}
@@ -44,6 +69,7 @@ Imm32CompAttrWideToAnsi(const BYTE *src, INT src_len, LPCWSTR text,
if (!src_len)
return 0;
+ str_len /= sizeof(WCHAR);
rc = WideCharToMultiByte(uCodePage, 0, text, str_len, NULL, 0, NULL, NULL);
if (dst_len)
@@ -66,7 +92,7 @@ end:
rc = j;
}
- return rc;
+ return rc * sizeof(BYTE);
}
static INT APIENTRY
@@ -79,6 +105,7 @@ Imm32CompAttrAnsiToWide(const BYTE *src, INT src_len, LPCSTR text,
if (!src_len)
return 0;
+ str_len /= sizeof(CHAR);
rc = MultiByteToWideChar(uCodePage, MB_PRECOMPOSED, text, str_len, NULL, 0);
if (dst_len)
@@ -100,7 +127,7 @@ Imm32CompAttrAnsiToWide(const BYTE *src, INT src_len, LPCSTR text,
rc = j;
}
- return rc;
+ return rc * sizeof(BYTE);
}
static INT APIENTRY
@@ -487,11 +514,332 @@ Imm32GetCompStrW(HIMC hIMC, const COMPOSITIONSTRING *pCS, DWORD
dwIndex,
}
BOOL APIENTRY
-Imm32SetCompositionStringAW(HIMC hIMC, DWORD dwIndex, LPCVOID lpComp, DWORD dwCompLen,
- LPCVOID lpRead, DWORD dwReadLen, BOOL bAnsi)
+Imm32SetCompositionStringAW(HIMC hIMC, DWORD dwIndex, LPVOID pComp, DWORD dwCompLen,
+ LPVOID pRead, DWORD dwReadLen, BOOL bAnsiAPI)
{
- FIXME("TODO:\n");
- return FALSE;
+ BOOL ret = FALSE, bAnsiClient;
+ LPVOID pCompNew = NULL, pReadNew = NULL;
+ DWORD dwThreadId, cbCompNew = 0, cbReadNew = 0;
+ LPINPUTCONTEXT pIC;
+ LPCOMPOSITIONSTRING pCS;
+ HKL hKL;
+ PIMEDPI pImeDpi;
+ UINT uCodePage;
+ LPRECONVERTSTRING pRS;
+
+ dwThreadId = NtUserQueryInputContext(hIMC, 1);
+ if (dwThreadId != GetCurrentThreadId())
+ return FALSE;
+
+ hKL = GetKeyboardLayout(dwThreadId);
+ pImeDpi = ImmLockImeDpi(hKL);
+ if (!pImeDpi)
+ return FALSE;
+
+ uCodePage = pImeDpi->uCodePage;
+ bAnsiClient = !ImeDpi_IsUnicode(pImeDpi);
+
+ switch (dwIndex)
+ {
+ case SCS_SETSTR: case SCS_CHANGEATTR: case SCS_CHANGECLAUSE:
+ break;
+
+ case SCS_SETRECONVERTSTRING: case SCS_QUERYRECONVERTSTRING:
+ if (pImeDpi->ImeInfo.fdwSCSCaps & SCS_CAP_SETRECONVERTSTRING)
+ break;
+ /* FALL THROUGH */
+ default:
+ ImmUnlockImeDpi(pImeDpi);
+ return FALSE;
+ }
+
+ if (bAnsiAPI == bAnsiClient || (!pComp && !pRead))
+ {
+ ret = pImeDpi->ImeSetCompositionString(hIMC, dwIndex, pComp, dwCompLen,
+ pRead, dwReadLen);
+ ImmUnlockImeDpi(pImeDpi);
+ return ret;
+ }
+
+ if (!Imm32OpenICAndCS(hIMC, &pIC, &pCS))
+ {
+ ImmUnlockImeDpi(pImeDpi);
+ return FALSE;
+ }
+
+ /*
+ * This code is really too complicated. But I cannot simplify.
+ * It converts like (pComp, dwCompLen) --> (pCompNew, cbCompNew) and
+ * (pRead, dwReadLen) --> (pReadNew, cbReadNew).
+ * (1) Check bAnsiClient, (2) Get the size, (3) Allocate a buffer for conversion,
+ * (4) Store converted data into the buffer.
+ */
+ switch (dwIndex)
+ {
+ case SCS_SETSTR:
+ if (pComp)
+ {
+ if (bAnsiClient)
+ {
+ cbCompNew = Imm32CompStrWideToAnsi(pComp, dwCompLen, NULL, 0,
uCodePage);
+ pCompNew = Imm32HeapAlloc(0, cbCompNew);
+ if (!pCompNew)
+ goto Quit;
+
+ Imm32CompStrWideToAnsi(pComp, dwCompLen, pCompNew, cbCompNew,
uCodePage);
+ }
+ else
+ {
+ cbCompNew = Imm32CompStrAnsiToWide(pComp, dwCompLen, NULL, 0,
uCodePage);
+ pCompNew = Imm32HeapAlloc(0, cbCompNew);
+ if (!pCompNew)
+ goto Quit;
+
+ Imm32CompStrAnsiToWide(pComp, dwCompLen, pCompNew, cbCompNew,
uCodePage);
+ }
+ }
+
+ if (pRead)
+ {
+ if (bAnsiClient)
+ {
+ cbReadNew = Imm32CompStrWideToAnsi(pRead, dwReadLen, NULL, 0,
uCodePage);
+ pReadNew = Imm32HeapAlloc(0, cbReadNew);
+ if (!pReadNew)
+ goto Quit;
+
+ Imm32CompStrWideToAnsi(pRead, dwReadLen, pReadNew, cbReadNew,
uCodePage);
+ }
+ else
+ {
+ cbReadNew = Imm32CompStrAnsiToWide(pRead, dwReadLen, NULL, 0,
uCodePage);
+ pReadNew = Imm32HeapAlloc(0, cbReadNew);
+ if (!pReadNew)
+ goto Quit;
+
+ Imm32CompStrAnsiToWide(pRead, dwReadLen, pReadNew, cbReadNew,
uCodePage);
+ }
+ }
+ break;
+
+ case SCS_CHANGEATTR:
+ if (pComp)
+ {
+ if (bAnsiClient)
+ {
+ cbCompNew = Imm32CompAttrWideToAnsi(pComp, dwCompLen,
+ CS_StrW(pCS, CompStr),
+ CS_SizeW(pCS, CompStr),
+ NULL, 0, uCodePage);
+ pCompNew = Imm32HeapAlloc(0, cbCompNew);
+ if (!pCompNew)
+ goto Quit;
+
+ Imm32CompAttrWideToAnsi(pComp, dwCompLen,
+ CS_StrW(pCS, CompStr), CS_SizeW(pCS,
CompStr),
+ pCompNew, cbCompNew, uCodePage);
+ }
+ else
+ {
+ cbCompNew = Imm32CompAttrAnsiToWide(pComp, dwCompLen,
+ CS_StrA(pCS, CompStr),
+ CS_SizeA(pCS, CompStr),
+ NULL, 0, uCodePage);
+ pCompNew = Imm32HeapAlloc(0, cbCompNew);
+ if (!pCompNew)
+ goto Quit;
+
+ Imm32CompAttrAnsiToWide(pComp, dwCompLen,
+ CS_StrA(pCS, CompStr), CS_SizeA(pCS,
CompStr),
+ pCompNew, cbCompNew, uCodePage);
+ }
+ }
+
+ if (pRead)
+ {
+ if (bAnsiClient)
+ {
+ cbReadNew = Imm32CompAttrWideToAnsi(pRead, dwReadLen,
+ CS_StrW(pCS, CompReadStr),
+ CS_SizeW(pCS, CompReadStr),
+ NULL, 0, uCodePage);
+ pReadNew = Imm32HeapAlloc(0, cbReadNew);
+ if (!pReadNew)
+ goto Quit;
+
+ Imm32CompAttrWideToAnsi(pRead, dwReadLen,
+ CS_StrW(pCS, CompReadStr), CS_SizeW(pCS,
CompReadStr),
+ pReadNew, cbReadNew, uCodePage);
+ }
+ else
+ {
+ cbReadNew = Imm32CompAttrAnsiToWide(pRead, dwReadLen,
+ CS_StrA(pCS, CompReadStr),
+ CS_SizeA(pCS, CompReadStr),
+ NULL, 0, uCodePage);
+ pReadNew = Imm32HeapAlloc(0, cbReadNew);
+ if (!pReadNew)
+ goto Quit;
+
+ Imm32CompAttrAnsiToWide(pRead, dwReadLen,
+ CS_StrA(pCS, CompReadStr), CS_SizeA(pCS,
CompReadStr),
+ pReadNew, cbReadNew, uCodePage);
+ }
+ }
+ break;
+
+ case SCS_CHANGECLAUSE:
+ if (pComp)
+ {
+ if (bAnsiClient)
+ {
+ cbCompNew = Imm32CompClauseWideToAnsi(pComp, dwCompLen, CS_StrW(pCS,
CompStr),
+ NULL, 0, uCodePage);
+ pCompNew = Imm32HeapAlloc(0, cbCompNew);
+ if (!pCompNew)
+ goto Quit;
+
+ Imm32CompClauseWideToAnsi(pComp, dwCompLen, CS_StrW(pCS, CompStr),
+ pCompNew, cbCompNew, uCodePage);
+ }
+ else
+ {
+ cbCompNew = Imm32CompClauseAnsiToWide(pComp, dwCompLen, CS_StrA(pCS,
CompStr),
+ NULL, 0, uCodePage);
+ pCompNew = Imm32HeapAlloc(0, cbCompNew);
+ if (!pCompNew)
+ goto Quit;
+
+ Imm32CompClauseAnsiToWide(pComp, dwCompLen, CS_StrA(pCS, CompStr),
+ pCompNew, cbCompNew, uCodePage);
+ }
+ }
+
+ if (pRead)
+ {
+ if (bAnsiClient)
+ {
+ cbReadNew = Imm32CompClauseWideToAnsi(pRead, dwReadLen, CS_StrW(pCS,
CompReadStr),
+ NULL, 0, uCodePage);
+ pReadNew = Imm32HeapAlloc(0, cbReadNew);
+ if (!pReadNew)
+ goto Quit;
+
+ Imm32CompClauseWideToAnsi(pRead, dwReadLen,
+ CS_StrW(pCS, CompReadStr),
+ pReadNew, cbReadNew, uCodePage);
+ }
+ else
+ {
+ cbReadNew = Imm32CompClauseAnsiToWide(pRead, dwReadLen, CS_StrA(pCS,
CompReadStr),
+ NULL, 0, uCodePage);
+ pReadNew = Imm32HeapAlloc(0, cbReadNew);
+ if (!pReadNew)
+ goto Quit;
+
+ Imm32CompClauseAnsiToWide(pRead, dwReadLen, CS_StrA(pCS,
CompReadStr),
+ pReadNew, cbReadNew, uCodePage);
+ }
+ }
+ break;
+
+ case SCS_SETRECONVERTSTRING: case SCS_QUERYRECONVERTSTRING:
+ {
+ if (pComp)
+ {
+ if (bAnsiClient)
+ {
+ cbCompNew = Imm32ReconvertAnsiFromWide(NULL, pComp, uCodePage);
+ pCompNew = Imm32HeapAlloc(0, cbCompNew);
+ if (!pCompNew)
+ goto Quit;
+
+ pRS = pCompNew;
+ pRS->dwSize = cbCompNew;
+ pRS->dwVersion = 0;
+ Imm32ReconvertAnsiFromWide(pRS, pComp, uCodePage);
+ }
+ else
+ {
+ cbCompNew = Imm32ReconvertWideFromAnsi(NULL, pComp, uCodePage);
+ pCompNew = Imm32HeapAlloc(0, cbCompNew);
+ if (!pCompNew)
+ goto Quit;
+
+ pRS = pCompNew;
+ pRS->dwSize = cbCompNew;
+ pRS->dwVersion = 0;
+ Imm32ReconvertWideFromAnsi(pRS, pComp, uCodePage);
+ }
+ }
+
+ if (pRead)
+ {
+ if (bAnsiClient)
+ {
+ cbReadNew = Imm32ReconvertAnsiFromWide(NULL, pRead, uCodePage);
+ pReadNew = Imm32HeapAlloc(0, cbReadNew);
+ if (!pReadNew)
+ goto Quit;
+
+ pRS = pReadNew;
+ pRS->dwSize = cbReadNew;
+ pRS->dwVersion = 0;
+ Imm32ReconvertAnsiFromWide(pRS, pRead, uCodePage);
+ }
+ else
+ {
+ cbReadNew = Imm32ReconvertWideFromAnsi(NULL, pRead, uCodePage);
+ pReadNew = Imm32HeapAlloc(0, cbReadNew);
+ if (!pReadNew)
+ goto Quit;
+
+ pRS = pReadNew;
+ pRS->dwSize = cbReadNew;
+ pRS->dwVersion = 0;
+ Imm32ReconvertWideFromAnsi(pRS, pRead, uCodePage);
+ }
+ }
+ break;
+ }
+ }
+
+ ImmUnlockIMCC(pIC->hCompStr);
+ pCS = NULL;
+ ImmUnlockIMC(hIMC);
+ pIC = NULL;
+
+ ret = pImeDpi->ImeSetCompositionString(hIMC, dwIndex, pCompNew, cbCompNew,
+ pReadNew, cbReadNew);
+
+ if (dwIndex == SCS_QUERYRECONVERTSTRING)
+ {
+ if (pComp)
+ {
+ if (bAnsiClient)
+ ret = Imm32ReconvertWideFromAnsi(pComp, pCompNew, uCodePage);
+ else
+ ret = Imm32ReconvertAnsiFromWide(pComp, pCompNew, uCodePage);
+ }
+
+ if (pRead)
+ {
+ if (bAnsiClient)
+ ret = Imm32ReconvertWideFromAnsi(pRead, pReadNew, uCodePage);
+ else
+ ret = Imm32ReconvertAnsiFromWide(pRead, pReadNew, uCodePage);
+ }
+ }
+
+Quit:
+ if (pCS)
+ ImmUnlockIMCC(pIC->hCompStr);
+ if (pIC)
+ ImmUnlockIMC(hIMC);
+ Imm32HeapFree(pCompNew);
+ Imm32HeapFree(pReadNew);
+ ImmUnlockImeDpi(pImeDpi);
+ return ret;
}
/***********************************************************************
@@ -582,8 +930,8 @@ LONG WINAPI ImmGetCompositionStringW(HIMC hIMC, DWORD dwIndex, LPVOID
lpBuf, DWO
* ImmSetCompositionStringA (IMM32.@)
*/
BOOL WINAPI
-ImmSetCompositionStringA(HIMC hIMC, DWORD dwIndex, LPCVOID lpComp, DWORD dwCompLen,
- LPCVOID lpRead, DWORD dwReadLen)
+ImmSetCompositionStringA(HIMC hIMC, DWORD dwIndex, LPVOID lpComp, DWORD dwCompLen,
+ LPVOID lpRead, DWORD dwReadLen)
{
TRACE("(%p, %lu, %p, %lu, %p, %lu)\n",
hIMC, dwIndex, lpComp, dwCompLen, lpRead, dwReadLen);
@@ -595,8 +943,8 @@ ImmSetCompositionStringA(HIMC hIMC, DWORD dwIndex, LPCVOID lpComp,
DWORD dwCompL
* ImmSetCompositionStringW (IMM32.@)
*/
BOOL WINAPI
-ImmSetCompositionStringW(HIMC hIMC, DWORD dwIndex, LPCVOID lpComp, DWORD dwCompLen,
- LPCVOID lpRead, DWORD dwReadLen)
+ImmSetCompositionStringW(HIMC hIMC, DWORD dwIndex, LPVOID lpComp, DWORD dwCompLen,
+ LPVOID lpRead, DWORD dwReadLen)
{
TRACE("(%p, %lu, %p, %lu, %p, %lu)\n",
hIMC, dwIndex, lpComp, dwCompLen, lpRead, dwReadLen);
diff --git a/modules/rostests/winetests/imm32/imm32.c
b/modules/rostests/winetests/imm32/imm32.c
index fef5b0dbb0d..407dfe1f6f7 100644
--- a/modules/rostests/winetests/imm32/imm32.c
+++ b/modules/rostests/winetests/imm32/imm32.c
@@ -293,7 +293,11 @@ static void cleanup(void) {
}
static void test_ImmNotifyIME(void) {
+#ifdef __REACTOS__
+ static char string[] = "wine";
+#else
static const char string[] = "wine";
+#endif
char resstr[16] = "";
HIMC imc;
BOOL ret;
@@ -422,7 +426,11 @@ static LRESULT WINAPI test_ime_wnd_proc(HWND hWnd, UINT msg, WPARAM
wParam, LPAR
static void test_ImmGetCompositionString(void)
{
HIMC imc;
+#ifdef __REACTOS__
+ static WCHAR string[] =
{'w','i','n','e',0x65e5,0x672c,0x8a9e};
+#else
static const WCHAR string[] =
{'w','i','n','e',0x65e5,0x672c,0x8a9e};
+#endif
char cstring[20];
WCHAR wstring[20];
LONG len;
diff --git a/sdk/include/psdk/imm.h b/sdk/include/psdk/imm.h
index fb7032181a7..ebd3bb4cb47 100644
--- a/sdk/include/psdk/imm.h
+++ b/sdk/include/psdk/imm.h
@@ -891,9 +891,9 @@ WINAPI
ImmSetCompositionStringA(
_In_ HIMC,
_In_ DWORD dwIndex,
- _In_reads_bytes_opt_(dwCompLen) LPCVOID lpComp,
+ _Inout_updates_bytes_opt_(dwCompLen) LPVOID lpComp,
_In_ DWORD dwCompLen,
- _In_reads_bytes_opt_(dwReadLen) LPCVOID lpRead,
+ _Inout_updates_bytes_opt_(dwReadLen) LPVOID lpRead,
_In_ DWORD dwReadLen);
BOOL
@@ -901,9 +901,9 @@ WINAPI
ImmSetCompositionStringW(
_In_ HIMC,
_In_ DWORD dwIndex,
- _In_reads_bytes_opt_(dwCompLen) LPCVOID lpComp,
+ _Inout_updates_bytes_opt_(dwCompLen) LPVOID lpComp,
_In_ DWORD dwCompLen,
- _In_reads_bytes_opt_(dwReadLen) LPCVOID lpRead,
+ _Inout_updates_bytes_opt_(dwReadLen) LPVOID lpRead,
_In_ DWORD dwReadLen);
#define ImmSetCompositionString WINELIB_NAME_AW(ImmSetCompositionString)
1097
days inactive
1097
days old
0 comments
1 participants
participants (1)
-
Katayama Hirofumi MZ