You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
357 lines
12 KiB
357 lines
12 KiB
/****************************************************************************
|
|
ESCAPE.CPP
|
|
|
|
Owner: cslim
|
|
Copyright (c) 1997-1999 Microsoft Corporation
|
|
|
|
ImeEscape functions
|
|
|
|
History:
|
|
14-JUL-1999 cslim Copied from IME98 source tree
|
|
*****************************************************************************/
|
|
|
|
#include "precomp.h"
|
|
#include "ui.h"
|
|
#include "debug.h"
|
|
#include "hanja.h"
|
|
#include "escape.h"
|
|
#include "apientry.h"
|
|
|
|
// IME_AUTOMATA subfunctions
|
|
#define IMEA_INIT 0x01
|
|
#define IMEA_NEXT 0x02
|
|
#define IMEA_PREV 0x03
|
|
// IME_MOVEIMEWINDOW
|
|
#define MCW_DEFAULT 0x00
|
|
#define MCW_WINDOW 0x02
|
|
#define MCW_SCREEN 0x04
|
|
|
|
BOOL vfWndOpen[3] = { fTrue, fTrue, fTrue };
|
|
static WORD wWndCmd[3] = { MCW_DEFAULT, MCW_DEFAULT, MCW_DEFAULT };
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
// IME_ESC_HANJA_MODE processing routine called by ImeEscape
|
|
// Korean specific
|
|
// It is for conversion from Hangul to Hanja the Input parameter (LPSTR)lpData
|
|
// is filled with Hangul charactert which will be converted to Hanja.
|
|
int EscHanjaMode(PCIMECtx pImeCtx, LPSTR lpIME32, BOOL fNewFunc)
|
|
{
|
|
LPWSTR pwchSrc;
|
|
LPSTR pchSrc;
|
|
WCHAR wchSrc;
|
|
INT iRet = fFalse;
|
|
|
|
// Update IMC values with lpIME32
|
|
if (pImeCtx->IsUnicodeEnv())
|
|
{
|
|
pwchSrc = (fNewFunc) ? (LPWSTR)lpIME32 : GET_LPSOURCEW((LPIMESTRUCT32)lpIME32);
|
|
if (pwchSrc == NULL || *pwchSrc == L'\0')
|
|
{
|
|
DbgAssert(0);
|
|
return 0;
|
|
}
|
|
wchSrc = *pwchSrc;
|
|
}
|
|
else
|
|
{
|
|
pchSrc = (fNewFunc) ? (LPSTR)lpIME32 : GET_LPSOURCEA((LPIMESTRUCT32)lpIME32);
|
|
if (pchSrc == NULL || *pchSrc == '\0')
|
|
{
|
|
DbgAssert(0);
|
|
return 0;
|
|
}
|
|
|
|
if (MultiByteToWideChar(CP_KOREA, MB_PRECOMPOSED, pchSrc, 2, &wchSrc, 1) == 0)
|
|
{
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
Dbg(DBGID_Hanja, TEXT("EscHanjaMode = %04X"), wchSrc);
|
|
if (GenerateHanjaCandList(pImeCtx, wchSrc))
|
|
{
|
|
// Set current comp str
|
|
if (pImeCtx->IsUnicodeEnv())
|
|
pImeCtx->SetCompBufStr(wchSrc);
|
|
else
|
|
pImeCtx->SetCompBufStr(*pchSrc, *(pchSrc+1));
|
|
|
|
// Change to Hanja conv mode
|
|
iRet = OurImmSetConversionStatus(pImeCtx->GetHIMC(), pImeCtx->GetConversionMode() | IME_CMODE_HANJACONVERT,
|
|
pImeCtx->GetSentenceMode());
|
|
}
|
|
else // if failed to convert
|
|
{
|
|
MessageBeep(MB_ICONEXCLAMATION);
|
|
}
|
|
|
|
Dbg(DBGID_Hanja, TEXT("EscHanjaMode return = %d"), iRet);
|
|
return (iRet);
|
|
}
|
|
|
|
|
|
INT EscGetOpen(PCIMECtx pIMECtx, LPIMESTRUCT32 lpIME32)
|
|
{
|
|
LPIMEDATA lpImeData = pIMECtx->GetGDataRaw();
|
|
INT iRet = fTrue;
|
|
|
|
if (lpImeData == NULL)
|
|
return fFalse;
|
|
|
|
if (lpIME32->dchSource > CAND_WINDOW)
|
|
iRet = fFalse;
|
|
else
|
|
{
|
|
iRet = vfWndOpen[lpIME32->dchSource] | 0x80000000UL;
|
|
lpIME32->wCount = wWndCmd[lpIME32->dchSource];
|
|
|
|
switch (lpIME32->wCount)
|
|
{
|
|
case MCW_DEFAULT:
|
|
switch (lpIME32->dchSource)
|
|
{
|
|
case COMP_WINDOW:
|
|
lpIME32->lParam1 = MAKELONG(lpImeData->ptStatusPos.y,
|
|
(lpImeData->ptStatusPos.x+lpImeData->xStatusWi+UI_GAPX + COMP_SIZEX > lpImeData->rcWorkArea.right) ?
|
|
lpImeData->ptStatusPos.x - UI_GAPX - COMP_SIZEX : lpImeData->ptStatusPos.x + lpImeData->xStatusWi + UI_GAPX);
|
|
break;
|
|
case STATE_WINDOW:
|
|
lpIME32->lParam1 = MAKELONG(lpImeData->rcWorkArea.bottom - lpImeData->yStatusHi,
|
|
lpImeData->rcWorkArea.right - lpImeData->xStatusWi);
|
|
break;
|
|
case CAND_WINDOW:
|
|
lpIME32->lParam1 = MAKELONG(lpImeData->rcWorkArea.bottom - lpImeData->yCandHi,
|
|
lpImeData->rcWorkArea.right - lpImeData->xCandWi);
|
|
|
|
break;
|
|
|
|
}
|
|
break;
|
|
|
|
case MCW_SCREEN:
|
|
switch (lpIME32->dchSource)
|
|
{
|
|
case COMP_WINDOW:
|
|
lpIME32->lParam1 = MAKELONG(lpImeData->ptCompPos.y, lpImeData->ptCompPos.x);
|
|
break;
|
|
|
|
case STATE_WINDOW:
|
|
lpIME32->lParam1 = MAKELONG(lpImeData->ptStatusPos.y, lpImeData->ptStatusPos.x);
|
|
break;
|
|
|
|
case CAND_WINDOW:
|
|
lpIME32->lParam1 = MAKELONG(lpImeData->rcWorkArea.bottom - lpImeData->yCandHi,
|
|
lpImeData->rcWorkArea.right - lpImeData->xCandWi);
|
|
break;
|
|
}
|
|
break;
|
|
|
|
case MCW_WINDOW:
|
|
switch (lpIME32->dchSource)
|
|
{
|
|
case COMP_WINDOW:
|
|
lpIME32->lParam1 = MAKELONG(lpImeData->ptCompPos.y, lpImeData->ptCompPos.x);
|
|
break;
|
|
|
|
case STATE_WINDOW:
|
|
lpIME32->lParam1 = MAKELONG(lpImeData->ptStatusPos.y, lpImeData->ptStatusPos.x);
|
|
break;
|
|
|
|
case CAND_WINDOW:
|
|
lpIME32->lParam1 = MAKELONG(lpImeData->rcWorkArea.bottom - lpImeData->yCandHi,
|
|
lpImeData->rcWorkArea.right - lpImeData->xCandWi);
|
|
break;
|
|
}
|
|
lpIME32->lParam1 -= lpIME32->lParam2;
|
|
break;
|
|
|
|
default:
|
|
iRet = fFalse;
|
|
}
|
|
}
|
|
return (iRet);
|
|
}
|
|
|
|
INT EscSetOpen(PCIMECtx pIMECtx, LPIMESTRUCT32 lpIME32)
|
|
{
|
|
BOOL fTmp;
|
|
HWND hDefIMEWnd;
|
|
INT iRet = fTrue;
|
|
|
|
if (lpIME32->dchSource > CAND_WINDOW)
|
|
iRet = fFalse;
|
|
else
|
|
{
|
|
fTmp = vfWndOpen[lpIME32->dchSource];
|
|
vfWndOpen[lpIME32->dchSource] = lpIME32->wParam;
|
|
iRet = fTmp | 0x80000000UL;
|
|
if (lpIME32->dchSource == STATE_WINDOW)
|
|
{
|
|
hDefIMEWnd = OurImmGetDefaultIMEWnd(pIMECtx->GetAppWnd());
|
|
if (hDefIMEWnd)
|
|
OurSendMessage(hDefIMEWnd, WM_IME_NOTIFY,
|
|
(lpIME32->wParam)? IMN_OPENSTATUSWINDOW: IMN_CLOSESTATUSWINDOW, 0L);
|
|
}
|
|
}
|
|
|
|
return (iRet);
|
|
}
|
|
|
|
INT EscMoveIMEWindow(PCIMECtx pIMECtx, LPIMESTRUCT32 lpIME32)
|
|
{
|
|
LPIMEDATA pImeData = pIMECtx->GetGDataRaw();
|
|
INT iRet = fTrue;
|
|
|
|
if (pImeData == NULL)
|
|
return fFalse;
|
|
|
|
if (lpIME32->dchSource > CAND_WINDOW)
|
|
iRet = fFalse;
|
|
else
|
|
{
|
|
switch (wWndCmd[lpIME32->dchSource] = lpIME32->wParam)
|
|
{
|
|
case MCW_DEFAULT:
|
|
switch (lpIME32->dchSource)
|
|
{
|
|
case COMP_WINDOW:
|
|
pImeData->ptCompPos.x = (pImeData->ptStatusPos.x+pImeData->xStatusWi+UI_GAPX + COMP_SIZEX > pImeData->rcWorkArea.right) ?
|
|
pImeData->ptStatusPos.x - UI_GAPX - COMP_SIZEX : pImeData->ptStatusPos.x + pImeData->xStatusWi + UI_GAPX;
|
|
pImeData->ptCompPos.y = pImeData->ptStatusPos.y;
|
|
break;
|
|
|
|
case STATE_WINDOW:
|
|
pImeData->ptStatusPos.x = pImeData->rcWorkArea.right - pImeData->xStatusWi;
|
|
pImeData->ptStatusPos.y = pImeData->rcWorkArea.bottom - pImeData->yStatusHi;
|
|
break;
|
|
|
|
case CAND_WINDOW:
|
|
//pImeData->ptCandPos.x = pImeData->rcWorkArea.right - pImeData->xCandWi;
|
|
//pImeData->ptCandPos.y = pImeData->rcWorkArea.bottom - pImeData->yCandHi;
|
|
break;
|
|
}
|
|
break;
|
|
|
|
case MCW_WINDOW:
|
|
case MCW_SCREEN:
|
|
switch (lpIME32->dchSource)
|
|
{
|
|
case COMP_WINDOW:
|
|
pImeData->ptCompPos.x = LOWORD(lpIME32->lParam1);
|
|
pImeData->ptCompPos.y = HIWORD(lpIME32->lParam1);
|
|
break;
|
|
|
|
case STATE_WINDOW:
|
|
pImeData->ptStatusPos.x = LOWORD(lpIME32->lParam1);
|
|
pImeData->ptStatusPos.y = HIWORD(lpIME32->lParam1);
|
|
break;
|
|
|
|
case CAND_WINDOW:
|
|
//pImeData->ptCandPos.x = LOWORD(lpIME32->lParam1);
|
|
//pImeData->ptCandPos.y = HIWORD(lpIME32->lParam1);
|
|
break;
|
|
}
|
|
break;
|
|
|
|
default:
|
|
iRet = fFalse;
|
|
}
|
|
}
|
|
return (iRet);
|
|
}
|
|
|
|
|
|
INT EscAutomata(PCIMECtx pIMECtx, LPIMESTRUCT32 lpIME32, BOOL fNewFunc)
|
|
{
|
|
// LPCOMPOSITIONSTRING lpCompStr;
|
|
INT iRet = fFalse;
|
|
WCHAR wcCur;
|
|
|
|
Dbg(DBGID_Automata, TEXT("EscAutomata: fNewFunc=%d, lpIME32->wParam=%04X, lpIME32->lParam1=0x%08X, lpIME32->lParam2=0x%08X, lpIME32->lParam3=0x%08X"), fNewFunc, lpIME32->wParam, lpIME32->lParam1, lpIME32->lParam2, lpIME32->lParam3 );
|
|
|
|
if (fNewFunc)
|
|
{
|
|
iRet = ImeProcessKey(pIMECtx->GetHIMC(), lpIME32->wParam,
|
|
lpIME32->lParam1, (LPBYTE)lpIME32 + (INT_PTR)lpIME32->dchSource);
|
|
if (iRet)
|
|
{
|
|
lpIME32->wCount = (WORD)ImeToAsciiEx(lpIME32->wParam,
|
|
HIWORD(lpIME32->lParam1), (LPBYTE)lpIME32 + lpIME32->dchSource,
|
|
(LPTRANSMSGLIST)((LPBYTE)lpIME32 + (INT_PTR)lpIME32->dchDest), 0, pIMECtx->GetHIMC());
|
|
}
|
|
else
|
|
if (lpIME32->wParam != VK_MENU)
|
|
{
|
|
LPTRANSMSGLIST lpTransBuf;
|
|
LPTRANSMSG lpTransMsg;
|
|
|
|
lpIME32->wCount = 1;
|
|
lpTransBuf = (LPTRANSMSGLIST)((LPBYTE)lpIME32 + (INT_PTR)lpIME32->dchDest);
|
|
if (lpTransBuf)
|
|
{
|
|
lpTransMsg = lpTransBuf->TransMsg;
|
|
SetTransBuffer(lpTransMsg, (HIWORD(lpIME32->lParam1) & 0x8000)? WM_IME_KEYUP: WM_IME_KEYDOWN, lpIME32->wParam, lpIME32->lParam1);
|
|
lpTransMsg++;
|
|
}
|
|
|
|
iRet = fTrue;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
CHangulAutomata *pAutoMata = pIMECtx->GetAutomata();
|
|
DbgAssert(pAutoMata != NULL);
|
|
if (pAutoMata == NULL)
|
|
{
|
|
return fFalse;
|
|
}
|
|
|
|
// It's only for HWin31 IME app compatibility layer
|
|
switch (lpIME32->wParam)
|
|
{
|
|
//lpIME32->dchSource = bState;
|
|
case IMEA_INIT:
|
|
pIMECtx->ClearCompositionStrBuffer();
|
|
break;
|
|
|
|
case IMEA_NEXT:
|
|
//HangeulAutomata(
|
|
// Atm_table[uCurrentInputMethod - IDD_2BEOL][lpIME32->dchSource - 0x20],
|
|
// NULL, lpCompStr);
|
|
DbgAssert(0);
|
|
break;
|
|
|
|
case IMEA_PREV:
|
|
//HangeulAutomata(0x80, NULL, lpCompStr); // 0x80 is for VK_BACK
|
|
pAutoMata->BackSpace();
|
|
wcCur = pAutoMata->GetCompositionChar();
|
|
|
|
if (pIMECtx->GetGData() && pIMECtx->GetGData()->GetJasoDel() == fFalse)
|
|
{
|
|
pAutoMata->InitState();
|
|
wcCur = 0;
|
|
}
|
|
|
|
if (wcCur)
|
|
{
|
|
pIMECtx->SetCompositionStr(wcCur);
|
|
pIMECtx->StoreComposition();
|
|
}
|
|
else
|
|
pIMECtx->ClearCompositionStrBuffer();
|
|
break;
|
|
}
|
|
iRet = fTrue;
|
|
}
|
|
|
|
return (iRet);
|
|
}
|
|
|
|
int EscGetIMEKeyLayout(PCIMECtx pIMECtx, LPIMESTRUCT32 lpIME32)
|
|
{
|
|
if (pIMECtx->GetGData() == NULL)
|
|
return fFalse;
|
|
else
|
|
lpIME32->lParam1 = (LONG)(pIMECtx->GetGData()->GetCurrentBeolsik());
|
|
return fTrue;
|
|
}
|