mirror of
https://github.com/reactos/reactos.git
synced 2024-11-19 05:22:59 +00:00
e1df4f2d8f
Follow-up of c2a9436
(#4798).
Improve trace messages.
CORE-11700
2195 lines
57 KiB
C
2195 lines
57 KiB
C
/*
|
|
* 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@reactos.org>
|
|
* Copyright 2018 Amine Khaldi <amine.khaldi@reactos.org>
|
|
* Copyright 2020-2022 Katayama Hirofumi MZ <katayama.hirofumi.mz@gmail.com>
|
|
*/
|
|
|
|
#include "precomp.h"
|
|
|
|
WINE_DEFAULT_DEBUG_CHANNEL(imm);
|
|
|
|
RTL_CRITICAL_SECTION gcsImeDpi; // Win: gcsImeDpi
|
|
PIMEDPI gpImeDpiList = NULL; // Win: gpImeDpi
|
|
|
|
// Win: ImmGetImeDpi
|
|
PIMEDPI APIENTRY Imm32FindImeDpi(HKL hKL)
|
|
{
|
|
PIMEDPI pImeDpi;
|
|
|
|
RtlEnterCriticalSection(&gcsImeDpi);
|
|
for (pImeDpi = gpImeDpiList; pImeDpi != NULL; pImeDpi = pImeDpi->pNext)
|
|
{
|
|
if (pImeDpi->hKL == hKL)
|
|
break;
|
|
}
|
|
RtlLeaveCriticalSection(&gcsImeDpi);
|
|
|
|
return pImeDpi;
|
|
}
|
|
|
|
// Win: UnloadIME
|
|
VOID APIENTRY Imm32FreeIME(PIMEDPI pImeDpi, BOOL bDestroy)
|
|
{
|
|
if (pImeDpi->hInst == NULL)
|
|
return;
|
|
if (bDestroy)
|
|
pImeDpi->ImeDestroy(0);
|
|
FreeLibrary(pImeDpi->hInst);
|
|
pImeDpi->hInst = NULL;
|
|
}
|
|
|
|
// Win: InquireIme
|
|
BOOL APIENTRY Imm32InquireIme(PIMEDPI pImeDpi)
|
|
{
|
|
WCHAR szUIClass[64];
|
|
WNDCLASSW wcW;
|
|
DWORD dwSysInfoFlags = 0;
|
|
LPIMEINFO pImeInfo = &pImeDpi->ImeInfo;
|
|
|
|
if (NtUserGetThreadState(THREADSTATE_ISWINLOGON2))
|
|
dwSysInfoFlags |= IME_SYSINFO_WINLOGON;
|
|
|
|
if (GetWin32ClientInfo()->dwTIFlags & TIF_16BIT)
|
|
dwSysInfoFlags |= IME_SYSINFO_WOW16;
|
|
|
|
if (IS_IME_HKL(pImeDpi->hKL))
|
|
{
|
|
if (!pImeDpi->ImeInquire(pImeInfo, szUIClass, dwSysInfoFlags))
|
|
{
|
|
ERR("\n");
|
|
return FALSE;
|
|
}
|
|
}
|
|
else if (IS_CICERO_MODE() && !IS_16BIT_MODE())
|
|
{
|
|
if (!pImeDpi->CtfImeInquireExW(pImeInfo, szUIClass, dwSysInfoFlags, pImeDpi->hKL))
|
|
{
|
|
ERR("\n");
|
|
return FALSE;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
ERR("\n");
|
|
return FALSE;
|
|
}
|
|
|
|
szUIClass[_countof(szUIClass) - 1] = UNICODE_NULL; /* Avoid buffer overrun */
|
|
|
|
if (pImeInfo->dwPrivateDataSize < sizeof(DWORD))
|
|
pImeInfo->dwPrivateDataSize = sizeof(DWORD);
|
|
|
|
#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)
|
|
{
|
|
ERR("Bad flags\n");
|
|
return FALSE;
|
|
}
|
|
if (pImeInfo->fdwConversionCaps & ~VALID_CMODE_CAPS)
|
|
{
|
|
ERR("Bad flags\n");
|
|
return FALSE;
|
|
}
|
|
if (pImeInfo->fdwSentenceCaps & ~VALID_SMODE_CAPS)
|
|
{
|
|
ERR("Bad flags\n");
|
|
return FALSE;
|
|
}
|
|
if (pImeInfo->fdwUICaps & ~VALID_UI_CAPS)
|
|
{
|
|
ERR("Bad flags\n");
|
|
return FALSE;
|
|
}
|
|
if (pImeInfo->fdwSCSCaps & ~VALID_SCS_CAPS)
|
|
{
|
|
ERR("Bad flags\n");
|
|
return FALSE;
|
|
}
|
|
if (pImeInfo->fdwSelectCaps & ~VALID_SELECT_CAPS)
|
|
{
|
|
ERR("Bad flags\n");
|
|
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 != CP_ACP)
|
|
return FALSE;
|
|
|
|
MultiByteToWideChar(CP_ACP, MB_PRECOMPOSED, (LPSTR)szUIClass, -1,
|
|
pImeDpi->szUIClass, _countof(pImeDpi->szUIClass));
|
|
|
|
pImeDpi->szUIClass[_countof(pImeDpi->szUIClass) - 1] = UNICODE_NULL;
|
|
}
|
|
|
|
if (!GetClassInfoW(pImeDpi->hInst, pImeDpi->szUIClass, &wcW))
|
|
{
|
|
ERR("\n");
|
|
return FALSE;
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
/* Define stub IME functions */
|
|
#define DEFINE_IME_ENTRY(type, name, params, optional) \
|
|
type APIENTRY Stub##name params { \
|
|
FIXME("%s: Why stub called?\n", #name); \
|
|
return (type)0; \
|
|
}
|
|
#include "imetable.h"
|
|
#undef DEFINE_IME_ENTRY
|
|
|
|
// Win: LoadIME
|
|
BOOL APIENTRY Imm32LoadIME(PIMEINFOEX pImeInfoEx, PIMEDPI pImeDpi)
|
|
{
|
|
WCHAR szPath[MAX_PATH];
|
|
HINSTANCE hIME;
|
|
FARPROC fn;
|
|
BOOL ret = FALSE;
|
|
|
|
if (!Imm32GetSystemLibraryPath(szPath, _countof(szPath), pImeInfoEx->wszImeFile))
|
|
return FALSE;
|
|
|
|
pImeDpi->hInst = hIME = LoadLibraryW(szPath);
|
|
if (hIME == NULL)
|
|
{
|
|
ERR("LoadLibraryW(%s) failed\n", debugstr_w(szPath));
|
|
return FALSE;
|
|
}
|
|
|
|
/* Populate the table by stub IME functions */
|
|
#define DEFINE_IME_ENTRY(type, name, params, optional) pImeDpi->name = Stub##name;
|
|
#include "imetable.h"
|
|
#undef DEFINE_IME_ENTRY
|
|
|
|
/* Populate the table by real IME functions */
|
|
#define DEFINE_IME_ENTRY(type, name, params, optional) \
|
|
do { \
|
|
fn = GetProcAddress(hIME, #name); \
|
|
if (fn) pImeDpi->name = (FN_##name)fn; \
|
|
else if (!(optional)) { \
|
|
ERR("'%s' not found in IME module '%s'.\n", #name, debugstr_w(szPath)); \
|
|
goto Failed; \
|
|
} \
|
|
} while (0);
|
|
#include "imetable.h"
|
|
#undef DEFINE_IME_ENTRY
|
|
|
|
if (Imm32InquireIme(pImeDpi))
|
|
{
|
|
ret = TRUE;
|
|
}
|
|
else
|
|
{
|
|
Failed:
|
|
ret = FALSE;
|
|
FreeLibrary(pImeDpi->hInst);
|
|
pImeDpi->hInst = NULL;
|
|
}
|
|
|
|
if (pImeInfoEx->fLoadFlag == 0)
|
|
{
|
|
if (ret)
|
|
{
|
|
C_ASSERT(sizeof(pImeInfoEx->wszUIClass) == sizeof(pImeDpi->szUIClass));
|
|
pImeInfoEx->ImeInfo = pImeDpi->ImeInfo;
|
|
RtlCopyMemory(pImeInfoEx->wszUIClass, pImeDpi->szUIClass,
|
|
sizeof(pImeInfoEx->wszUIClass));
|
|
pImeInfoEx->fLoadFlag = 2;
|
|
}
|
|
else
|
|
{
|
|
pImeInfoEx->fLoadFlag = 1;
|
|
}
|
|
|
|
NtUserSetImeInfoEx(pImeInfoEx);
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
// Win: LoadImeDpi
|
|
PIMEDPI APIENTRY Imm32LoadImeDpi(HKL hKL, BOOL bLock)
|
|
{
|
|
IMEINFOEX ImeInfoEx;
|
|
CHARSETINFO ci;
|
|
PIMEDPI pImeDpiNew, pImeDpiFound;
|
|
UINT uCodePage;
|
|
LCID lcid;
|
|
|
|
if (!IS_IME_HKL(hKL))
|
|
{
|
|
TRACE("\n");
|
|
return NULL;
|
|
}
|
|
|
|
if (!ImmGetImeInfoEx(&ImeInfoEx, ImeInfoExKeyboardLayout, &hKL))
|
|
{
|
|
ERR("\n");
|
|
return NULL;
|
|
}
|
|
|
|
if (ImeInfoEx.fLoadFlag == 1)
|
|
{
|
|
ERR("\n");
|
|
return NULL;
|
|
}
|
|
|
|
pImeDpiNew = ImmLocalAlloc(HEAP_ZERO_MEMORY, sizeof(IMEDPI));
|
|
if (IS_NULL_UNEXPECTEDLY(pImeDpiNew))
|
|
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 (!Imm32LoadIME(&ImeInfoEx, pImeDpiNew))
|
|
{
|
|
ERR("\n");
|
|
ImmLocalFree(pImeDpiNew);
|
|
return FALSE;
|
|
}
|
|
|
|
RtlEnterCriticalSection(&gcsImeDpi);
|
|
|
|
pImeDpiFound = Imm32FindImeDpi(hKL);
|
|
if (pImeDpiFound)
|
|
{
|
|
if (!bLock)
|
|
pImeDpiFound->dwFlags &= ~IMEDPI_FLAG_LOCKED;
|
|
|
|
RtlLeaveCriticalSection(&gcsImeDpi);
|
|
Imm32FreeIME(pImeDpiNew, FALSE);
|
|
ImmLocalFree(pImeDpiNew);
|
|
return pImeDpiFound;
|
|
}
|
|
else
|
|
{
|
|
if (bLock)
|
|
{
|
|
pImeDpiNew->dwFlags |= IMEDPI_FLAG_LOCKED;
|
|
pImeDpiNew->cLockObj = 1;
|
|
}
|
|
|
|
pImeDpiNew->pNext = gpImeDpiList;
|
|
gpImeDpiList = pImeDpiNew;
|
|
|
|
RtlLeaveCriticalSection(&gcsImeDpi);
|
|
return pImeDpiNew;
|
|
}
|
|
}
|
|
|
|
// Win: FindOrLoadImeDpi
|
|
PIMEDPI APIENTRY Imm32FindOrLoadImeDpi(HKL hKL)
|
|
{
|
|
PIMEDPI pImeDpi;
|
|
|
|
if (!IS_IME_HKL(hKL) && (!IS_CICERO_MODE() || IS_16BIT_MODE()))
|
|
{
|
|
TRACE("\n");
|
|
return NULL;
|
|
}
|
|
|
|
pImeDpi = ImmLockImeDpi(hKL);
|
|
if (pImeDpi == NULL)
|
|
pImeDpi = Imm32LoadImeDpi(hKL, TRUE);
|
|
return pImeDpi;
|
|
}
|
|
|
|
static LRESULT APIENTRY
|
|
ImeDpi_Escape(PIMEDPI pImeDpi, HIMC hIMC, UINT uSubFunc, LPVOID lpData, HKL hKL)
|
|
{
|
|
if (IS_IME_HKL(hKL))
|
|
return pImeDpi->ImeEscape(hIMC, uSubFunc, lpData);
|
|
if (IS_CICERO_MODE() && !IS_16BIT_MODE())
|
|
return pImeDpi->CtfImeEscapeEx(hIMC, uSubFunc, lpData, hKL);
|
|
|
|
return 0;
|
|
}
|
|
|
|
// Win: ImmUnloadIME
|
|
BOOL APIENTRY Imm32ReleaseIME(HKL hKL)
|
|
{
|
|
BOOL ret = TRUE;
|
|
PIMEDPI pImeDpi0, pImeDpi1;
|
|
|
|
RtlEnterCriticalSection(&gcsImeDpi);
|
|
|
|
for (pImeDpi0 = gpImeDpiList; pImeDpi0; pImeDpi0 = pImeDpi0->pNext)
|
|
{
|
|
if (pImeDpi0->hKL == hKL)
|
|
break;
|
|
}
|
|
|
|
if (!pImeDpi0)
|
|
goto Quit;
|
|
|
|
if (pImeDpi0->cLockObj)
|
|
{
|
|
pImeDpi0->dwFlags |= IMEDPI_FLAG_UNLOADED;
|
|
ret = FALSE;
|
|
goto Quit;
|
|
}
|
|
|
|
if (gpImeDpiList == pImeDpi0)
|
|
{
|
|
gpImeDpiList = pImeDpi0->pNext;
|
|
}
|
|
else if (gpImeDpiList)
|
|
{
|
|
for (pImeDpi1 = gpImeDpiList; pImeDpi1; pImeDpi1 = pImeDpi1->pNext)
|
|
{
|
|
if (pImeDpi1->pNext == pImeDpi0)
|
|
{
|
|
pImeDpi1->pNext = pImeDpi0->pNext;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
Imm32FreeIME(pImeDpi0, TRUE);
|
|
ImmLocalFree(pImeDpi0);
|
|
|
|
Quit:
|
|
RtlLeaveCriticalSection(&gcsImeDpi);
|
|
return ret;
|
|
}
|
|
|
|
// We will transport the IME menu items by using a flat memory block via
|
|
// a file mapping object beyond the boundary of a process.
|
|
|
|
#define MAX_IMEMENU_BITMAP_BYTES 0xF00
|
|
|
|
typedef struct tagIMEMENUITEM
|
|
{
|
|
IMEMENUITEMINFOW Info;
|
|
BYTE abChecked[MAX_IMEMENU_BITMAP_BYTES];
|
|
BYTE abUnchecked[MAX_IMEMENU_BITMAP_BYTES];
|
|
BYTE abItem[MAX_IMEMENU_BITMAP_BYTES];
|
|
} IMEMENUITEM, *PIMEMENUITEM;
|
|
|
|
typedef struct tagIMEMENU
|
|
{
|
|
DWORD dwVersion;
|
|
DWORD dwFlags;
|
|
DWORD dwType;
|
|
DWORD dwItemCount;
|
|
IMEMENUITEMINFOW Parent;
|
|
IMEMENUITEM Items[ANYSIZE_ARRAY];
|
|
} IMEMENU, *PIMEMENU;
|
|
|
|
/***********************************************************************
|
|
* ImmPutImeMenuItemsIntoMappedFile (IMM32.@)
|
|
*
|
|
* Called from user32.dll to transport the IME menu items by using a
|
|
* file mapping object. This function is provided for WM_IME_SYSTEM:IMS_GETIMEMENU
|
|
* handling.
|
|
*/
|
|
LRESULT WINAPI ImmPutImeMenuItemsIntoMappedFile(HIMC hIMC)
|
|
{
|
|
LRESULT ret = FALSE;
|
|
HANDLE hMapping;
|
|
PIMEMENU pView;
|
|
LPIMEMENUITEMINFOW pParent = NULL, pItems = NULL;
|
|
DWORD i, cItems, cbItems = 0;
|
|
|
|
hMapping = OpenFileMappingW(FILE_MAP_ALL_ACCESS, FALSE, L"ImmMenuInfo");
|
|
pView = MapViewOfFile(hMapping, FILE_MAP_ALL_ACCESS, 0, 0, 0);
|
|
if (IS_NULL_UNEXPECTEDLY(pView))
|
|
goto Quit;
|
|
|
|
if (pView->dwVersion != 1)
|
|
{
|
|
ERR("\n");
|
|
goto Quit;
|
|
}
|
|
|
|
if (pView->Parent.cbSize > 0)
|
|
pParent = &pView->Parent;
|
|
|
|
if (pView->dwItemCount > 0)
|
|
{
|
|
cbItems = pView->dwItemCount * sizeof(IMEMENUITEMINFOW);
|
|
pItems = ImmLocalAlloc(HEAP_ZERO_MEMORY, cbItems);
|
|
if (IS_NULL_UNEXPECTEDLY(pItems))
|
|
goto Quit;
|
|
}
|
|
|
|
cItems = ImmGetImeMenuItemsW(hIMC, pView->dwFlags, pView->dwType, pParent, pItems, cbItems);
|
|
pView->dwItemCount = cItems;
|
|
if (IS_ZERO_UNEXPECTEDLY(cItems))
|
|
goto Quit;
|
|
|
|
if (pItems)
|
|
{
|
|
for (i = 0; i < cItems; ++i)
|
|
{
|
|
pView->Items[i].Info = pItems[i];
|
|
|
|
// store bitmaps to bytes
|
|
if (pItems[i].hbmpChecked)
|
|
{
|
|
Imm32StoreBitmapToBytes(pItems[i].hbmpChecked, pView->Items[i].abChecked,
|
|
MAX_IMEMENU_BITMAP_BYTES);
|
|
DeleteObject(pItems[i].hbmpChecked);
|
|
}
|
|
if (pItems[i].hbmpUnchecked)
|
|
{
|
|
Imm32StoreBitmapToBytes(pItems[i].hbmpUnchecked, pView->Items[i].abUnchecked,
|
|
MAX_IMEMENU_BITMAP_BYTES);
|
|
DeleteObject(pItems[i].hbmpUnchecked);
|
|
}
|
|
if (pItems[i].hbmpItem)
|
|
{
|
|
Imm32StoreBitmapToBytes(pItems[i].hbmpItem, pView->Items[i].abItem,
|
|
MAX_IMEMENU_BITMAP_BYTES);
|
|
DeleteObject(pItems[i].hbmpItem);
|
|
}
|
|
}
|
|
}
|
|
|
|
ret = TRUE;
|
|
|
|
Quit:
|
|
if (pItems)
|
|
ImmLocalFree(pItems);
|
|
if (pView)
|
|
UnmapViewOfFile(pView);
|
|
if (hMapping)
|
|
CloseHandle(hMapping);
|
|
return ret;
|
|
}
|
|
|
|
// Win: ImmGetImeMenuItemsInterProcess
|
|
DWORD APIENTRY
|
|
Imm32GetImeMenuItemWInterProcess(HIMC hIMC, DWORD dwFlags, DWORD dwType, LPVOID lpImeParentMenu,
|
|
LPVOID lpImeMenu, DWORD dwSize)
|
|
{
|
|
HANDLE hMapping;
|
|
PIMEMENU pView;
|
|
DWORD i, cbView, dwItemCount, ret = 0;
|
|
HWND hImeWnd;
|
|
PIMEMENUITEM pGotItem;
|
|
LPIMEMENUITEMINFOW pSetInfo;
|
|
|
|
hImeWnd = (HWND)NtUserQueryInputContext(hIMC, QIC_DEFAULTWINDOWIME);
|
|
if (!hImeWnd || !IsWindow(hImeWnd))
|
|
{
|
|
ERR("\n");
|
|
return 0;
|
|
}
|
|
|
|
dwItemCount = (lpImeMenu ? (dwSize / sizeof(IMEMENUITEMINFOW)) : 0);
|
|
cbView = sizeof(IMEMENU) + ((size_t)dwItemCount - 1) * sizeof(IMEMENUITEM);
|
|
|
|
RtlEnterCriticalSection(&gcsImeDpi);
|
|
|
|
// create a file mapping
|
|
hMapping = CreateFileMappingW(INVALID_HANDLE_VALUE, NULL, PAGE_READWRITE,
|
|
0, cbView, L"ImmMenuInfo");
|
|
pView = MapViewOfFile(hMapping, FILE_MAP_READ | FILE_MAP_WRITE, 0, 0, 0);
|
|
if (IS_NULL_UNEXPECTEDLY(pView))
|
|
goto Quit;
|
|
|
|
ZeroMemory(pView, cbView);
|
|
pView->dwVersion = 1;
|
|
pView->dwFlags = dwFlags;
|
|
pView->dwType = dwType;
|
|
pView->dwItemCount = dwItemCount;
|
|
if (lpImeParentMenu)
|
|
{
|
|
pView->Parent = *(LPIMEMENUITEMINFOW)lpImeParentMenu;
|
|
pView->Parent.cbSize = sizeof(IMEMENUITEMINFOW);
|
|
}
|
|
|
|
if (!SendMessageW(hImeWnd, WM_IME_SYSTEM, IMS_GETIMEMENU, (LPARAM)hIMC))
|
|
{
|
|
ERR("\n");
|
|
goto Quit;
|
|
}
|
|
|
|
ret = pView->dwItemCount;
|
|
|
|
if (!lpImeMenu)
|
|
goto Quit;
|
|
|
|
for (i = 0; i < ret; ++i)
|
|
{
|
|
pGotItem = &(pView->Items[i]);
|
|
pSetInfo = &((LPIMEMENUITEMINFOW)lpImeMenu)[i];
|
|
|
|
*pSetInfo = pGotItem->Info;
|
|
|
|
// load bitmaps from bytes
|
|
if (pSetInfo->hbmpChecked)
|
|
{
|
|
pSetInfo->hbmpChecked = Imm32LoadBitmapFromBytes(pGotItem->abChecked);
|
|
}
|
|
if (pSetInfo->hbmpUnchecked)
|
|
{
|
|
pSetInfo->hbmpUnchecked = Imm32LoadBitmapFromBytes(pGotItem->abUnchecked);
|
|
}
|
|
if (pSetInfo->hbmpItem)
|
|
{
|
|
pSetInfo->hbmpItem = Imm32LoadBitmapFromBytes(pGotItem->abItem);
|
|
}
|
|
}
|
|
|
|
Quit:
|
|
RtlLeaveCriticalSection(&gcsImeDpi);
|
|
if (pView)
|
|
UnmapViewOfFile(pView);
|
|
if (hMapping)
|
|
CloseHandle(hMapping);
|
|
return ret;
|
|
}
|
|
|
|
// Win: ImmGetImeMenuItemsWorker
|
|
DWORD APIENTRY
|
|
ImmGetImeMenuItemsAW(HIMC hIMC, DWORD dwFlags, DWORD dwType, LPVOID lpImeParentMenu,
|
|
LPVOID lpImeMenu, DWORD dwSize, BOOL bTargetIsAnsi)
|
|
{
|
|
DWORD ret = 0, cbTotal, dwProcessId, dwThreadId, iItem;
|
|
LPINPUTCONTEXT pIC;
|
|
PIMEDPI pImeDpi = NULL;
|
|
IMEMENUITEMINFOA ParentA;
|
|
IMEMENUITEMINFOW ParentW;
|
|
LPIMEMENUITEMINFOA pItemA;
|
|
LPIMEMENUITEMINFOW pItemW;
|
|
LPVOID pNewItems = NULL, pNewParent = NULL;
|
|
BOOL bImcIsAnsi;
|
|
HKL hKL;
|
|
|
|
if (IS_NULL_UNEXPECTEDLY(hIMC))
|
|
return 0;
|
|
|
|
dwProcessId = (DWORD)NtUserQueryInputContext(hIMC, QIC_INPUTPROCESSID);
|
|
if (IS_ZERO_UNEXPECTEDLY(dwProcessId))
|
|
return 0;
|
|
|
|
if (dwProcessId != GetCurrentProcessId())
|
|
{
|
|
if (bTargetIsAnsi)
|
|
return 0;
|
|
return Imm32GetImeMenuItemWInterProcess(hIMC, dwFlags, dwType, lpImeParentMenu,
|
|
lpImeMenu, dwSize);
|
|
}
|
|
|
|
pIC = ImmLockIMC(hIMC);
|
|
if (IS_NULL_UNEXPECTEDLY(pIC))
|
|
return 0;
|
|
|
|
dwThreadId = (DWORD)NtUserQueryInputContext(hIMC, QIC_INPUTTHREADID);
|
|
if (IS_ZERO_UNEXPECTEDLY(dwThreadId))
|
|
{
|
|
ImmUnlockIMC(hIMC);
|
|
return 0;
|
|
}
|
|
|
|
hKL = GetKeyboardLayout(dwThreadId);
|
|
pImeDpi = ImmLockImeDpi(hKL);
|
|
if (IS_NULL_UNEXPECTEDLY(pImeDpi))
|
|
{
|
|
ImmUnlockIMC(hIMC);
|
|
return 0;
|
|
}
|
|
|
|
bImcIsAnsi = Imm32IsImcAnsi(hIMC);
|
|
|
|
if (bImcIsAnsi != bTargetIsAnsi)
|
|
{
|
|
if (bTargetIsAnsi)
|
|
{
|
|
if (lpImeParentMenu)
|
|
pNewParent = &ParentW;
|
|
|
|
if (lpImeMenu)
|
|
{
|
|
cbTotal = ((dwSize / sizeof(IMEMENUITEMINFOA)) * sizeof(IMEMENUITEMINFOW));
|
|
pNewItems = ImmLocalAlloc(0, cbTotal);
|
|
if (IS_NULL_UNEXPECTEDLY(pNewItems))
|
|
goto Quit;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (lpImeParentMenu)
|
|
pNewParent = &ParentA;
|
|
|
|
if (lpImeMenu)
|
|
{
|
|
cbTotal = ((dwSize / sizeof(IMEMENUITEMINFOW)) * sizeof(IMEMENUITEMINFOA));
|
|
pNewItems = ImmLocalAlloc(0, cbTotal);
|
|
if (IS_NULL_UNEXPECTEDLY(pNewItems))
|
|
goto Quit;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
pNewItems = lpImeMenu;
|
|
pNewParent = lpImeParentMenu;
|
|
}
|
|
|
|
ret = pImeDpi->ImeGetImeMenuItems(hIMC, dwFlags, dwType, pNewParent, pNewItems, dwSize);
|
|
if (IS_ZERO_UNEXPECTEDLY(ret) || !lpImeMenu)
|
|
goto Quit;
|
|
|
|
if (bImcIsAnsi != bTargetIsAnsi)
|
|
{
|
|
if (bTargetIsAnsi)
|
|
{
|
|
if (pNewParent)
|
|
Imm32ImeMenuWideToAnsi(pNewParent, lpImeParentMenu, pImeDpi->uCodePage);
|
|
|
|
pItemW = pNewItems;
|
|
pItemA = lpImeMenu;
|
|
for (iItem = 0; iItem < ret; ++iItem, ++pItemW, ++pItemA)
|
|
{
|
|
if (!Imm32ImeMenuWideToAnsi(pItemW, pItemA, pImeDpi->uCodePage))
|
|
{
|
|
ERR("\n");
|
|
ret = 0;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (pNewParent)
|
|
Imm32ImeMenuAnsiToWide(pNewParent, lpImeParentMenu, pImeDpi->uCodePage, TRUE);
|
|
|
|
pItemA = pNewItems;
|
|
pItemW = lpImeMenu;
|
|
for (iItem = 0; iItem < dwSize; ++iItem, ++pItemA, ++pItemW)
|
|
{
|
|
if (!Imm32ImeMenuAnsiToWide(pItemA, pItemW, pImeDpi->uCodePage, TRUE))
|
|
{
|
|
ERR("\n");
|
|
ret = 0;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
Quit:
|
|
if (pNewItems != lpImeMenu)
|
|
ImmLocalFree(pNewItems);
|
|
ImmUnlockImeDpi(pImeDpi);
|
|
ImmUnlockIMC(hIMC);
|
|
TRACE("ret: 0x%X\n", ret);
|
|
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(CP_ACP, lpszIMEFileName);
|
|
if (IS_NULL_UNEXPECTEDLY(pszFileNameW))
|
|
goto Quit;
|
|
|
|
pszLayoutTextW = Imm32WideFromAnsi(CP_ACP, lpszLayoutText);
|
|
if (IS_NULL_UNEXPECTEDLY(pszLayoutTextW))
|
|
goto Quit;
|
|
|
|
hKL = ImmInstallIMEW(pszFileNameW, pszLayoutTextW);
|
|
|
|
Quit:
|
|
ImmLocalFree(pszFileNameW);
|
|
ImmLocalFree(pszLayoutTextW);
|
|
return hKL;
|
|
}
|
|
|
|
/***********************************************************************
|
|
* ImmInstallIMEW (IMM32.@)
|
|
*/
|
|
HKL WINAPI ImmInstallIMEW(LPCWSTR lpszIMEFileName, LPCWSTR lpszLayoutText)
|
|
{
|
|
WCHAR szImeFileName[MAX_PATH], szImeDestPath[MAX_PATH], szImeKey[20];
|
|
IMEINFOEX InfoEx;
|
|
LPWSTR pchFilePart;
|
|
UINT iLayout, cLayouts;
|
|
HKL hNewKL;
|
|
WORD wLangID;
|
|
PREG_IME pLayouts = NULL;
|
|
|
|
TRACE("(%s, %s)\n", debugstr_w(lpszIMEFileName), debugstr_w(lpszLayoutText));
|
|
|
|
GetFullPathNameW(lpszIMEFileName, _countof(szImeFileName), szImeFileName, &pchFilePart);
|
|
CharUpperW(szImeFileName);
|
|
if (IS_NULL_UNEXPECTEDLY(pchFilePart))
|
|
return NULL;
|
|
|
|
/* Load the IME version info */
|
|
InfoEx.hkl = hNewKL = NULL;
|
|
StringCchCopyW(InfoEx.wszImeFile, _countof(InfoEx.wszImeFile), pchFilePart);
|
|
if (!Imm32LoadImeVerInfo(&InfoEx) || !InfoEx.hkl)
|
|
{
|
|
ERR("\n");
|
|
return NULL;
|
|
}
|
|
wLangID = LOWORD(InfoEx.hkl);
|
|
|
|
/* Get the IME layouts from registry */
|
|
cLayouts = Imm32GetImeLayout(NULL, 0);
|
|
if (cLayouts)
|
|
{
|
|
pLayouts = ImmLocalAlloc(0, cLayouts * sizeof(REG_IME));
|
|
if (IS_NULL_UNEXPECTEDLY(pLayouts))
|
|
return NULL;
|
|
|
|
if (!Imm32GetImeLayout(pLayouts, cLayouts))
|
|
{
|
|
ERR("\n");
|
|
ImmLocalFree(pLayouts);
|
|
return NULL;
|
|
}
|
|
|
|
for (iLayout = 0; iLayout < cLayouts; ++iLayout)
|
|
{
|
|
if (lstrcmpiW(pLayouts[iLayout].szFileName, pchFilePart) == 0)
|
|
{
|
|
if (wLangID != LOWORD(pLayouts[iLayout].hKL))
|
|
{
|
|
ERR("\n");
|
|
goto Quit; /* The language is different */
|
|
}
|
|
|
|
hNewKL = pLayouts[iLayout].hKL; /* Found */
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
/* If the IME for the specified filename is valid, then unload it now */
|
|
if (ImmGetImeInfoEx(&InfoEx, ImeInfoExImeFileName, pchFilePart) &&
|
|
!UnloadKeyboardLayout(InfoEx.hkl))
|
|
{
|
|
ERR("\n");
|
|
hNewKL = NULL;
|
|
goto Quit;
|
|
}
|
|
|
|
Imm32GetSystemLibraryPath(szImeDestPath, _countof(szImeDestPath), pchFilePart);
|
|
CharUpperW(szImeDestPath);
|
|
|
|
/* If the source and the destination pathnames were different, then copy the IME file */
|
|
if (lstrcmpiW(szImeFileName, szImeDestPath) != 0 &&
|
|
!Imm32CopyImeFile(szImeFileName, szImeDestPath))
|
|
{
|
|
ERR("\n");
|
|
hNewKL = NULL;
|
|
goto Quit;
|
|
}
|
|
|
|
if (hNewKL == NULL)
|
|
hNewKL = Imm32AssignNewLayout(cLayouts, pLayouts, wLangID);
|
|
|
|
if (hNewKL)
|
|
{
|
|
/* Write the IME layout to registry */
|
|
if (Imm32WriteImeLayout(hNewKL, pchFilePart, lpszLayoutText))
|
|
{
|
|
/* Load the keyboard layout */
|
|
StringCchPrintfW(szImeKey, _countof(szImeKey), L"%08X", (DWORD)(DWORD_PTR)hNewKL);
|
|
hNewKL = LoadKeyboardLayoutW(szImeKey, KLF_REPLACELANG);
|
|
}
|
|
else
|
|
{
|
|
ERR("\n");
|
|
hNewKL = NULL;
|
|
}
|
|
}
|
|
|
|
Quit:
|
|
ImmLocalFree(pLayouts);
|
|
return hNewKL;
|
|
}
|
|
|
|
/***********************************************************************
|
|
* ImmIsIME (IMM32.@)
|
|
*/
|
|
BOOL WINAPI ImmIsIME(HKL hKL)
|
|
{
|
|
IMEINFOEX info;
|
|
TRACE("(%p)\n", hKL);
|
|
return !!ImmGetImeInfoEx(&info, ImeInfoExKeyboardLayoutTFS, &hKL);
|
|
}
|
|
|
|
/***********************************************************************
|
|
* ImmGetDefaultIMEWnd (IMM32.@)
|
|
*/
|
|
HWND WINAPI ImmGetDefaultIMEWnd(HWND hWnd)
|
|
{
|
|
if (!IS_IMM_MODE())
|
|
{
|
|
TRACE("\n");
|
|
return NULL;
|
|
}
|
|
|
|
if (hWnd == NULL)
|
|
return (HWND)NtUserGetThreadState(THREADSTATE_DEFAULTIMEWINDOW);
|
|
|
|
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 && IS_CROSS_THREAD_HIMC(hIMC))
|
|
return FALSE;
|
|
|
|
hKL = GetKeyboardLayout(0);
|
|
pImeDpi = ImmLockImeDpi(hKL);
|
|
if (IS_NULL_UNEXPECTEDLY(pImeDpi))
|
|
return FALSE;
|
|
|
|
ret = pImeDpi->NotifyIME(hIMC, dwAction, dwIndex, dwValue);
|
|
ImmUnlockImeDpi(pImeDpi);
|
|
return ret;
|
|
}
|
|
|
|
/***********************************************************************
|
|
* ImmDisableLegacyIME(IMM32.@)
|
|
*/
|
|
BOOL WINAPI ImmDisableLegacyIME(void)
|
|
{
|
|
FIXME("stub\n");
|
|
return TRUE;
|
|
}
|
|
|
|
/***********************************************************************
|
|
* ImmGetImeInfoEx (IMM32.@)
|
|
*/
|
|
BOOL WINAPI
|
|
ImmGetImeInfoEx(PIMEINFOEX pImeInfoEx, IMEINFOEXCLASS SearchType, PVOID pvSearchKey)
|
|
{
|
|
HKL hKL;
|
|
if (SearchType == ImeInfoExKeyboardLayout || SearchType == ImeInfoExKeyboardLayoutTFS)
|
|
{
|
|
hKL = *(HKL*)pvSearchKey;
|
|
pImeInfoEx->hkl = hKL;
|
|
|
|
if (SearchType == ImeInfoExKeyboardLayoutTFS)
|
|
{
|
|
if (!IS_IME_HKL(hKL))
|
|
{
|
|
if (CtfImmIsTextFrameServiceDisabled() || !IS_CICERO_MODE() || IS_16BIT_MODE())
|
|
{
|
|
TRACE("\n");
|
|
return FALSE;
|
|
}
|
|
}
|
|
|
|
SearchType = ImeInfoExKeyboardLayout;
|
|
}
|
|
else
|
|
{
|
|
if (!IS_IME_HKL(hKL))
|
|
{
|
|
TRACE("\n");
|
|
return FALSE;
|
|
}
|
|
}
|
|
}
|
|
else if (SearchType == ImeInfoExImeFileName)
|
|
{
|
|
StringCchCopyW(pImeInfoEx->wszImeFile, _countof(pImeInfoEx->wszImeFile),
|
|
pvSearchKey);
|
|
}
|
|
else
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
return NtUserGetImeInfoEx(pImeInfoEx, SearchType);
|
|
}
|
|
|
|
/***********************************************************************
|
|
* ImmLockImeDpi (IMM32.@)
|
|
*/
|
|
PIMEDPI WINAPI ImmLockImeDpi(HKL hKL)
|
|
{
|
|
PIMEDPI pImeDpi = NULL;
|
|
|
|
TRACE("(%p)\n", hKL);
|
|
|
|
RtlEnterCriticalSection(&gcsImeDpi);
|
|
|
|
/* Find by hKL */
|
|
for (pImeDpi = gpImeDpiList; pImeDpi; pImeDpi = pImeDpi->pNext)
|
|
{
|
|
if (pImeDpi->hKL == hKL) /* found */
|
|
{
|
|
/* lock if possible */
|
|
if (pImeDpi->dwFlags & IMEDPI_FLAG_UNLOADED)
|
|
pImeDpi = NULL;
|
|
else
|
|
++(pImeDpi->cLockObj);
|
|
break;
|
|
}
|
|
}
|
|
|
|
RtlLeaveCriticalSection(&gcsImeDpi);
|
|
return pImeDpi;
|
|
}
|
|
|
|
/***********************************************************************
|
|
* ImmUnlockImeDpi (IMM32.@)
|
|
*/
|
|
VOID WINAPI ImmUnlockImeDpi(PIMEDPI pImeDpi)
|
|
{
|
|
PIMEDPI *ppEntry;
|
|
|
|
TRACE("(%p)\n", pImeDpi);
|
|
|
|
if (pImeDpi == NULL)
|
|
return;
|
|
|
|
RtlEnterCriticalSection(&gcsImeDpi);
|
|
|
|
/* unlock */
|
|
--(pImeDpi->cLockObj);
|
|
if (pImeDpi->cLockObj != 0)
|
|
{
|
|
RtlLeaveCriticalSection(&gcsImeDpi);
|
|
return;
|
|
}
|
|
|
|
if ((pImeDpi->dwFlags & IMEDPI_FLAG_UNLOADED) == 0)
|
|
{
|
|
if ((pImeDpi->dwFlags & IMEDPI_FLAG_LOCKED) == 0 ||
|
|
(pImeDpi->ImeInfo.fdwProperty & IME_PROP_END_UNLOAD) == 0)
|
|
{
|
|
RtlLeaveCriticalSection(&gcsImeDpi);
|
|
return;
|
|
}
|
|
}
|
|
|
|
/* Remove from list */
|
|
for (ppEntry = &gpImeDpiList; *ppEntry; ppEntry = &((*ppEntry)->pNext))
|
|
{
|
|
if (*ppEntry == pImeDpi) /* found */
|
|
{
|
|
*ppEntry = pImeDpi->pNext;
|
|
break;
|
|
}
|
|
}
|
|
|
|
Imm32FreeIME(pImeDpi, TRUE);
|
|
ImmLocalFree(pImeDpi);
|
|
|
|
RtlLeaveCriticalSection(&gcsImeDpi);
|
|
}
|
|
|
|
/***********************************************************************
|
|
* ImmLoadIME (IMM32.@)
|
|
*/
|
|
BOOL WINAPI ImmLoadIME(HKL hKL)
|
|
{
|
|
PIMEDPI pImeDpi;
|
|
|
|
if (!IS_IME_HKL(hKL) && (!IS_CICERO_MODE() || IS_16BIT_MODE()))
|
|
{
|
|
TRACE("\n");
|
|
return FALSE;
|
|
}
|
|
|
|
pImeDpi = Imm32FindImeDpi(hKL);
|
|
if (pImeDpi == NULL)
|
|
pImeDpi = Imm32LoadImeDpi(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 (!IS_IME_HKL(hKL))
|
|
{
|
|
TRACE("\n");
|
|
return 0;
|
|
}
|
|
|
|
if (!ImmGetImeInfoEx(&info, ImeInfoExKeyboardLayout, &hKL))
|
|
{
|
|
ERR("\n");
|
|
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 (!IS_IME_HKL(hKL))
|
|
{
|
|
TRACE("\n");
|
|
return 0;
|
|
}
|
|
|
|
if (!ImmGetImeInfoEx(&info, ImeInfoExKeyboardLayout, &hKL))
|
|
{
|
|
ERR("\n");
|
|
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 (!IS_IME_HKL(hKL))
|
|
{
|
|
TRACE("\n");
|
|
if (uBufLen > 0)
|
|
lpszFileName[0] = 0;
|
|
return 0;
|
|
}
|
|
|
|
if (!ImmGetImeInfoEx(&info, ImeInfoExKeyboardLayout, &hKL))
|
|
{
|
|
ERR("\n");
|
|
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 (!IS_IME_HKL(hKL))
|
|
{
|
|
TRACE("\n");
|
|
if (uBufLen > 0)
|
|
lpszFileName[0] = 0;
|
|
return 0;
|
|
}
|
|
|
|
if (!ImmGetImeInfoEx(&info, ImeInfoExKeyboardLayout, &hKL))
|
|
{
|
|
ERR("\n");
|
|
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 (!IS_IME_HKL(hKL))
|
|
{
|
|
TRACE("\n");
|
|
return FALSE;
|
|
}
|
|
|
|
if (!ImmGetImeInfoEx(&ImeInfoEx, ImeInfoExKeyboardLayout, &hKL))
|
|
{
|
|
ERR("\n");
|
|
return FALSE;
|
|
}
|
|
|
|
if (fdwIndex == IGP_GETIMEVERSION)
|
|
return ImeInfoEx.dwImeWinVersion;
|
|
|
|
if (ImeInfoEx.fLoadFlag != 2)
|
|
{
|
|
pImeDpi = Imm32FindOrLoadImeDpi(hKL);
|
|
if (IS_NULL_UNEXPECTEDLY(pImeDpi))
|
|
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;
|
|
}
|
|
|
|
/***********************************************************************
|
|
* ImmEscapeA (IMM32.@)
|
|
*/
|
|
LRESULT WINAPI ImmEscapeA(HKL hKL, HIMC hIMC, UINT uSubFunc, LPVOID lpData)
|
|
{
|
|
LRESULT ret;
|
|
PIMEDPI pImeDpi;
|
|
INT cch;
|
|
CHAR szA[MAX_IMM_FILENAME];
|
|
WCHAR szW[MAX_IMM_FILENAME];
|
|
|
|
TRACE("(%p, %p, %u, %p)\n", hKL, hIMC, uSubFunc, lpData);
|
|
|
|
pImeDpi = Imm32FindOrLoadImeDpi(hKL);
|
|
if (IS_NULL_UNEXPECTEDLY(pImeDpi))
|
|
return 0;
|
|
|
|
if (!ImeDpi_IsUnicode(pImeDpi) || !lpData) /* No conversion needed */
|
|
{
|
|
ret = ImeDpi_Escape(pImeDpi, hIMC, uSubFunc, lpData, hKL);
|
|
ImmUnlockImeDpi(pImeDpi);
|
|
return ret;
|
|
}
|
|
|
|
switch (uSubFunc)
|
|
{
|
|
case IME_ESC_SEQUENCE_TO_INTERNAL:
|
|
ret = ImeDpi_Escape(pImeDpi, hIMC, uSubFunc, lpData, hKL);
|
|
|
|
cch = 0;
|
|
if (HIWORD(ret))
|
|
szW[cch++] = HIWORD(ret);
|
|
if (LOWORD(ret))
|
|
szW[cch++] = LOWORD(ret);
|
|
|
|
cch = WideCharToMultiByte(pImeDpi->uCodePage, 0, szW, cch, szA, _countof(szA),
|
|
NULL, NULL);
|
|
switch (cch)
|
|
{
|
|
case 1:
|
|
ret = MAKEWORD(szA[0], 0);
|
|
break;
|
|
case 2:
|
|
ret = MAKEWORD(szA[1], szA[0]);
|
|
break;
|
|
case 3:
|
|
ret = MAKELONG(MAKEWORD(szA[2], szA[1]), MAKEWORD(szA[0], 0));
|
|
break;
|
|
case 4:
|
|
ret = MAKELONG(MAKEWORD(szA[3], szA[2]), MAKEWORD(szA[1], szA[0]));
|
|
break;
|
|
default:
|
|
ret = 0;
|
|
break;
|
|
}
|
|
break;
|
|
|
|
case IME_ESC_GET_EUDC_DICTIONARY:
|
|
case IME_ESC_IME_NAME:
|
|
case IME_ESC_GETHELPFILENAME:
|
|
ret = ImeDpi_Escape(pImeDpi, hIMC, uSubFunc, szW, hKL);
|
|
if (ret)
|
|
{
|
|
szW[_countof(szW) - 1] = UNICODE_NULL; /* Avoid buffer overrun */
|
|
WideCharToMultiByte(pImeDpi->uCodePage, 0, szW, -1,
|
|
lpData, MAX_IMM_FILENAME, NULL, NULL);
|
|
((LPSTR)lpData)[MAX_IMM_FILENAME - 1] = 0;
|
|
}
|
|
break;
|
|
|
|
case IME_ESC_SET_EUDC_DICTIONARY:
|
|
case IME_ESC_HANJA_MODE:
|
|
MultiByteToWideChar(pImeDpi->uCodePage, MB_PRECOMPOSED,
|
|
lpData, -1, szW, _countof(szW));
|
|
szW[_countof(szW) - 1] = UNICODE_NULL; /* Avoid buffer overrun */
|
|
ret = ImeDpi_Escape(pImeDpi, hIMC, uSubFunc, szW, hKL);
|
|
break;
|
|
|
|
default:
|
|
ret = ImeDpi_Escape(pImeDpi, hIMC, uSubFunc, lpData, hKL);
|
|
break;
|
|
}
|
|
|
|
ImmUnlockImeDpi(pImeDpi);
|
|
TRACE("ret: %p\n", ret);
|
|
return ret;
|
|
}
|
|
|
|
/***********************************************************************
|
|
* ImmEscapeW (IMM32.@)
|
|
*/
|
|
LRESULT WINAPI ImmEscapeW(HKL hKL, HIMC hIMC, UINT uSubFunc, LPVOID lpData)
|
|
{
|
|
LRESULT ret;
|
|
PIMEDPI pImeDpi;
|
|
INT cch;
|
|
CHAR szA[MAX_IMM_FILENAME];
|
|
WCHAR szW[MAX_IMM_FILENAME];
|
|
WORD word;
|
|
|
|
TRACE("(%p, %p, %u, %p)\n", hKL, hIMC, uSubFunc, lpData);
|
|
|
|
pImeDpi = Imm32FindOrLoadImeDpi(hKL);
|
|
if (IS_NULL_UNEXPECTEDLY(pImeDpi))
|
|
return 0;
|
|
|
|
if (ImeDpi_IsUnicode(pImeDpi) || !lpData) /* No conversion needed */
|
|
{
|
|
ret = ImeDpi_Escape(pImeDpi, hIMC, uSubFunc, lpData, hKL);
|
|
ImmUnlockImeDpi(pImeDpi);
|
|
return ret;
|
|
}
|
|
|
|
switch (uSubFunc)
|
|
{
|
|
case IME_ESC_SEQUENCE_TO_INTERNAL:
|
|
ret = ImeDpi_Escape(pImeDpi, hIMC, uSubFunc, lpData, hKL);
|
|
|
|
word = LOWORD(ret);
|
|
cch = 0;
|
|
if (HIBYTE(word))
|
|
szA[cch++] = HIBYTE(word);
|
|
if (LOBYTE(word))
|
|
szA[cch++] = LOBYTE(word);
|
|
|
|
cch = MultiByteToWideChar(pImeDpi->uCodePage, MB_PRECOMPOSED,
|
|
szA, cch, szW, _countof(szW));
|
|
switch (cch)
|
|
{
|
|
case 1: ret = szW[0]; break;
|
|
case 2: ret = MAKELONG(szW[1], szW[0]); break;
|
|
default: ret = 0; break;
|
|
}
|
|
break;
|
|
|
|
case IME_ESC_GET_EUDC_DICTIONARY:
|
|
case IME_ESC_IME_NAME:
|
|
case IME_ESC_GETHELPFILENAME:
|
|
ret = ImeDpi_Escape(pImeDpi, hIMC, uSubFunc, szA, hKL);
|
|
if (ret)
|
|
{
|
|
szA[_countof(szA) - 1] = 0;
|
|
MultiByteToWideChar(pImeDpi->uCodePage, MB_PRECOMPOSED,
|
|
szA, -1, lpData, MAX_IMM_FILENAME);
|
|
((LPWSTR)lpData)[MAX_IMM_FILENAME - 1] = UNICODE_NULL; /* Avoid buffer overrun */
|
|
}
|
|
break;
|
|
|
|
case IME_ESC_SET_EUDC_DICTIONARY:
|
|
case IME_ESC_HANJA_MODE:
|
|
WideCharToMultiByte(pImeDpi->uCodePage, 0,
|
|
lpData, -1, szA, _countof(szA), NULL, NULL);
|
|
szA[_countof(szA) - 1] = 0;
|
|
ret = ImeDpi_Escape(pImeDpi, hIMC, uSubFunc, szA, hKL);
|
|
break;
|
|
|
|
default:
|
|
ret = ImeDpi_Escape(pImeDpi, hIMC, uSubFunc, lpData, hKL);
|
|
break;
|
|
}
|
|
|
|
ImmUnlockImeDpi(pImeDpi);
|
|
TRACE("ret: %p\n", ret);
|
|
return ret;
|
|
}
|
|
|
|
/***********************************************************************
|
|
* ImmGetOpenStatus (IMM32.@)
|
|
*/
|
|
BOOL WINAPI ImmGetOpenStatus(HIMC hIMC)
|
|
{
|
|
BOOL ret;
|
|
LPINPUTCONTEXT pIC;
|
|
|
|
TRACE("(%p)\n", hIMC);
|
|
|
|
if (IS_NULL_UNEXPECTEDLY(hIMC))
|
|
return FALSE;
|
|
|
|
pIC = ImmLockIMC(hIMC);
|
|
if (IS_NULL_UNEXPECTEDLY(pIC))
|
|
return FALSE;
|
|
|
|
ret = pIC->fOpen;
|
|
ImmUnlockIMC(hIMC);
|
|
TRACE("ret: %d\n", ret);
|
|
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 (IS_CROSS_THREAD_HIMC(hIMC))
|
|
return FALSE;
|
|
|
|
pIC = ImmLockIMC(hIMC);
|
|
if (IS_NULL_UNEXPECTEDLY(pIC))
|
|
return FALSE;
|
|
|
|
if (pIC->fOpen != fOpen)
|
|
{
|
|
pIC->fOpen = fOpen;
|
|
hWnd = pIC->hWnd;
|
|
dwConversion = pIC->fdwConversion;
|
|
bHasChange = TRUE;
|
|
}
|
|
|
|
ImmUnlockIMC(hIMC);
|
|
|
|
if (bHasChange)
|
|
{
|
|
Imm32MakeIMENotify(hIMC, hWnd, NI_CONTEXTUPDATED, 0,
|
|
IMC_SETOPENSTATUS, IMN_SETOPENSTATUS, 0);
|
|
NtUserNotifyIMEStatus(hWnd, fOpen, dwConversion);
|
|
}
|
|
else
|
|
{
|
|
TRACE("No change.\n");
|
|
}
|
|
|
|
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 (IS_NULL_UNEXPECTEDLY(pIC))
|
|
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 (IS_CROSS_THREAD_HIMC(hIMC))
|
|
return FALSE;
|
|
|
|
pIC = ImmLockIMC(hIMC);
|
|
if (IS_NULL_UNEXPECTEDLY(pIC))
|
|
return FALSE;
|
|
|
|
hWnd = pIC->hWnd;
|
|
pIC->ptStatusWndPos = *lpptPos;
|
|
pIC->fdwInit |= INIT_STATUSWNDPOS;
|
|
|
|
ImmUnlockIMC(hIMC);
|
|
|
|
Imm32MakeIMENotify(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 (IS_NULL_UNEXPECTEDLY(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)
|
|
{
|
|
LPINPUTCONTEXTDX pIC;
|
|
HWND hWnd;
|
|
|
|
if (IS_CROSS_THREAD_HIMC(hIMC))
|
|
return FALSE;
|
|
|
|
pIC = (LPINPUTCONTEXTDX)ImmLockIMC(hIMC);
|
|
if (IS_NULL_UNEXPECTEDLY(pIC))
|
|
return FALSE;
|
|
|
|
pIC->cfCompForm = *lpCompForm;
|
|
pIC->fdwInit |= INIT_COMPFORM;
|
|
|
|
if (pIC->dwUIFlags & 0x8)
|
|
pIC->dwUIFlags &= ~0x8;
|
|
else
|
|
pIC->dwUIFlags &= ~0x2;
|
|
|
|
hWnd = pIC->hWnd;
|
|
|
|
ImmUnlockIMC(hIMC);
|
|
|
|
Imm32MakeIMENotify(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 (IS_NULL_UNEXPECTEDLY(pClientImc))
|
|
return FALSE;
|
|
|
|
bWide = (pClientImc->dwFlags & CLIENTIMC_WIDE);
|
|
ImmUnlockClientImc(pClientImc);
|
|
|
|
pIC = ImmLockIMC(hIMC);
|
|
if (IS_NULL_UNEXPECTEDLY(pIC))
|
|
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 (IS_NULL_UNEXPECTEDLY(pClientImc))
|
|
return FALSE;
|
|
|
|
bWide = (pClientImc->dwFlags & CLIENTIMC_WIDE);
|
|
ImmUnlockClientImc(pClientImc);
|
|
|
|
pIC = ImmLockIMC(hIMC);
|
|
if (IS_NULL_UNEXPECTEDLY(pIC))
|
|
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;
|
|
LANGID LangID;
|
|
HWND hWnd;
|
|
|
|
TRACE("(%p, %p)\n", hIMC, lplf);
|
|
|
|
if (IS_CROSS_THREAD_HIMC(hIMC))
|
|
return FALSE;
|
|
|
|
pClientImc = ImmLockClientImc(hIMC);
|
|
if (IS_NULL_UNEXPECTEDLY(pClientImc))
|
|
return FALSE;
|
|
|
|
bWide = (pClientImc->dwFlags & CLIENTIMC_WIDE);
|
|
ImmUnlockClientImc(pClientImc);
|
|
|
|
if (bWide)
|
|
{
|
|
LogFontAnsiToWide(lplf, &lfW);
|
|
return ImmSetCompositionFontW(hIMC, &lfW);
|
|
}
|
|
|
|
pIC = (LPINPUTCONTEXTDX)ImmLockIMC(hIMC);
|
|
if (IS_NULL_UNEXPECTEDLY(pIC))
|
|
return FALSE;
|
|
|
|
if (GetWin32ClientInfo()->dwExpWinVer < _WIN32_WINNT_NT4) /* old version (3.x)? */
|
|
{
|
|
LangID = LANGIDFROMLCID(GetSystemDefaultLCID());
|
|
if (PRIMARYLANGID(LangID) == 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);
|
|
|
|
Imm32MakeIMENotify(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;
|
|
LANGID LangID;
|
|
|
|
TRACE("(%p, %p)\n", hIMC, lplf);
|
|
|
|
if (IS_CROSS_THREAD_HIMC(hIMC))
|
|
return FALSE;
|
|
|
|
pClientImc = ImmLockClientImc(hIMC);
|
|
if (IS_NULL_UNEXPECTEDLY(pClientImc))
|
|
return FALSE;
|
|
|
|
bWide = (pClientImc->dwFlags & CLIENTIMC_WIDE);
|
|
ImmUnlockClientImc(pClientImc);
|
|
|
|
if (!bWide)
|
|
{
|
|
LogFontWideToAnsi(lplf, &lfA);
|
|
return ImmSetCompositionFontA(hIMC, &lfA);
|
|
}
|
|
|
|
pIC = (LPINPUTCONTEXTDX)ImmLockIMC(hIMC);
|
|
if (IS_NULL_UNEXPECTEDLY(pIC))
|
|
return FALSE;
|
|
|
|
if (GetWin32ClientInfo()->dwExpWinVer < _WIN32_WINNT_NT4) /* old version (3.x)? */
|
|
{
|
|
LangID = LANGIDFROMLCID(GetSystemDefaultLCID());
|
|
if (PRIMARYLANGID(LangID) == 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);
|
|
|
|
Imm32MakeIMENotify(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 = Imm32FindOrLoadImeDpi(hKL);
|
|
if (IS_NULL_UNEXPECTEDLY(pImeDpi))
|
|
return 0;
|
|
|
|
if (!ImeDpi_IsUnicode(pImeDpi)) /* No conversion needed */
|
|
{
|
|
ret = pImeDpi->ImeConversionList(hIMC, pSrc, lpDst, dwBufLen, uFlag);
|
|
ImmUnlockImeDpi(pImeDpi);
|
|
return ret;
|
|
}
|
|
|
|
if (pSrc)
|
|
{
|
|
pszSrcW = Imm32WideFromAnsi(pImeDpi->uCodePage, pSrc);
|
|
if (IS_NULL_UNEXPECTEDLY(pszSrcW))
|
|
goto Quit;
|
|
}
|
|
|
|
cb = pImeDpi->ImeConversionList(hIMC, pszSrcW, NULL, 0, uFlag);
|
|
if (IS_ZERO_UNEXPECTEDLY(cb))
|
|
goto Quit;
|
|
|
|
pCL = ImmLocalAlloc(0, cb);
|
|
if (IS_NULL_UNEXPECTEDLY(pCL))
|
|
goto Quit;
|
|
|
|
cb = pImeDpi->ImeConversionList(hIMC, pszSrcW, pCL, cb, uFlag);
|
|
if (IS_ZERO_UNEXPECTEDLY(cb))
|
|
goto Quit;
|
|
|
|
ret = CandidateListWideToAnsi(pCL, lpDst, dwBufLen, pImeDpi->uCodePage);
|
|
|
|
Quit:
|
|
ImmLocalFree(pszSrcW);
|
|
ImmLocalFree(pCL);
|
|
ImmUnlockImeDpi(pImeDpi);
|
|
TRACE("ret: 0x%X\n", ret);
|
|
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 = Imm32FindOrLoadImeDpi(hKL);
|
|
if (IS_NULL_UNEXPECTEDLY(pImeDpi))
|
|
return 0;
|
|
|
|
if (ImeDpi_IsUnicode(pImeDpi)) /* No conversion needed */
|
|
{
|
|
ret = pImeDpi->ImeConversionList(hIMC, pSrc, lpDst, dwBufLen, uFlag);
|
|
ImmUnlockImeDpi(pImeDpi);
|
|
return ret;
|
|
}
|
|
|
|
if (pSrc)
|
|
{
|
|
pszSrcA = Imm32AnsiFromWide(pImeDpi->uCodePage, pSrc);
|
|
if (IS_NULL_UNEXPECTEDLY(pszSrcA))
|
|
goto Quit;
|
|
}
|
|
|
|
cb = pImeDpi->ImeConversionList(hIMC, pszSrcA, NULL, 0, uFlag);
|
|
if (IS_ZERO_UNEXPECTEDLY(cb))
|
|
goto Quit;
|
|
|
|
pCL = ImmLocalAlloc(0, cb);
|
|
if (IS_NULL_UNEXPECTEDLY(pCL))
|
|
goto Quit;
|
|
|
|
cb = pImeDpi->ImeConversionList(hIMC, pszSrcA, pCL, cb, uFlag);
|
|
if (IS_ZERO_UNEXPECTEDLY(cb))
|
|
goto Quit;
|
|
|
|
ret = CandidateListAnsiToWide(pCL, lpDst, dwBufLen, pImeDpi->uCodePage);
|
|
|
|
Quit:
|
|
ImmLocalFree(pszSrcA);
|
|
ImmLocalFree(pCL);
|
|
ImmUnlockImeDpi(pImeDpi);
|
|
TRACE("ret: 0x%X\n", ret);
|
|
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 (IS_NULL_UNEXPECTEDLY(pIC))
|
|
return FALSE;
|
|
|
|
if (lpfdwConversion)
|
|
{
|
|
*lpfdwConversion = pIC->fdwConversion;
|
|
TRACE("0x%X\n", *lpfdwConversion);
|
|
}
|
|
|
|
if (lpfdwSentence)
|
|
{
|
|
*lpfdwSentence = pIC->fdwSentence;
|
|
TRACE("0x%X\n", *lpfdwSentence);
|
|
}
|
|
|
|
ImmUnlockIMC(hIMC);
|
|
return TRUE;
|
|
}
|
|
|
|
/***********************************************************************
|
|
* ImmSetConversionStatus (IMM32.@)
|
|
*/
|
|
BOOL WINAPI ImmSetConversionStatus(HIMC hIMC, DWORD fdwConversion, DWORD fdwSentence)
|
|
{
|
|
HKL hKL;
|
|
LPINPUTCONTEXT pIC;
|
|
DWORD dwOldConversion, dwOldSentence;
|
|
BOOL fOpen = FALSE, fConversionChange = FALSE, fSentenceChange = FALSE, fUseCicero = FALSE;
|
|
HWND hWnd;
|
|
|
|
TRACE("(%p, 0x%lX, 0x%lX)\n", hIMC, fdwConversion, fdwSentence);
|
|
|
|
hKL = GetKeyboardLayout(0);
|
|
if (!IS_IME_HKL(hKL) && IS_CICERO_MODE() && !IS_16BIT_MODE())
|
|
fUseCicero = TRUE;
|
|
|
|
if (IS_CROSS_THREAD_HIMC(hIMC))
|
|
return FALSE;
|
|
|
|
pIC = ImmLockIMC(hIMC);
|
|
if (IS_NULL_UNEXPECTEDLY(pIC))
|
|
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;
|
|
fOpen = pIC->fOpen;
|
|
ImmUnlockIMC(hIMC);
|
|
|
|
if (fConversionChange || fUseCicero)
|
|
{
|
|
Imm32MakeIMENotify(hIMC, hWnd, NI_CONTEXTUPDATED, dwOldConversion,
|
|
IMC_SETCONVERSIONMODE, IMN_SETCONVERSIONMODE, 0);
|
|
if (fConversionChange)
|
|
NtUserNotifyIMEStatus(hWnd, fOpen, fdwConversion);
|
|
}
|
|
|
|
if (fSentenceChange || fUseCicero)
|
|
{
|
|
Imm32MakeIMENotify(hIMC, hWnd, NI_CONTEXTUPDATED, dwOldSentence,
|
|
IMC_SETSENTENCEMODE, IMN_SETSENTENCEMODE, 0);
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
/***********************************************************************
|
|
* ImmConfigureIMEA (IMM32.@)
|
|
*/
|
|
BOOL WINAPI ImmConfigureIMEA(HKL hKL, HWND hWnd, DWORD dwMode, LPVOID lpData)
|
|
{
|
|
BOOL ret = FALSE;
|
|
PIMEDPI pImeDpi;
|
|
REGISTERWORDW RegWordW;
|
|
LPREGISTERWORDA pRegWordA;
|
|
|
|
TRACE("(%p, %p, 0x%lX, %p)\n", hKL, hWnd, dwMode, lpData);
|
|
|
|
if (IS_NULL_UNEXPECTEDLY(ValidateHwnd(hWnd)) || IS_CROSS_PROCESS_HWND(hWnd))
|
|
return FALSE;
|
|
|
|
pImeDpi = Imm32FindOrLoadImeDpi(hKL);
|
|
if (IS_NULL_UNEXPECTEDLY(pImeDpi))
|
|
return FALSE;
|
|
|
|
RtlZeroMemory(&RegWordW, sizeof(RegWordW));
|
|
|
|
if (!ImeDpi_IsUnicode(pImeDpi) || !lpData || dwMode != IME_CONFIG_REGISTERWORD)
|
|
goto DoIt; /* No conversion needed */
|
|
|
|
pRegWordA = lpData;
|
|
|
|
if (pRegWordA->lpReading)
|
|
{
|
|
RegWordW.lpReading = Imm32WideFromAnsi(pImeDpi->uCodePage, pRegWordA->lpReading);
|
|
if (IS_NULL_UNEXPECTEDLY(RegWordW.lpReading))
|
|
goto Quit;
|
|
}
|
|
|
|
if (pRegWordA->lpWord)
|
|
{
|
|
RegWordW.lpWord = Imm32WideFromAnsi(pImeDpi->uCodePage, pRegWordA->lpWord);
|
|
if (IS_NULL_UNEXPECTEDLY(RegWordW.lpWord))
|
|
goto Quit;
|
|
}
|
|
|
|
lpData = &RegWordW;
|
|
|
|
DoIt:
|
|
SendMessageW(hWnd, WM_IME_SYSTEM, 0x1B, 0);
|
|
ret = pImeDpi->ImeConfigure(hKL, hWnd, dwMode, lpData);
|
|
SendMessageW(hWnd, WM_IME_SYSTEM, 0x1A, 0);
|
|
|
|
Quit:
|
|
ImmLocalFree(RegWordW.lpReading);
|
|
ImmLocalFree(RegWordW.lpWord);
|
|
ImmUnlockImeDpi(pImeDpi);
|
|
TRACE("ret: %d\n", ret);
|
|
return ret;
|
|
}
|
|
|
|
/***********************************************************************
|
|
* ImmConfigureIMEW (IMM32.@)
|
|
*/
|
|
BOOL WINAPI ImmConfigureIMEW(HKL hKL, HWND hWnd, DWORD dwMode, LPVOID lpData)
|
|
{
|
|
BOOL ret = FALSE;
|
|
PIMEDPI pImeDpi;
|
|
REGISTERWORDA RegWordA;
|
|
LPREGISTERWORDW pRegWordW;
|
|
|
|
TRACE("(%p, %p, 0x%lX, %p)\n", hKL, hWnd, dwMode, lpData);
|
|
|
|
if (IS_NULL_UNEXPECTEDLY(ValidateHwnd(hWnd)) || IS_CROSS_PROCESS_HWND(hWnd))
|
|
return FALSE;
|
|
|
|
pImeDpi = Imm32FindOrLoadImeDpi(hKL);
|
|
if (IS_NULL_UNEXPECTEDLY(pImeDpi))
|
|
return FALSE;
|
|
|
|
RtlZeroMemory(&RegWordA, sizeof(RegWordA));
|
|
|
|
if (ImeDpi_IsUnicode(pImeDpi) || !lpData || dwMode != IME_CONFIG_REGISTERWORD)
|
|
goto DoIt; /* No conversion needed */
|
|
|
|
pRegWordW = lpData;
|
|
|
|
if (pRegWordW->lpReading)
|
|
{
|
|
RegWordA.lpReading = Imm32AnsiFromWide(pImeDpi->uCodePage, pRegWordW->lpReading);
|
|
if (IS_NULL_UNEXPECTEDLY(RegWordA.lpReading))
|
|
goto Quit;
|
|
}
|
|
|
|
if (pRegWordW->lpWord)
|
|
{
|
|
RegWordA.lpWord = Imm32AnsiFromWide(pImeDpi->uCodePage, pRegWordW->lpWord);
|
|
if (IS_NULL_UNEXPECTEDLY(RegWordA.lpWord))
|
|
goto Quit;
|
|
}
|
|
|
|
lpData = &RegWordA;
|
|
|
|
DoIt:
|
|
SendMessageW(hWnd, WM_IME_SYSTEM, 0x1B, 0);
|
|
ret = pImeDpi->ImeConfigure(hKL, hWnd, dwMode, lpData);
|
|
SendMessageW(hWnd, WM_IME_SYSTEM, 0x1A, 0);
|
|
|
|
Quit:
|
|
ImmLocalFree(RegWordA.lpReading);
|
|
ImmLocalFree(RegWordA.lpWord);
|
|
ImmUnlockImeDpi(pImeDpi);
|
|
TRACE("ret: %d\n", ret);
|
|
return ret;
|
|
}
|
|
|
|
/***********************************************************************
|
|
* ImmGetImeMenuItemsA (IMM32.@)
|
|
*/
|
|
DWORD WINAPI
|
|
ImmGetImeMenuItemsA(HIMC hIMC, DWORD dwFlags, DWORD dwType,
|
|
LPIMEMENUITEMINFOA lpImeParentMenu,
|
|
LPIMEMENUITEMINFOA lpImeMenu, DWORD dwSize)
|
|
{
|
|
TRACE("(%p, 0x%lX, 0x%lX, %p, %p, 0x%lX)\n",
|
|
hIMC, dwFlags, dwType, lpImeParentMenu, lpImeMenu, dwSize);
|
|
return ImmGetImeMenuItemsAW(hIMC, dwFlags, dwType, lpImeParentMenu, lpImeMenu, dwSize, TRUE);
|
|
}
|
|
|
|
/***********************************************************************
|
|
* ImmGetImeMenuItemsW (IMM32.@)
|
|
*/
|
|
DWORD WINAPI
|
|
ImmGetImeMenuItemsW(HIMC hIMC, DWORD dwFlags, DWORD dwType,
|
|
LPIMEMENUITEMINFOW lpImeParentMenu,
|
|
LPIMEMENUITEMINFOW lpImeMenu, DWORD dwSize)
|
|
{
|
|
TRACE("(%p, 0x%lX, 0x%lX, %p, %p, 0x%lX)\n",
|
|
hIMC, dwFlags, dwType, lpImeParentMenu, lpImeMenu, dwSize);
|
|
return ImmGetImeMenuItemsAW(hIMC, dwFlags, dwType, lpImeParentMenu, lpImeMenu, dwSize, FALSE);
|
|
}
|
|
|
|
/***********************************************************************
|
|
* ImmWINNLSEnableIME (IMM32.@)
|
|
*/
|
|
BOOL WINAPI ImmWINNLSEnableIME(HWND hWnd, BOOL enable)
|
|
{
|
|
HIMC hIMC;
|
|
PCLIENTIMC pClientImc;
|
|
HWND hImeWnd;
|
|
BOOL bImeWnd, ret;
|
|
|
|
TRACE("(%p, %d)\n", hWnd, enable);
|
|
|
|
if (!Imm32IsSystemJapaneseOrKorean())
|
|
{
|
|
SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
|
|
return FALSE;
|
|
}
|
|
|
|
hIMC = (HIMC)NtUserGetThreadState(THREADSTATE_DEFAULTINPUTCONTEXT);
|
|
if (IS_NULL_UNEXPECTEDLY(hIMC))
|
|
return FALSE;
|
|
|
|
pClientImc = ImmLockClientImc(hIMC);
|
|
if (IS_NULL_UNEXPECTEDLY(pClientImc))
|
|
return FALSE;
|
|
|
|
ret = !(pClientImc->dwFlags & CLIENTIMC_DISABLEIME);
|
|
if (!!enable == ret)
|
|
{
|
|
TRACE("Same\n");
|
|
ImmUnlockClientImc(pClientImc);
|
|
return ret;
|
|
}
|
|
|
|
if (!IsWindow(hWnd))
|
|
hWnd = GetFocus();
|
|
|
|
hImeWnd = ImmGetDefaultIMEWnd(hWnd);
|
|
bImeWnd = IsWindow(hImeWnd);
|
|
if (bImeWnd)
|
|
ImmSetActiveContext(hWnd, (enable ? NULL : hIMC), FALSE);
|
|
|
|
if (enable)
|
|
pClientImc->dwFlags &= ~CLIENTIMC_DISABLEIME;
|
|
else
|
|
pClientImc->dwFlags |= CLIENTIMC_DISABLEIME;
|
|
|
|
ImmUnlockClientImc(pClientImc);
|
|
|
|
if (bImeWnd)
|
|
ImmSetActiveContext(hWnd, (enable ? hIMC : NULL), TRUE);
|
|
|
|
return ret;
|
|
}
|