able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/windows/feime/kor/imeui.c

1335 lines
48 KiB
C
Raw Permalink Normal View History

Add source files
2020-09-26 03:20:57 -05:00
/******************************************************************************
*
* File Name: imeui.c
*
* - User Interface routines.
*
* Author: Beomseok Oh (BeomOh)
*
* Copyright (C) Microsoft Corp 1993-1995. All rights reserved.
*
******************************************************************************/
// include files
#include "precomp.h"
// local definitions
#define UIGWL_FLAGS 0
#define UIF_WNDMOVE 0x00000001UL
#define UIF_HANPRESS 0x00000002UL
#define UIF_JUNPRESS 0x00000004UL
#define UIF_CHIPRESS 0x00000008UL
#define UIF_MOUSEIN 0x00000010UL
#define UIF_SHOWSTATUS 0x00000020UL
#define UIF_PRIVATEPOS 0x00000040UL
extern BOOL fWndOpen[3];
extern WORD wWndCmd[3];
// public data
#pragma data_seg(".text", "CODE")
const TCHAR szUIClassName[] = TEXT("MSIME95K");
const TCHAR szStateWndName[] = TEXT("IMESTATE");
const TCHAR szCompWndName[] = TEXT("IMECOMP");
const TCHAR szCandWndName[] = TEXT("IMECAND");
const static RECT rcHan = { 4, 2, 21, 19 }, rcJun = { 24, 2, 41, 19 },
rcChi = { 44, 2, 61, 19 };
const static RECT rcCandCli = { 0, 0, 319, 29 },
rcLArrow = { 15, 4, 27, 25 }, rcRArrow = { 292, 4, 304, 25 },
rcBtn[9] = { { 30, 4, 57, 25 }, { 59, 4, 86, 25 },
{ 88, 4, 115, 25 }, { 117, 4, 144, 25 },
{ 146, 4, 173, 25 }, { 175, 4, 202, 25 },
{ 204, 4, 231, 25 }, { 233, 4, 260, 25 },
{ 262, 4, 289, 25 } };
#pragma data_seg()
HBITMAP hBMClient, hBMComp, hBMCand, hBMCandNum, hBMCandArr[2];
HBITMAP hBMEng, hBMHan, hBMBan, hBMJun, hBMChi[2];
HCURSOR hIMECursor;
HFONT hFontFix = NULL;
#pragma data_seg("SHAREDDATA")
RECT rcScreen = { 0, 0, 0, 0 };
RECT rcOldScrn = { 0, 0, 0, 0 };
POINT ptDefPos[3] = { { -1, -1 }, { -1, -1 }, { -1, -1 } };
POINT ptState = { -1, -1 };
POINT ptComp = { -1, -1 };
POINT ptCand = { -1, -1 };
DWORD dwScreenRes = 0;
#pragma data_seg()
static POINT ptPos;
static RECT rc;
void UpdateUIPosition(void)
{
HKEY hKey;
DWORD dwBuf, dwCb;
SystemParametersInfo(SPI_GETWORKAREA, sizeof(rcScreen), &rcScreen, FALSE);
if (!EqualRect(&rcOldScrn, &rcScreen))
{
ptDefPos[STATE_WINDOW].x = rcScreen.right - STATEXSIZE - GetSystemMetrics(SM_CXBORDER)
- GetSystemMetrics(SM_CXVSCROLL) - GetSystemMetrics(SM_CXHSCROLL);
ptDefPos[STATE_WINDOW].y = rcScreen.bottom - STATEYSIZE;
ptDefPos[COMP_WINDOW].x = ptDefPos[STATE_WINDOW].x + STATEXSIZE + GAPX;
ptDefPos[COMP_WINDOW].y = ptDefPos[STATE_WINDOW].y + GAPY;
ptDefPos[CAND_WINDOW].x = rcScreen.right - CANDXSIZE;
ptDefPos[CAND_WINDOW].y = rcScreen.bottom - CANDYSIZE;
if (ptState.x == -1 && ptState.y == -1)
{
if (RegOpenKey(HKEY_CURRENT_USER, szIMEKey, &hKey) == ERROR_SUCCESS)
{
dwCb = sizeof(dwBuf);
if (RegQueryValueEx(hKey, szStatePos, NULL, NULL, (LPBYTE)&dwBuf, &dwCb)
== ERROR_SUCCESS)
{
ptState.x = HIWORD(dwBuf);
ptState.y = LOWORD(dwBuf);
wWndCmd[STATE_WINDOW] = wWndCmd[COMP_WINDOW] = 0x04; // MCW_SCREEN
}
else
ptState = ptDefPos[STATE_WINDOW];
dwCb = sizeof(dwBuf);
if (RegQueryValueEx(hKey, szCandPos, NULL, NULL, (LPBYTE)&dwBuf, &dwCb)
== ERROR_SUCCESS)
{
ptCand.x = HIWORD(dwBuf);
ptCand.y = LOWORD(dwBuf);
}
else
ptCand = ptDefPos[CAND_WINDOW];
RegCloseKey(hKey);
}
else
{
ptState = ptDefPos[STATE_WINDOW];
ptCand = ptDefPos[CAND_WINDOW];
}
dwScreenRes = MAKELONG(GetSystemMetrics(SM_CXSCREEN), GetSystemMetrics(SM_CYSCREEN));
}
else
{
ptState.x += rcScreen.left - rcOldScrn.left;
ptState.y += rcScreen.top - rcOldScrn.top;
ptComp.x += rcScreen.left - rcOldScrn.left;
ptComp.y += rcScreen.top - rcOldScrn.top;
ptCand.x += rcScreen.left - rcOldScrn.left;
ptCand.y += rcScreen.top - rcOldScrn.top;
}
if (ptState.x < rcScreen.left)
ptState.x = rcScreen.left;
else if (ptState.x > rcScreen.right - STATEXSIZE)
ptState.x = rcScreen.right - STATEXSIZE;
if (ptState.y < rcScreen.top)
ptState.y = rcScreen.top;
else if (ptState.y > rcScreen.bottom - STATEYSIZE)
ptState.y = rcScreen.bottom - STATEYSIZE;
ptComp.x = (ptState.x + STATEXSIZE + GAPX + COMPSIZE > rcScreen.right)?
ptState.x - GAPX - COMPSIZE: ptState.x + STATEXSIZE + GAPX;
ptComp.y = ptState.y + GAPY;
if (ptCand.x < rcScreen.left)
ptCand.x = rcScreen.left;
else if (ptCand.x > rcScreen.right - CANDXSIZE)
ptCand.x = rcScreen.right - CANDXSIZE;
if (ptCand.y < rcScreen.top)
ptCand.y = rcScreen.top;
else if (ptCand.y > rcScreen.bottom - CANDYSIZE)
ptCand.y = rcScreen.bottom - CANDYSIZE;
rcOldScrn = rcScreen;
}
}
BOOL InitializeResource(HANDLE hInstance)
{
hBMClient = MyCreateMappedBitmap(hInst, TEXT("Client"));
hBMEng = MyCreateMappedBitmap(hInst, TEXT("English"));
hBMHan = MyCreateMappedBitmap(hInst, TEXT("Hangeul"));
hBMBan = MyCreateMappedBitmap(hInst, TEXT("Banja"));
hBMJun = MyCreateMappedBitmap(hInst, TEXT("Junja"));
hBMChi[0] = MyCreateMappedBitmap(hInst, TEXT("ChineseOff"));
hBMChi[1] = MyCreateMappedBitmap(hInst, TEXT("ChineseOn"));
hBMComp = MyCreateMappedBitmap(hInst, TEXT("Composition"));
hBMCand = MyCreateMappedBitmap(hInst, TEXT("Candidate"));
hBMCandNum = MyCreateMappedBitmap(hInst, TEXT("CandNumber"));
hBMCandArr[0] = MyCreateMappedBitmap(hInst, TEXT("CandArrow1"));
hBMCandArr[1] = MyCreateMappedBitmap(hInst, TEXT("CandArrow2"));
hIMECursor = LoadCursor(hInstance, TEXT("MyHand"));
#ifdef JOHAB_IME
hFontFix = CreateFont(-16,0,0,0,0,0,0,0,130,OUT_DEFAULT_PRECIS,
CLIP_DEFAULT_PRECIS,DEFAULT_QUALITY,FIXED_PITCH,TEXT("<EFBFBD><EFBFBD><EFBFBD><EFBFBD>"));
#else
hFontFix = CreateFont(-16,0,0,0,0,0,0,0,129,OUT_DEFAULT_PRECIS,
CLIP_DEFAULT_PRECIS,DEFAULT_QUALITY,FIXED_PITCH,TEXT("<EFBFBD><EFBFBD><EFBFBD><EFBFBD>"));
#endif
return TRUE;
}
BOOL RegisterUIClass(HANDLE hInstance)
{
BOOL fRet = TRUE;
WNDCLASSEX wc;
wc.cbSize = sizeof(WNDCLASSEX);
wc.style = CS_VREDRAW | CS_HREDRAW | CS_IME;
wc.cbClsExtra = 0;
wc.hInstance = hInstance;
wc.hCursor = LoadCursor(NULL, IDC_ARROW);
wc.hIcon = NULL;
wc.hIconSm = NULL;
wc.lpszMenuName = (LPTSTR)NULL;
wc.hbrBackground = NULL;
wc.cbWndExtra = 8;
wc.lpfnWndProc = UIWndProc;
wc.lpszClassName = (LPTSTR)szUIClassName;
if (!RegisterClassEx((LPWNDCLASSEX)&wc))
{
MyDebugOut(MDB_LOG, "RegisterClassEx() Failed for UIWindow.");
fRet = FALSE;
}
wc.style = CS_VREDRAW | CS_HREDRAW | CS_IME;
wc.cbWndExtra = 4;
wc.lpfnWndProc = StateWndProc;
wc.lpszClassName = (LPTSTR)szStateWndName;
if (!RegisterClassEx((LPWNDCLASSEX)&wc))
{
MyDebugOut(MDB_LOG, "RegisterClassEx() Failed for StateWindow.");
fRet = FALSE;
}
wc.lpfnWndProc = CompWndProc;
wc.lpszClassName = (LPTSTR)szCompWndName;
if (!RegisterClassEx((LPWNDCLASSEX)&wc))
{
MyDebugOut(MDB_LOG, "RegisterClassEx() Failed for CompWindow.");
fRet = FALSE;
}
wc.lpfnWndProc = CandWndProc;
wc.lpszClassName = (LPTSTR)szCandWndName;
if (!RegisterClassEx((LPWNDCLASSEX)&wc))
{
MyDebugOut(MDB_LOG, "RegisterClassEx() Failed for CandWindow.");
fRet = FALSE;
}
return fRet;
}
BOOL UnregisterUIClass(HANDLE hInstance)
{
BOOL fRet = TRUE;
if (!UnregisterClass(szUIClassName, hInstance))
{
MyDebugOut(MDB_LOG, "UnregisterClass() Failed for UIWindow.");
fRet = FALSE;
}
if (!UnregisterClass(szStateWndName, hInstance))
{
MyDebugOut(MDB_LOG, "UnregisterClass() Failed for StateWindow.");
fRet = FALSE;
}
if (!UnregisterClass(szCompWndName, hInstance))
{
MyDebugOut(MDB_LOG, "UnregisterClass() Failed for CompWindow.");
fRet = FALSE;
}
if (!UnregisterClass(szCandWndName, hInstance))
{
MyDebugOut(MDB_LOG, "UnregisterClass() Failed for CandWindow.");
fRet = FALSE;
}
return fRet;
}
void DrawBitmap(HDC hDC, long xStart, long yStart, HBITMAP hBitmap)
{
HDC hMemDC;
HBITMAP hBMOld;
BITMAP bm;
POINT pt;
hMemDC = CreateCompatibleDC(hDC);
hBMOld = SelectObject(hMemDC, hBitmap);
GetObject(hBitmap, sizeof(BITMAP), (LPSTR)&bm);
pt.x = bm.bmWidth;
pt.y = bm.bmHeight;
BitBlt(hDC, xStart, yStart, pt.x, pt.y, hMemDC, 0, 0, SRCCOPY);
SelectObject(hMemDC, hBMOld);
DeleteDC(hMemDC);
return;
}
void ShowWindowBorder(RECT rc)
{
HDC hDC;
HBRUSH hBrOld;
int cxBorder, cyBorder;
hDC = CreateDC(TEXT("DISPLAY"), NULL, NULL, NULL);
hBrOld = SelectObject(hDC, GetStockObject(GRAY_BRUSH));
cxBorder = GetSystemMetrics(SM_CXBORDER);
cyBorder = GetSystemMetrics(SM_CYBORDER);
PatBlt(hDC, rc.left, rc.top, rc.right-rc.left-cxBorder, cyBorder, PATINVERT);
PatBlt(hDC, rc.right-cxBorder, rc.top, cxBorder, rc.bottom-rc.top-cyBorder, PATINVERT);
PatBlt(hDC, rc.right, rc.bottom-cyBorder, -(rc.right-rc.left-cxBorder), cyBorder, PATINVERT);
PatBlt(hDC, rc.left, rc.bottom, cxBorder, -(rc.bottom-rc.top-cyBorder), PATINVERT);
SelectObject(hDC, hBrOld);
DeleteDC(hDC);
return;
}
void ShowHideUIWnd(HIMC hIMC, LPUIINSTANCE lpUIInst, BOOL fShow, LPARAM lParam)
{
LPINPUTCONTEXT lpIMC;
LPCOMPOSITIONSTRING lpCompStr;
DWORD fdwUIFlags;
if (fShow && hIMC && (lpIMC = ImmLockIMC(hIMC)))
{
UpdateUIPosition();
fdwUIFlags = (DWORD)GetWindowLong(lpUIInst->rghWnd[STATE_WINDOW], UIGWL_FLAGS);
if (!(fdwUIFlags & UIF_PRIVATEPOS))
lpIMC->ptStatusWndPos = ptState;
MoveWindow(lpUIInst->rghWnd[STATE_WINDOW], lpIMC->ptStatusWndPos.x,
lpIMC->ptStatusWndPos.y, STATEXSIZE, STATEYSIZE, TRUE);
if (lpIMC->cfCompForm.dwStyle == CFS_DEFAULT)
{
MoveWindow(lpUIInst->rghWnd[COMP_WINDOW], ptComp.x, ptComp.y, COMPSIZE, COMPSIZE, TRUE);
}
if (fWndOpen[STATE_WINDOW] != FALSE && (fdwUIFlags & UIF_SHOWSTATUS))
ShowWindow(lpUIInst->rghWnd[STATE_WINDOW], SW_SHOWNOACTIVATE);
else
ShowWindow(lpUIInst->rghWnd[STATE_WINDOW], SW_HIDE);
lpCompStr = (LPCOMPOSITIONSTRING)ImmLockIMCC(lpIMC->hCompStr);
if (lpCompStr && lpCompStr->dwCompStrLen
&& fWndOpen[COMP_WINDOW] && (lParam & ISC_SHOWUICOMPOSITIONWINDOW))
ShowWindow(lpUIInst->rghWnd[COMP_WINDOW], SW_SHOWNOACTIVATE);
else
ShowWindow(lpUIInst->rghWnd[COMP_WINDOW], SW_HIDE);
if (lpIMC->fdwConversion & IME_CMODE_HANJACONVERT
&& fWndOpen[CAND_WINDOW] && (lParam & ISC_SHOWUICANDIDATEWINDOW))
ShowWindow(lpUIInst->rghWnd[CAND_WINDOW], SW_SHOWNOACTIVATE);
else
ShowWindow(lpUIInst->rghWnd[CAND_WINDOW], SW_HIDE);
ImmUnlockIMCC(lpIMC->hCompStr);
ImmUnlockIMC(hIMC);
}
else
{
ShowWindow(lpUIInst->rghWnd[STATE_WINDOW], SW_HIDE);
ShowWindow(lpUIInst->rghWnd[COMP_WINDOW], SW_HIDE);
ShowWindow(lpUIInst->rghWnd[CAND_WINDOW], SW_HIDE);
}
}
LRESULT CALLBACK UIWndProc(HWND hWnd, UINT uMessage, WPARAM wParam, LPARAM lParam)
{
HGLOBAL hUIInst;
LPUIINSTANCE lpUIInst;
switch (uMessage)
{
case WM_CREATE:
hUIInst = GlobalAlloc(GHND, sizeof(UIINSTANCE));
lpUIInst = (LPUIINSTANCE)GlobalLock(hUIInst);
lpUIInst->rghWnd[STATE_WINDOW] = CreateWindow(szStateWndName, TEXT("\0"),
WS_DISABLED | WS_POPUP, ptState.x, ptState.y,
STATEXSIZE, STATEYSIZE, hWnd, NULL, hInst, NULL);
lpUIInst->rghWnd[COMP_WINDOW] = CreateWindow(szCompWndName, TEXT("\0"),
WS_DISABLED | WS_POPUP, ptComp.x, ptComp.y,
COMPSIZE, COMPSIZE, hWnd, NULL, hInst, NULL );
lpUIInst->rghWnd[CAND_WINDOW] = CreateWindow(szCandWndName, TEXT("\0"),
WS_DISABLED | WS_POPUP, ptCand.x, ptCand.y,
CANDXSIZE, CANDYSIZE, hWnd, NULL, hInst, NULL );
GlobalUnlock(hUIInst);
SetWindowLongPtr(hWnd, IMMGWL_PRIVATE, (LONG_PTR)hUIInst);
return 0;
case WM_DESTROY:
hUIInst = (HGLOBAL)GetWindowLongPtr(hWnd, IMMGWL_PRIVATE);
lpUIInst = (LPUIINSTANCE)GlobalLock(hUIInst);
DestroyWindow(lpUIInst->rghWnd[STATE_WINDOW]);
DestroyWindow(lpUIInst->rghWnd[COMP_WINDOW]);
DestroyWindow(lpUIInst->rghWnd[CAND_WINDOW]);
GlobalUnlock(hUIInst);
GlobalFree(hUIInst);
SetWindowLongPtr(hWnd, IMMGWL_PRIVATE, (LONG_PTR)0);
return 0;
case WM_IME_SELECT:
hUIInst = (HGLOBAL)GetWindowLongPtr(hWnd, IMMGWL_PRIVATE);
lpUIInst = (LPUIINSTANCE)GlobalLock(hUIInst);
ShowHideUIWnd(GetWindowLongPtr(hWnd, IMMGWL_IMC), lpUIInst, wParam, ISC_SHOWUIALL);
GlobalUnlock(hUIInst);
return 0;
case WM_IME_COMPOSITION:
hUIInst = (HGLOBAL)GetWindowLongPtr(hWnd, IMMGWL_PRIVATE);
lpUIInst = (LPUIINSTANCE)GlobalLock(hUIInst);
InvalidateRect(lpUIInst->rghWnd[COMP_WINDOW], NULL, TRUE);
GlobalUnlock(hUIInst);
return 0;
case WM_IME_CONTROL:
return (LRESULT)DoIMEControl(hWnd, wParam, lParam);
case WM_IME_NOTIFY:
return (LRESULT)DoIMENotify(hWnd, wParam, lParam);
case WM_IME_SETCONTEXT:
hUIInst = (HGLOBAL)GetWindowLongPtr(hWnd, IMMGWL_PRIVATE);
lpUIInst = (LPUIINSTANCE)GlobalLock(hUIInst);
ShowHideUIWnd(GetWindowLongPtr(hWnd, IMMGWL_IMC), lpUIInst, wParam, lParam);
GlobalUnlock(hUIInst);
return 0;
case WM_IME_STARTCOMPOSITION:
hUIInst = (HGLOBAL)GetWindowLongPtr(hWnd, IMMGWL_PRIVATE);
lpUIInst = (LPUIINSTANCE)GlobalLock(hUIInst);
ShowWindow(lpUIInst->rghWnd[COMP_WINDOW], fWndOpen[COMP_WINDOW]? SW_SHOWNOACTIVATE: SW_HIDE);
GlobalUnlock(hUIInst);
return 0;
case WM_IME_ENDCOMPOSITION:
hUIInst = (HGLOBAL)GetWindowLongPtr(hWnd, IMMGWL_PRIVATE);
lpUIInst = (LPUIINSTANCE)GlobalLock(hUIInst);
ShowWindow(lpUIInst->rghWnd[COMP_WINDOW], SW_HIDE);
GlobalUnlock(hUIInst);
return 0;
case WM_SYSCOLORCHANGE:
GetSysColorsAndMappedBitmap();
return 0;
case WM_DISPLAYCHANGE:
if (dwScreenRes != (DWORD)lParam)
{
ptState.x += LOWORD(lParam) - LOWORD(dwScreenRes);
ptState.y += HIWORD(lParam) - HIWORD(dwScreenRes);
ptComp.x += LOWORD(lParam) - LOWORD(dwScreenRes);
ptComp.y += HIWORD(lParam) - HIWORD(dwScreenRes);
ptCand.x += LOWORD(lParam) - LOWORD(dwScreenRes);
ptCand.y += HIWORD(lParam) - HIWORD(dwScreenRes);
dwScreenRes = MAKELONG(GetSystemMetrics(SM_CXSCREEN), GetSystemMetrics(SM_CYSCREEN));
}
return 0;
}
return DefWindowProc(hWnd, uMessage, wParam, lParam);
}
LRESULT CALLBACK StateWndProc(HWND hWnd, UINT uMessage, WPARAM wParam, LPARAM lParam)
{
switch (uMessage)
{
HANDLE_DUMMYMSG(WM_IME_CHAR);
HANDLE_DUMMYMSG(WM_IME_COMPOSITIONFULL);
HANDLE_DUMMYMSG(WM_IME_COMPOSITION);
HANDLE_DUMMYMSG(WM_IME_CONTROL);
HANDLE_DUMMYMSG(WM_IME_NOTIFY);
HANDLE_DUMMYMSG(WM_IME_SELECT);
HANDLE_DUMMYMSG(WM_IME_SETCONTEXT);
HANDLE_DUMMYMSG(WM_IME_STARTCOMPOSITION);
HANDLE_DUMMYMSG(WM_IME_ENDCOMPOSITION);
HANDLE_MSG(hWnd, WM_SETCURSOR, State_OnSetCursor);
HANDLE_MSG(hWnd, WM_MOUSEMOVE, State_OnMouseMove);
HANDLE_MSG(hWnd, WM_LBUTTONUP, State_OnLButtonUp);
HANDLE_MSG(hWnd, WM_PAINT, State_OnPaint);
HANDLE_MSG(hWnd, WM_COMMAND, State_OnCommand);
}
return DefWindowProc(hWnd, uMessage, wParam, lParam);
}
BOOL State_OnSetCursor(HWND hWnd, HWND hWndCursor, UINT codeHitTest, UINT msg)
{
HWND hWndUI;
HIMC hIMC;
DWORD fdwUIFlags;
SetCursor(hIMECursor);
switch (msg)
{
case WM_LBUTTONDOWN:
GetCursorPos(&ptPos);
ScreenToClient(hWnd, &ptPos);
fdwUIFlags = (DWORD)GetWindowLong(hWnd, UIGWL_FLAGS);
if (PtInRect((LPRECT)&rcHan, ptPos))
{
fdwUIFlags |= UIF_HANPRESS;
}
else if (PtInRect((LPRECT)&rcJun, ptPos))
{
fdwUIFlags |= UIF_JUNPRESS;
}
else if (PtInRect((LPRECT)&rcChi, ptPos))
{
fdwUIFlags |= UIF_CHIPRESS;
}
else
{
fdwUIFlags |= UIF_WNDMOVE;
GetWindowRect(hWnd, &rc);
ShowWindowBorder(rc);
SetCapture(hWnd);
}
SetWindowLong(hWnd, UIGWL_FLAGS, fdwUIFlags);
break;
case WM_LBUTTONUP:
GetCursorPos(&ptPos);
ScreenToClient(hWnd, &ptPos);
fdwUIFlags = (DWORD)GetWindowLong( hWnd, UIGWL_FLAGS );
if ((fdwUIFlags & UIF_HANPRESS) && PtInRect((LPRECT)&rcHan, ptPos))
{
fdwUIFlags &= ~UIF_HANPRESS;
keybd_event(VK_HANGEUL, 0, 0, 0);
keybd_event(VK_HANGEUL, 0, KEYEVENTF_KEYUP, 0);
}
else if ((fdwUIFlags & UIF_JUNPRESS) && PtInRect((LPRECT)&rcJun, ptPos))
{
fdwUIFlags &= ~UIF_JUNPRESS;
keybd_event(VK_JUNJA, 0, 0, 0);
keybd_event(VK_JUNJA, 0, KEYEVENTF_KEYUP, 0);
}
else if ((fdwUIFlags & UIF_CHIPRESS) && PtInRect((LPRECT)&rcChi, ptPos))
{
fdwUIFlags &= ~UIF_CHIPRESS;
keybd_event(VK_HANJA, 0, 0, 0);
keybd_event(VK_HANJA, 0, KEYEVENTF_KEYUP, 0);
}
else
fdwUIFlags &= ~(UIF_HANPRESS | UIF_JUNPRESS | UIF_CHIPRESS);
SetWindowLong(hWnd, UIGWL_FLAGS, fdwUIFlags);
break;
case WM_RBUTTONDOWN:
hWndUI = GetWindow(hWnd, GW_OWNER);
hIMC = (HIMC)GetWindowLongPtr(hWndUI, IMMGWL_IMC);
if (bState) MakeFinalMsgBuf(hIMC, 0);
break;
case WM_RBUTTONUP:
State_OnMyMenu(hWnd);
break;
}
return TRUE;
}
void State_OnMouseMove(HWND hWnd, int x, int y, UINT keyFlags)
{
DWORD fdwUIFlags;
fdwUIFlags = (DWORD)GetWindowLong(hWnd, UIGWL_FLAGS);
if (fdwUIFlags & UIF_WNDMOVE)
{
ShowWindowBorder(rc);
rc.left += x - ptPos.x;
rc.top += y - ptPos.y;
rc.right += x - ptPos.x;
rc.bottom += y - ptPos.y;
ShowWindowBorder(rc);
ptPos.x = x;
ptPos.y = y;
}
return;
UNREFERENCED_PARAMETER(keyFlags);
}
void State_OnLButtonUp(HWND hWnd, int x, int y, UINT keyFlags)
{
HKEY hKey;
DWORD fdwUIFlags, dwBuf, dwCb;
HGLOBAL hUIInst;
LPUIINSTANCE lpUIInst;
HWND hWndUI;
HIMC hIMC;
LPINPUTCONTEXT lpIMC;
ReleaseCapture();
fdwUIFlags = (DWORD)GetWindowLong(hWnd, UIGWL_FLAGS);
if (fdwUIFlags & UIF_WNDMOVE)
{
ShowWindowBorder(rc);
MoveWindow(hWnd, rc.left, rc.top, STATEXSIZE, STATEYSIZE, TRUE);
ptState.x = rc.left;
ptState.y = rc.top;
if (RegCreateKey(HKEY_CURRENT_USER, szIMEKey, &hKey) == ERROR_SUCCESS)
{
dwCb = sizeof(dwBuf);
dwBuf = (ptState.x << 16) | (ptState.y & 0x0FFFF); // HIWORD : X, LOWORD : Y
RegSetValueEx(hKey, szStatePos, 0, REG_DWORD, (LPBYTE)&dwBuf, dwCb);
RegCloseKey(hKey);
}
ptComp.x = (ptState.x + STATEXSIZE + GAPX + COMPSIZE > rcScreen.right)?
ptState.x - GAPX - COMPSIZE: ptState.x + STATEXSIZE + GAPX;
ptComp.y = ptState.y + GAPY;
hWndUI = GetWindow(hWnd, GW_OWNER);
hIMC = (HIMC)GetWindowLongPtr(hWndUI, IMMGWL_IMC);
lpIMC = ImmLockIMC(hIMC);
if (lpIMC != NULL) {
lpIMC->ptStatusWndPos = ptState;
if (lpIMC->cfCompForm.dwStyle == CFS_DEFAULT)
{
hUIInst = (HGLOBAL)GetWindowLongPtr(GetWindow(hWnd, GW_OWNER), IMMGWL_PRIVATE);
lpUIInst = (LPUIINSTANCE)GlobalLock(hUIInst);
MoveWindow(lpUIInst->rghWnd[COMP_WINDOW], ptComp.x, ptComp.y, COMPSIZE, COMPSIZE, TRUE);
GlobalUnlock(hUIInst);
lpIMC->cfCompForm.ptCurrentPos = ptComp;
}
ImmUnlockIMC(hIMC);
}
wWndCmd[STATE_WINDOW] = wWndCmd[COMP_WINDOW] = 0x04; // MCW_SCREEN
fdwUIFlags &= ~UIF_WNDMOVE;
}
SetWindowLong(hWnd, UIGWL_FLAGS, fdwUIFlags);
return;
UNREFERENCED_PARAMETER(x);
UNREFERENCED_PARAMETER(y);
UNREFERENCED_PARAMETER(keyFlags);
}
typedef struct tagCOLORMAP
{
COLORREF bgrfrom;
COLORREF bgrto;
COLORREF sysColor;
} COLORMAP;
// these are the default colors used to map the dib colors
// to the current system colors
#define BGR_BUTTONTEXT (RGB(000,000,000)) // black
#define BGR_BUTTONSHADOW (RGB(128,128,128)) // dark grey
#define BGR_BUTTONFACE (RGB(192,192,192)) // bright grey
#define BGR_BUTTONHILIGHT (RGB(255,255,255)) // white
#define BGR_BACKGROUNDSEL (RGB(255,000,000)) // blue
#define BGR_BACKGROUND (RGB(255,000,255)) // magenta
#define FlipColor(rgb) (RGB(GetBValue(rgb), GetGValue(rgb), GetRValue(rgb)))
HBITMAP MyCreateMappedBitmap(HINSTANCE hInstance, LPTSTR lpszBitmap)
{
HDC hdc, hdcMem = NULL;
HANDLE h;
LPDWORD p;
LPSTR lpBits;
HANDLE hRes;
LPBITMAPINFOHEADER lpBitmapInfo, lpTmpBMInfo;
HBITMAP hbm = NULL, hbmOld;
int numcolors, i, wid, hgt;
static COLORMAP ColorMap[] =
{
{BGR_BUTTONTEXT, BGR_BUTTONTEXT, COLOR_BTNTEXT}, // black
{BGR_BUTTONSHADOW, BGR_BUTTONSHADOW, COLOR_BTNSHADOW}, // dark grey
{BGR_BUTTONFACE, BGR_BUTTONFACE, COLOR_BTNFACE}, // bright grey
{BGR_BUTTONHILIGHT, BGR_BUTTONHILIGHT, COLOR_BTNHIGHLIGHT},// white
{BGR_BACKGROUNDSEL, BGR_BACKGROUNDSEL, COLOR_HIGHLIGHT}, // blue
{BGR_BACKGROUND, BGR_BACKGROUND, COLOR_WINDOW} // magenta
};
#define NUM_MAPS (sizeof(ColorMap)/sizeof(COLORMAP))
h = FindResource(hInstance, lpszBitmap, RT_BITMAP);
if (!h)
return NULL;
hRes = LoadResource(hInstance, h);
/* Lock the bitmap and get a pointer to the color table. */
lpBitmapInfo = (LPBITMAPINFOHEADER)LockResource(hRes);
if (!lpBitmapInfo)
return NULL;
// HACK: We need to use temp copy of BITMAPINFO because original info is destroyed
// after change color. It cause next time LoadResource result has wrong info.
i = sizeof(BITMAPINFOHEADER) + 16*sizeof(RGBQUAD);
lpTmpBMInfo = (LPBITMAPINFOHEADER) LocalAlloc(LPTR, i);
if (!lpTmpBMInfo) {
UnlockResource(hRes);
FreeResource(hRes);
return NULL;
}
CopyMemory(lpTmpBMInfo, lpBitmapInfo, i);
//
// So what are the new colors anyway ?
//
for (i=0; i < NUM_MAPS; i++)
ColorMap[i].bgrto = FlipColor(GetSysColor((int)ColorMap[i].sysColor));
// HACK: ??? p = (LPDWORD)(((LPSTR)lpBitmapInfo) + lpBitmapInfo->biSize);
p = (LPDWORD)(((LPSTR)lpTmpBMInfo) + lpTmpBMInfo->biSize);
/* Replace button-face and button-shadow colors with the current values
*/
numcolors = 16;
while (numcolors-- > 0)
{
for (i = 0; i < NUM_MAPS; i++)
{
if (*p == ColorMap[i].bgrfrom)
{
*p = ColorMap[i].bgrto;
break;
}
}
p++;
}
/* First skip over the header structure */
lpBits = (LPSTR)(lpBitmapInfo + 1);
/* Skip the color table entries, if any */
lpBits += (1 << (lpBitmapInfo->biBitCount)) * sizeof(RGBQUAD);
/* Create a color bitmap compatible with the display device */
i = wid = (int)lpBitmapInfo->biWidth;
hgt = (int)lpBitmapInfo->biHeight;
hdc = GetDC(NULL);
hdcMem = CreateCompatibleDC(hdc);
if (hdcMem)
{
hbm = CreateDiscardableBitmap(hdc, i, hgt);
if (hbm)
{
hbmOld = SelectObject(hdcMem, hbm);
// set the main image
StretchDIBits(hdcMem, 0, 0, wid, hgt, 0, 0, wid, hgt, lpBits,
(LPBITMAPINFO)lpTmpBMInfo, DIB_RGB_COLORS, SRCCOPY);
SelectObject(hdcMem, hbmOld);
}
DeleteObject(hdcMem);
}
ReleaseDC(NULL, hdc);
UnlockResource(hRes);
FreeResource(hRes);
// HACK: Remove hack temp BITMAPINFO.
LocalFree(lpTmpBMInfo);
return hbm;
}
void GetSysColorsAndMappedBitmap(void)
{
static DWORD rgbFace, rgbShadow, rgbHilight, rgbFrame;
static COLORREF rgbSaveFace = 0xFFFFFFFFL,
rgbSaveShadow = 0xFFFFFFFFL,
rgbSaveHilight = 0xFFFFFFFFL,
rgbSaveFrame = 0xFFFFFFFFL;
rgbFace = GetSysColor(COLOR_BTNFACE);
rgbShadow = GetSysColor(COLOR_BTNSHADOW);
rgbHilight = GetSysColor(COLOR_BTNHIGHLIGHT);
rgbFrame = GetSysColor(COLOR_WINDOWFRAME);
if (rgbSaveFace != rgbFace || rgbSaveShadow != rgbShadow
|| rgbSaveHilight != rgbHilight || rgbSaveFrame != rgbFrame)
{
rgbSaveFace = rgbFace;
rgbSaveShadow = rgbShadow;
rgbSaveHilight = rgbHilight;
rgbSaveFrame = rgbFrame;
DeleteObject(hBMClient);
DeleteObject(hBMEng);
DeleteObject(hBMHan);
DeleteObject(hBMBan);
DeleteObject(hBMJun);
DeleteObject(hBMChi[0]);
DeleteObject(hBMChi[1]);
DeleteObject(hBMComp);
DeleteObject(hBMCand);
DeleteObject(hBMCandNum);
DeleteObject(hBMCandArr[0]);
DeleteObject(hBMCandArr[1]);
hBMClient = MyCreateMappedBitmap(hInst, TEXT("Client"));
hBMEng = MyCreateMappedBitmap(hInst, TEXT("English"));
hBMHan = MyCreateMappedBitmap(hInst, TEXT("Hangeul"));
hBMBan = MyCreateMappedBitmap(hInst, TEXT("Banja"));
hBMJun = MyCreateMappedBitmap(hInst, TEXT("Junja"));
hBMChi[0] = MyCreateMappedBitmap(hInst, TEXT("ChineseOff"));
hBMChi[1] = MyCreateMappedBitmap(hInst, TEXT("ChineseOn"));
hBMComp = MyCreateMappedBitmap(hInst, TEXT("Composition"));
hBMCand = MyCreateMappedBitmap(hInst, TEXT("Candidate"));
hBMCandNum = MyCreateMappedBitmap(hInst, TEXT("CandNumber"));
hBMCandArr[0] = MyCreateMappedBitmap(hInst, TEXT("CandArrow1"));
hBMCandArr[1] = MyCreateMappedBitmap(hInst, TEXT("CandArrow2"));
}
}
void State_OnPaint(HWND hWnd)
{
HDC hDC;
HWND hWndUI;
HIMC hIMC;
LPINPUTCONTEXT lpIMC;
PAINTSTRUCT ps;
DWORD fdwUIFlags;
hDC = BeginPaint(hWnd, &ps);
hWndUI = GetWindow(hWnd, GW_OWNER);
hIMC = (HIMC)GetWindowLongPtr(hWndUI, IMMGWL_IMC);
if (hIMC && (lpIMC = ImmLockIMC(hIMC)))
{
fdwUIFlags = (DWORD)GetWindowLong(hWnd, UIGWL_FLAGS);
DrawBitmap(hDC, 0, 0, hBMClient);
DrawBitmap(hDC, rcHan.left, rcHan.top,
(lpIMC->fOpen && (lpIMC->fdwConversion & IME_CMODE_HANGEUL))? hBMHan: hBMEng);
DrawBitmap(hDC, rcJun.left, rcJun.top,
(lpIMC->fOpen && (lpIMC->fdwConversion & IME_CMODE_FULLSHAPE))? hBMJun: hBMBan);
DrawBitmap(hDC, rcChi.left, rcChi.top,
(lpIMC->fdwConversion & IME_CMODE_HANJACONVERT)? hBMChi[1]: hBMChi[0]);
ImmUnlockIMC(hIMC);
}
EndPaint(hWnd, &ps);
}
void State_OnCommand(HWND hWnd, int id, HWND hWndCtl, UINT codeNotify)
{
switch (id)
{
case IDM_CONFIG:
State_OnMyConfig(hWnd);
break;
case IDM_ABOUT:
State_OnMyAbout(hWnd);
break;
}
}
void State_OnMyMenu(HWND hWnd)
{
HMENU hMenu;
POINT ptCurrent;
TCHAR szBuffer[256];
GetCursorPos(&ptCurrent);
hMenu = CreatePopupMenu();
LoadString(hInst, IDS_CONFIG, szBuffer, sizeof(szBuffer));
AppendMenu(hMenu, MF_ENABLED, IDM_CONFIG, szBuffer);
AppendMenu(hMenu, MF_SEPARATOR, 0, NULL);
LoadString(hInst, IDS_ABOUT, szBuffer, sizeof(szBuffer));
AppendMenu(hMenu, MF_ENABLED, IDM_ABOUT, szBuffer);
TrackPopupMenu(hMenu, TPM_LEFTALIGN, ptCurrent.x, ptCurrent.y, 0, hWnd, NULL);
DestroyMenu(hMenu);
}
void State_OnMyConfig(HWND hWnd)
{
HIMC hIMC;
LPINPUTCONTEXT lpIMC;
hIMC = (HIMC)GetWindowLongPtr(GetWindow(hWnd, GW_OWNER), IMMGWL_IMC);
if (lpIMC = ImmLockIMC(hIMC))
{
ImeConfigure(0, lpIMC->hWnd, IME_CONFIG_GENERAL, NULL);
ImmUnlockIMC(hIMC);
}
}
void State_OnMyAbout(HWND hWnd)
{
HIMC hIMC;
LPINPUTCONTEXT lpIMC;
TCHAR szBuffer[256];
hIMC = (HIMC)GetWindowLongPtr(GetWindow(hWnd, GW_OWNER), IMMGWL_IMC);
if (lpIMC = ImmLockIMC(hIMC))
{
LoadString(hInst, IDS_PROGRAM, szBuffer, sizeof(szBuffer));
ShellAbout(lpIMC->hWnd, szBuffer, NULL, LoadIcon(hInst, TEXT("IMEIcon")));
ImmUnlockIMC(hIMC);
}
}
LRESULT CALLBACK CompWndProc(HWND hWnd, UINT uMessage, WPARAM wParam, LPARAM lParam)
{
switch (uMessage)
{
HANDLE_DUMMYMSG(WM_IME_CHAR);
HANDLE_DUMMYMSG(WM_IME_COMPOSITIONFULL);
HANDLE_DUMMYMSG(WM_IME_COMPOSITION);
HANDLE_DUMMYMSG(WM_IME_CONTROL);
HANDLE_DUMMYMSG(WM_IME_NOTIFY);
HANDLE_DUMMYMSG(WM_IME_SELECT);
HANDLE_DUMMYMSG(WM_IME_SETCONTEXT);
HANDLE_DUMMYMSG(WM_IME_STARTCOMPOSITION);
HANDLE_DUMMYMSG(WM_IME_ENDCOMPOSITION);
HANDLE_MSG(hWnd, WM_PAINT, Comp_OnPaint);
}
return DefWindowProc(hWnd, uMessage, wParam, lParam);
}
void Comp_OnPaint(HWND hWnd)
{
HDC hDC;
HWND hWndUI;
HIMC hIMC;
LPINPUTCONTEXT lpIMC;
LPCOMPOSITIONSTRING lpUICompStr;
PAINTSTRUCT ps;
HFONT hOldFont;
int iSaveBkMode;
hDC = BeginPaint(hWnd, &ps);
hWndUI = GetWindow(hWnd, GW_OWNER);
hIMC = (HIMC)GetWindowLongPtr(hWndUI, IMMGWL_IMC);
lpIMC = ImmLockIMC(hIMC);
if (lpIMC) {
lpUICompStr = (LPCOMPOSITIONSTRING)ImmLockIMCC(lpIMC->hCompStr);
if (lpUICompStr && lpUICompStr->dwCompStrLen)
{
DrawBitmap(hDC, 0, 0, hBMComp);
iSaveBkMode = SetBkMode(hDC, TRANSPARENT);
hOldFont = SelectObject(hDC, hFontFix);
TextOut(hDC, 3, 3, (LPTSTR)lpUICompStr + lpUICompStr->dwCompStrOffset, 2);
SelectObject(hDC, hOldFont);
SetBkMode(hDC, iSaveBkMode);
}
ImmUnlockIMCC(lpIMC->hCompStr);
ImmUnlockIMC(hIMC);
}
EndPaint(hWnd, &ps);
}
LRESULT CALLBACK CandWndProc(HWND hWnd, UINT uMessage, WPARAM wParam, LPARAM lParam)
{
switch (uMessage)
{
HANDLE_DUMMYMSG(WM_IME_CHAR);
HANDLE_DUMMYMSG(WM_IME_COMPOSITIONFULL);
HANDLE_DUMMYMSG(WM_IME_COMPOSITION);
HANDLE_DUMMYMSG(WM_IME_CONTROL);
HANDLE_DUMMYMSG(WM_IME_NOTIFY);
HANDLE_DUMMYMSG(WM_IME_SELECT);
HANDLE_DUMMYMSG(WM_IME_SETCONTEXT);
HANDLE_DUMMYMSG(WM_IME_STARTCOMPOSITION);
HANDLE_DUMMYMSG(WM_IME_ENDCOMPOSITION);
HANDLE_MSG(hWnd, WM_SETCURSOR, Cand_OnSetCursor);
HANDLE_MSG(hWnd, WM_PAINT, Cand_OnPaint);
}
return DefWindowProc(hWnd, uMessage, wParam, lParam);
}
BOOL Cand_OnSetCursor(HWND hWnd, HWND hWndCursor, UINT codeHitTest, UINT msg)
{
int iLoop;
SetCursor(hIMECursor);
switch (msg)
{
case WM_LBUTTONDOWN:
GetCursorPos(&ptPos);
ScreenToClient(hWnd, &ptPos);
if (PtInRect((LPRECT)&rcCandCli, ptPos))
{
if (!PtInRect((LPRECT)&rcLArrow, ptPos)
&& !PtInRect((LPRECT)&rcRArrow, ptPos)
&& !PtInRect((LPRECT)&rcBtn[0], ptPos)
&& !PtInRect((LPRECT)&rcBtn[1], ptPos)
&& !PtInRect((LPRECT)&rcBtn[2], ptPos)
&& !PtInRect((LPRECT)&rcBtn[3], ptPos)
&& !PtInRect((LPRECT)&rcBtn[4], ptPos)
&& !PtInRect((LPRECT)&rcBtn[5], ptPos)
&& !PtInRect((LPRECT)&rcBtn[6], ptPos)
&& !PtInRect((LPRECT)&rcBtn[7], ptPos)
&& !PtInRect((LPRECT)&rcBtn[8], ptPos))
MessageBeep(MB_ICONEXCLAMATION);
}
break;
case WM_LBUTTONUP:
GetCursorPos(&ptPos);
ScreenToClient(hWnd, &ptPos);
if (PtInRect((LPRECT)&rcLArrow, ptPos))
{
keybd_event(VK_LEFT, 0, 0, 0);
keybd_event(VK_LEFT, 0, KEYEVENTF_KEYUP, 0);
}
else if (PtInRect((LPRECT)&rcRArrow, ptPos))
{
keybd_event(VK_RIGHT, 0, 0, 0);
keybd_event(VK_RIGHT, 0, KEYEVENTF_KEYUP, 0);
}
else
{
for (iLoop = 0; iLoop < 9; iLoop++)
if (PtInRect((LPRECT)&rcBtn[iLoop], ptPos))
{
keybd_event((BYTE)(iLoop + '1'), 0, 0, 0);
keybd_event((BYTE)(iLoop + '1'), 0, KEYEVENTF_KEYUP, 0);
break;
}
}
break;
}
return TRUE;
}
void Cand_OnPaint(HWND hWnd)
{
HDC hDC;
HWND hWndUI;
HIMC hIMC;
LPINPUTCONTEXT lpIMC;
LPCANDIDATEINFO lpCandInfo;
LPCANDIDATELIST lpCandList;
LPTSTR lpCandStr;
PAINTSTRUCT ps;
HFONT hOldFont;
DWORD iLoop, iStart;
int iSaveBkMode;
hDC = BeginPaint(hWnd, &ps);
hWndUI = GetWindow(hWnd, GW_OWNER);
hIMC = (HIMC)GetWindowLongPtr(hWndUI, IMMGWL_IMC);
lpIMC = ImmLockIMC(hIMC);
if (lpIMC != NULL) {
lpCandInfo = (LPCANDIDATEINFO)ImmLockIMCC(lpIMC->hCandInfo);
lpCandList = (LPCANDIDATELIST)((LPBYTE)lpCandInfo + sizeof(CANDIDATEINFO));
if (lpCandInfo && lpCandList->dwCount)
{
hOldFont = SelectObject(hDC, hFontFix);
DrawBitmap(hDC, 0, 0, hBMCand);
iSaveBkMode = SetBkMode(hDC, TRANSPARENT);
iStart = (lpCandList->dwSelection / lpCandList->dwPageSize) * lpCandList->dwPageSize;
for (iLoop = 0; iLoop < 9 && iStart+iLoop < lpCandList->dwCount; iLoop++)
{
lpCandStr = (LPTSTR)lpCandList + lpCandList->dwOffset[iStart + iLoop];
TextOut(hDC, rcBtn[iLoop].left + 10, rcBtn[iLoop].top +3, lpCandStr, 2);
}
SetBkMode(hDC, iSaveBkMode);
for (iLoop = iLoop; iLoop < 9; iLoop++)
DrawBitmap(hDC, rcBtn[iLoop].left + 3, rcBtn[iLoop].top + 6, hBMCandNum);
if (iStart)
DrawBitmap(hDC, 19, 8, hBMCandArr[0]);
if (iStart + 9 < lpCandList->dwCount)
DrawBitmap(hDC, 296, 8, hBMCandArr[1]);
SelectObject(hDC, hOldFont);
}
ImmUnlockIMCC(lpIMC->hCandInfo);
ImmUnlockIMC(hIMC);
}
EndPaint(hWnd, &ps);
}
LRESULT DoIMEControl(HWND hWnd, WPARAM wParam, LPARAM lParam)
{
HIMC hIMC;
LPINPUTCONTEXT lpIMC;
HGLOBAL hUIInst;
LPUIINSTANCE lpUIInst;
LPCANDIDATEFORM lpCandForm;
LPLOGFONT lpLogFont;
LOGFONT lfFont;
LPCOMPOSITIONFORM lpCompForm;
PPOINTS pPointS;
RECT rcRect;
LRESULT lRet = FALSE;
switch (wParam)
{
case IMC_GETCANDIDATEPOS:
hIMC = (HIMC)GetWindowLongPtr(hWnd, IMMGWL_IMC);
if (hIMC && (lpIMC = ImmLockIMC(hIMC)))
{
lpCandForm = (LPCANDIDATEFORM)lParam;
*lpCandForm = lpIMC->cfCandForm[0];
hUIInst = (HGLOBAL)GetWindowLongPtr(hWnd, IMMGWL_PRIVATE);
lpUIInst = (LPUIINSTANCE)GlobalLock(hUIInst);
GetWindowRect(lpUIInst->rghWnd[CAND_WINDOW], (LPRECT)&rcRect);
lpCandForm->ptCurrentPos.x = rcRect.left;
lpCandForm->ptCurrentPos.y = rcRect.top;
GlobalUnlock(hUIInst);
ImmUnlockIMC(hIMC);
}
break;
case IMC_GETCOMPOSITIONFONT:
lpLogFont = (LPLOGFONT)lParam;
if (GetObject(hFontFix, sizeof(lfFont), (LPVOID)&lfFont))
*lpLogFont = lfFont;
break;
case IMC_GETCOMPOSITIONWINDOW:
hIMC = (HIMC)GetWindowLongPtr(hWnd, IMMGWL_IMC);
if (hIMC && (lpIMC = ImmLockIMC(hIMC)))
{
lpCompForm = (LPCOMPOSITIONFORM)lParam;
*lpCompForm = lpIMC->cfCompForm;
hUIInst = (HGLOBAL)GetWindowLongPtr(hWnd, IMMGWL_PRIVATE);
lpUIInst = (LPUIINSTANCE)GlobalLock(hUIInst);
GetWindowRect(lpUIInst->rghWnd[COMP_WINDOW], (LPRECT)&rcRect);
lpCompForm->ptCurrentPos.x = rcRect.left;
lpCompForm->ptCurrentPos.y = rcRect.top;
GlobalUnlock(hUIInst);
ImmUnlockIMC(hIMC);
}
break;
case IMC_GETSTATUSWINDOWPOS:
hUIInst = (HGLOBAL)GetWindowLongPtr(hWnd, IMMGWL_PRIVATE);
lpUIInst = (LPUIINSTANCE)GlobalLock(hUIInst);
GetWindowRect(lpUIInst->rghWnd[STATE_WINDOW], (LPRECT)&rcRect);
pPointS = (PPOINTS)&lRet;
pPointS->x = (short)rcRect.left;
pPointS->y = (short)rcRect.top;
GlobalUnlock(hUIInst);
break;
default:
lRet = TRUE;
}
return lRet;
}
LRESULT DoIMENotify(HWND hWnd, WPARAM wParam, LPARAM lParam)
{
HIMC hIMC;
LPINPUTCONTEXT lpIMC;
HGLOBAL hUIInst;
LPUIINSTANCE lpUIInst;
LPCANDIDATEINFO lpCandInfo;
DWORD fdwUIFlags;
POINT pt, ptTmp;
RECT rcTmp;
BOOL lRet = FALSE;
switch (wParam)
{
case IMN_OPENSTATUSWINDOW:
hUIInst = (HGLOBAL)GetWindowLongPtr(hWnd, IMMGWL_PRIVATE);
lpUIInst = (LPUIINSTANCE)GlobalLock(hUIInst);
fdwUIFlags = (DWORD)GetWindowLong(lpUIInst->rghWnd[STATE_WINDOW], UIGWL_FLAGS);
fdwUIFlags |= UIF_SHOWSTATUS;
SetWindowLong(lpUIInst->rghWnd[STATE_WINDOW], UIGWL_FLAGS, fdwUIFlags);
if (fWndOpen[STATE_WINDOW] != FALSE && GetWindowLongPtr(hWnd, IMMGWL_IMC)) {
ShowWindow(lpUIInst->rghWnd[STATE_WINDOW], SW_SHOWNOACTIVATE);
}
GlobalUnlock(hUIInst);
break;
case IMN_CLOSESTATUSWINDOW:
hUIInst = (HGLOBAL)GetWindowLongPtr(hWnd, IMMGWL_PRIVATE);
lpUIInst = (LPUIINSTANCE)GlobalLock(hUIInst);
fdwUIFlags = (DWORD)GetWindowLong(lpUIInst->rghWnd[STATE_WINDOW], UIGWL_FLAGS);
fdwUIFlags &= ~UIF_SHOWSTATUS;
SetWindowLong(lpUIInst->rghWnd[STATE_WINDOW], UIGWL_FLAGS, fdwUIFlags);
ShowWindow(lpUIInst->rghWnd[STATE_WINDOW], SW_HIDE);
GlobalUnlock(hUIInst);
break;
case IMN_CHANGECANDIDATE:
hUIInst = (HGLOBAL)GetWindowLongPtr(hWnd, IMMGWL_PRIVATE);
lpUIInst = (LPUIINSTANCE)GlobalLock(hUIInst);
InvalidateRect(lpUIInst->rghWnd[CAND_WINDOW], NULL, TRUE);
GlobalUnlock(hUIInst);
break;
case IMN_CLOSECANDIDATE:
hIMC = (HIMC)GetWindowLongPtr(hWnd, IMMGWL_IMC);
lpIMC = ImmLockIMC(hIMC);
if (lpIMC != NULL) {
hUIInst = (HGLOBAL)GetWindowLongPtr(hWnd, IMMGWL_PRIVATE);
lpUIInst = (LPUIINSTANCE)GlobalLock(hUIInst);
if (lpUIInst == NULL) {
ImmUnlockIMC(hIMC);
break;
}
lpIMC->hCandInfo = ImmReSizeIMCC(lpIMC->hCandInfo, sizeof(CANDIDATEINFO));
lpCandInfo = (LPCANDIDATEINFO)ImmLockIMCC(lpIMC->hCandInfo);
lpCandInfo->dwSize = sizeof(CANDIDATEINFO);
lpCandInfo->dwCount = 0;
ImmUnlockIMCC(lpIMC->hCandInfo);
InvalidateRect(lpUIInst->rghWnd[STATE_WINDOW], NULL, TRUE);
ShowWindow(lpUIInst->rghWnd[CAND_WINDOW], SW_HIDE);
GlobalUnlock(hUIInst);
ImmUnlockIMC(hIMC);
}
break;
case IMN_OPENCANDIDATE:
hIMC = (HIMC)GetWindowLongPtr(hWnd, IMMGWL_IMC);
lpIMC = ImmLockIMC(hIMC);
if (lpIMC != NULL) {
hUIInst = (HGLOBAL)GetWindowLongPtr(hWnd, IMMGWL_PRIVATE);
lpUIInst = (LPUIINSTANCE)GlobalLock(hUIInst);
if (lpUIInst == NULL) {
ImmUnlockIMC(hIMC);
break;
}
InvalidateRect(lpUIInst->rghWnd[STATE_WINDOW], NULL, TRUE);
ShowWindow(lpUIInst->rghWnd[CAND_WINDOW], fWndOpen[CAND_WINDOW]? SW_SHOWNOACTIVATE: SW_HIDE);
UpdateWindow(lpUIInst->rghWnd[STATE_WINDOW]);
UpdateWindow(lpUIInst->rghWnd[CAND_WINDOW]);
GlobalUnlock(hUIInst);
ImmUnlockIMC(hIMC);
}
break;
case IMN_SETCONVERSIONMODE:
case IMN_SETOPENSTATUS:
hUIInst = (HGLOBAL)GetWindowLongPtr(hWnd, IMMGWL_PRIVATE);
lpUIInst = (LPUIINSTANCE)GlobalLock(hUIInst);
if (lpUIInst != NULL) {
InvalidateRect(lpUIInst->rghWnd[STATE_WINDOW], NULL, TRUE);
GlobalUnlock(hUIInst);
}
break;
case IMN_SETCANDIDATEPOS:
hIMC = (HIMC)GetWindowLongPtr(hWnd, IMMGWL_IMC);
lpIMC = ImmLockIMC(hIMC);
if (lpIMC == NULL)
break;
hUIInst = (HGLOBAL)GetWindowLongPtr(hWnd, IMMGWL_PRIVATE);
lpUIInst = (LPUIINSTANCE)GlobalLock(hUIInst);
if (lpUIInst == NULL) {
ImmUnlockIMC(hIMC);
break;
}
if (lpIMC->cfCandForm[0].dwIndex == -1)
pt = ptCand;
else
{
switch (lpIMC->cfCandForm[0].dwStyle)
{
case CFS_CANDIDATEPOS:
pt = lpIMC->cfCandForm[0].ptCurrentPos;
ClientToScreen(lpIMC->hWnd, &pt);
if (pt.x < rcScreen.left)
pt.x = rcScreen.left;
else if (pt.x > rcScreen.right - CANDXSIZE)
pt.x = rcScreen.right - CANDXSIZE;
if (pt.y < rcScreen.top)
pt.y = rcScreen.top;
else if (pt.y > rcScreen.bottom - CANDYSIZE)
pt.y = rcScreen.bottom - CANDYSIZE;
break;
case CFS_EXCLUDE:
pt = lpIMC->cfCandForm[0].ptCurrentPos;
rcTmp.left = pt.x;
rcTmp.top = pt.y;
rcTmp.right = pt.x + CANDXSIZE;
rcTmp.bottom = pt.y + CANDYSIZE;
ClientToScreen(lpIMC->hWnd, &pt);
if (pt.x < rcScreen.left)
pt.x = rcScreen.left;
else if (pt.x > rcScreen.right - CANDXSIZE)
pt.x = rcScreen.right - CANDXSIZE;
if (pt.y < rcScreen.top)
pt.y = rcScreen.top;
else if (pt.y > rcScreen.bottom - CANDYSIZE)
pt.y = rcScreen.bottom - CANDYSIZE;
if (IntersectRect(&rcTmp, &rcTmp, &lpIMC->cfCandForm[0].rcArea))
{
ptTmp.x = lpIMC->cfCandForm[0].rcArea.right;
ptTmp.y = lpIMC->cfCandForm[0].rcArea.bottom;
ClientToScreen(lpIMC->hWnd, &ptTmp);
pt.y = (ptTmp.y < rcScreen.bottom - CANDYSIZE)? ptTmp.y:
ptTmp.y - lpIMC->cfCandForm[0].rcArea.bottom
+ lpIMC->cfCandForm[0].rcArea.top - CANDYSIZE;
}
break;
default:
pt = ptCand;
}
}
MoveWindow(lpUIInst->rghWnd[CAND_WINDOW], pt.x, pt.y, CANDXSIZE, CANDYSIZE, TRUE);
GlobalUnlock(hUIInst);
ImmUnlockIMC(hIMC);
break;
case IMN_SETCOMPOSITIONWINDOW:
hIMC = (HIMC)GetWindowLongPtr(hWnd, IMMGWL_IMC);
lpIMC = ImmLockIMC(hIMC);
if (lpIMC == NULL)
break;
hUIInst = (HGLOBAL)GetWindowLongPtr(hWnd, IMMGWL_PRIVATE);
lpUIInst = (LPUIINSTANCE)GlobalLock(hUIInst);
if (lpUIInst == NULL) {
ImmUnlockIMC(hIMC);
break;
}
if (lpIMC->cfCompForm.dwStyle & CFS_RECT)
{
pt.x = lpIMC->cfCompForm.rcArea.left;
pt.y = lpIMC->cfCompForm.rcArea.top;
ClientToScreen(lpIMC->hWnd, &pt);
}
else if (lpIMC->cfCompForm.dwStyle & CFS_POINT)
{
pt = lpIMC->cfCompForm.ptCurrentPos;
ClientToScreen(lpIMC->hWnd, &pt);
}
else // For CFS_DEFAULT
pt = lpIMC->cfCompForm.ptCurrentPos = ptComp;
MoveWindow(lpUIInst->rghWnd[COMP_WINDOW], pt.x, pt.y, COMPSIZE, COMPSIZE, TRUE);
GlobalUnlock(hUIInst);
ImmUnlockIMC(hIMC);
break;
case IMN_SETSTATUSWINDOWPOS:
hIMC = (HIMC)GetWindowLongPtr(hWnd, IMMGWL_IMC);
lpIMC = ImmLockIMC(hIMC);
if (lpIMC == NULL)
break;
hUIInst = (HGLOBAL)GetWindowLongPtr(hWnd, IMMGWL_PRIVATE);
lpUIInst = (LPUIINSTANCE)GlobalLock(hUIInst);
if (lpUIInst == NULL) {
ImmUnlockIMC(hIMC);
break;
}
MoveWindow(lpUIInst->rghWnd[STATE_WINDOW], lpIMC->ptStatusWndPos.x,
lpIMC->ptStatusWndPos.y, STATEXSIZE, STATEYSIZE, TRUE);
fdwUIFlags = (DWORD)GetWindowLong(lpUIInst->rghWnd[STATE_WINDOW], UIGWL_FLAGS);
fdwUIFlags |= UIF_PRIVATEPOS;
SetWindowLong(lpUIInst->rghWnd[STATE_WINDOW], UIGWL_FLAGS, fdwUIFlags);
GlobalUnlock(hUIInst);
ImmUnlockIMC(hIMC);
break;
default:
lRet = TRUE;
}
return lRet;
UNREFERENCED_PARAMETER(lParam);
}
Reference in a new issue Copy permalink