windows-nt/Source/XPSP1/NT/windows/feime/usa/toascii.c

628 lines
16 KiB
C
Raw Permalink Normal View History

2020-09-26 03:20:57 -05:00
/*************************************************
* toascii.c *
* *
* Copyright (C) 1999 Microsoft Inc. *
* *
*************************************************/
#include <windows.h>
#include <immdev.h>
#include "imeattr.h"
#include "imedefs.h"
/**********************************************************************/
/* ProcessKey() */
/* Return Value: */
/* different state which input key will change IME to */
/**********************************************************************/
UINT PASCAL ProcessKey( // this key will cause the IME go to what state
WORD wCharCode,
UINT uVirtKey,
UINT uScanCode,
CONST LPBYTE lpbKeyState,
LPINPUTCONTEXT lpIMC,
LPPRIVCONTEXT lpImcP)
{
if (!lpIMC)
{
return (CST_INVALID);
}
if (!lpImcP)
{
return (CST_INVALID);
}
if (uVirtKey == VK_MENU)
{
//
// no ALT key
//
return (CST_INVALID);
}
else if (uScanCode & KF_ALTDOWN)
{
//
// no ALT-xx key
//
return (CST_INVALID);
}
else if (uVirtKey == VK_CONTROL)
{
//
// no CTRL key
//
return (CST_INVALID);
}
else if (lpbKeyState[VK_CONTROL] & 0x80)
{
//
// no CTRL-xx key
//
return (CST_INVALID);
}
else if (uVirtKey == VK_SHIFT)
{
//
// no SHIFT key
//
return (CST_INVALID);
}
else if (!lpIMC->fOpen)
{
//
// don't compose in close status
//
return (CST_INVALID);
}
else if (lpIMC->fdwConversion & IME_CMODE_NOCONVERSION)
{
//
// don't compose in no coversion status
//
return (CST_INVALID);
}
else if (lpIMC->fdwConversion & IME_CMODE_CHARCODE)
{
//
// not support
//
return (CST_INVALID);
}
if (uVirtKey >= VK_NUMPAD0 && uVirtKey <= VK_DIVIDE)
{
//
// A PM decision: all numpad should be past to app
//
return (CST_ALPHANUMERIC);
}
if (!(lpIMC->fdwConversion & IME_CMODE_NATIVE))
{
return (CST_INVALID);
}
else if (!(lpbKeyState[VK_SHIFT] & 0x80))
{
//
// need more check for IME_CMODE_NATIVE
//
}
else if (wCharCode < ' ' && wCharCode > '~')
{
return (CST_INVALID);
}
//
// need more check for IME_CMODE_NATIVE
//
if (wCharCode >= ' ' && wCharCode <= 'z')
{
wCharCode = bUpper[wCharCode - ' '];
}
if (uVirtKey == VK_ESCAPE)
{
register LPGUIDELINE lpGuideLine;
register UINT iImeState;
if (lpImcP->fdwImeMsg & MSG_ALREADY_START)
{
return (CST_INPUT);
}
lpGuideLine = ImmLockIMCC(lpIMC->hGuideLine);
if (!lpGuideLine)
{
return (CST_INVALID);
}
else if (lpGuideLine->dwLevel == GL_LEVEL_NOGUIDELINE)
{
iImeState = CST_INVALID;
}
else
{
//
// need this key to clean information string or guideline state
//
iImeState = CST_INPUT;
}
ImmUnlockIMCC(lpIMC->hGuideLine);
return (iImeState);
}
else if (uVirtKey == VK_BACK)
{
if (lpImcP->fdwImeMsg & MSG_ALREADY_START)
{
return (CST_INPUT);
}
else
{
return (CST_INVALID);
}
}
//
// check finalize char
//
if (wCharCode == ' ' && lpImcP->iImeState == CST_INIT)
{
return (CST_INVALID);
}
else if (lpImeL->fCompChar[(wCharCode - ' ') >> 4] &
fMask[wCharCode & 0x000F])
{
return (CST_INPUT);
}
else if (wCharCode >= 'G' && wCharCode <= 'Z' ||
wCharCode >= 'g' && wCharCode <= 'z')
{
//
// PM decision says we should not send these letters to input
// to avoid confusing users. We special handle this case by
// introducing CST_BLOCKINPUT flag.
//
return (CST_BLOCKINPUT);
}
return (CST_INVALID);
}
/**********************************************************************/
/* ImeProcessKey() / UniImeProcessKey() */
/* Return Value: */
/* TRUE - successful, FALSE - failure */
/**********************************************************************/
// if this key is need by IME?
BOOL WINAPI ImeProcessKey(
HIMC hIMC,
UINT uVirtKey,
LPARAM lParam,
CONST LPBYTE lpbKeyState)
{
LPINPUTCONTEXT lpIMC;
LPPRIVCONTEXT lpImcP;
BYTE szAscii[4];
int nChars;
BOOL fRet;
//
// can't compose in NULL hIMC
//
if (!hIMC)
{
return (FALSE);
}
lpIMC = (LPINPUTCONTEXT)ImmLockIMC(hIMC);
if (!lpIMC)
{
return (FALSE);
}
lpImcP = (LPPRIVCONTEXT)ImmLockIMCC(lpIMC->hPrivate);
if (!lpImcP)
{
ImmUnlockIMC(hIMC);
return (FALSE);
}
nChars = ToAscii(uVirtKey, HIWORD(lParam), lpbKeyState, (LPVOID)szAscii, 0);
if (!nChars)
{
szAscii[0] = 0;
}
if (ProcessKey( (WORD)szAscii[0],
uVirtKey,
HIWORD(lParam),
lpbKeyState,
lpIMC,
lpImcP) == CST_INVALID)
{
fRet = FALSE;
}
else
{
fRet = TRUE;
}
ImmUnlockIMCC(lpIMC->hPrivate);
ImmUnlockIMC(hIMC);
return (fRet);
}
/**********************************************************************/
/* TranslateToAscii() */
/* Translates the key input to WM_CHAR as keyboard drivers does */
/* */
/* Return Value: */
/* the number of translated chars */
/**********************************************************************/
UINT PASCAL TranslateToAscii(
UINT uScanCode,
LPTRANSMSG lpTransMsg,
WORD wCharCode)
{
if (wCharCode)
{
//
// one char code
//
lpTransMsg->message = WM_CHAR;
lpTransMsg->wParam = wCharCode;
lpTransMsg->lParam = (uScanCode << 16) | 1UL;
return (1);
}
//
// no char code case
//
return (0);
}
/**********************************************************************/
/* TranslateImeMessage() */
/* Return Value: */
/* the number of translated messages */
/**********************************************************************/
UINT PASCAL TranslateImeMessage(
LPTRANSMSGLIST lpTransBuf,
LPINPUTCONTEXT lpIMC,
LPPRIVCONTEXT lpImcP)
{
UINT uNumMsg;
UINT i;
BOOL bLockMsgBuf;
LPTRANSMSG lpTransMsg;
uNumMsg = 0;
bLockMsgBuf = FALSE;
for (i = 0; i < 2; i++)
{
if (lpImcP->fdwImeMsg & MSG_IMN_COMPOSITIONSIZE)
{
if (!i)
{
uNumMsg++;
}
else
{
lpTransMsg->message = WM_IME_NOTIFY;
lpTransMsg->wParam = IMN_PRIVATE;
lpTransMsg->lParam = IMN_PRIVATE_COMPOSITION_SIZE;
lpTransMsg += 1;
}
}
if (lpImcP->fdwImeMsg & MSG_START_COMPOSITION)
{
if (!(lpImcP->fdwImeMsg & MSG_ALREADY_START))
{
if (!i)
{
uNumMsg++;
}
else
{
lpTransMsg->message = WM_IME_STARTCOMPOSITION;
lpTransMsg->wParam = 0;
lpTransMsg->lParam = 0;
lpTransMsg += 1;
lpImcP->fdwImeMsg |= MSG_ALREADY_START;
}
}
}
if (lpImcP->fdwImeMsg & MSG_IMN_COMPOSITIONPOS)
{
if (!i)
{
uNumMsg++;
}
else
{
lpTransMsg->message = WM_IME_NOTIFY;
lpTransMsg->wParam = IMN_SETCOMPOSITIONWINDOW;
lpTransMsg->lParam = 0;
lpTransMsg += 1;
}
}
if (lpImcP->fdwImeMsg & MSG_COMPOSITION)
{
if (!i)
{
uNumMsg++;
}
else
{
lpTransMsg->message = WM_IME_COMPOSITION;
lpTransMsg->wParam = lpImcP->dwCompChar;
lpTransMsg->lParam = lpImcP->fdwGcsFlag;
lpTransMsg += 1;
}
}
if (lpImcP->fdwImeMsg & MSG_GUIDELINE)
{
if (!i)
{
uNumMsg++;
}
else
{
lpTransMsg->message = WM_IME_NOTIFY;
lpTransMsg->wParam = IMN_GUIDELINE;
lpTransMsg->lParam = 0;
lpTransMsg += 1;
}
}
if (lpImcP->fdwImeMsg & MSG_IMN_PAGEUP)
{
if (!i)
{
uNumMsg++;
}
else
{
lpTransMsg->message = WM_IME_NOTIFY;
lpTransMsg->wParam = IMN_PRIVATE;
lpTransMsg->lParam = IMN_PRIVATE_PAGEUP;
lpTransMsg += 1;
}
}
if (lpImcP->fdwImeMsg & MSG_END_COMPOSITION)
{
if (lpImcP->fdwImeMsg & MSG_ALREADY_START)
{
if (!i)
{
uNumMsg++;
}
else
{
lpTransMsg->message = WM_IME_ENDCOMPOSITION;
lpTransMsg->wParam = 0;
lpTransMsg->lParam = 0;
lpTransMsg += 1;
lpImcP->fdwImeMsg &= ~(MSG_ALREADY_START);
}
}
}
if (lpImcP->fdwImeMsg & MSG_IMN_TOGGLE_UI)
{
if (!i)
{
uNumMsg++;
}
else
{
lpTransMsg->message = WM_IME_NOTIFY;
lpTransMsg->wParam = IMN_PRIVATE;
lpTransMsg->lParam = IMN_PRIVATE_TOGGLE_UI;
lpTransMsg += 1;
}
}
if (!i)
{
HIMCC hMem;
if (!uNumMsg)
{
return (uNumMsg);
}
if (lpImcP->fdwImeMsg & MSG_IN_IMETOASCIIEX)
{
UINT uNumMsgLimit;
// ++ for the start position of buffer to strore the messages
uNumMsgLimit = lpTransBuf->uMsgCount;
if (uNumMsg <= uNumMsgLimit)
{
lpTransMsg = lpTransBuf->TransMsg;
continue;
}
}
// we need to use message buffer
if (!lpIMC->hMsgBuf)
{
lpIMC->hMsgBuf = ImmCreateIMCC(uNumMsg * sizeof(TRANSMSG));
lpIMC->dwNumMsgBuf = 0;
}
else if (hMem = ImmReSizeIMCC(lpIMC->hMsgBuf,
(lpIMC->dwNumMsgBuf + uNumMsg) * sizeof(TRANSMSG)))
{
if (hMem != lpIMC->hMsgBuf)
{
ImmDestroyIMCC(lpIMC->hMsgBuf);
lpIMC->hMsgBuf = hMem;
}
}
else
{
return (0);
}
lpTransMsg = (LPTRANSMSG)ImmLockIMCC(lpIMC->hMsgBuf);
if (!lpTransMsg)
{
return (0);
}
lpTransMsg += lpIMC->dwNumMsgBuf;
bLockMsgBuf = TRUE;
}
else
{
if (bLockMsgBuf)
{
ImmUnlockIMCC(lpIMC->hMsgBuf);
}
}
}
return (uNumMsg);
}
/**********************************************************************/
/* ImeToAsciiEx() / UniImeToAsciiex() */
/* Return Value: */
/* the number of translated message */
/**********************************************************************/
UINT WINAPI ImeToAsciiEx(
UINT uVirtKey,
UINT uScanCode,
CONST LPBYTE lpbKeyState,
LPTRANSMSGLIST lpTransBuf,
UINT fuState,
HIMC hIMC)
{
WORD wCharCode;
LPINPUTCONTEXT lpIMC;
LPCOMPOSITIONSTRING lpCompStr;
LPGUIDELINE lpGuideLine;
LPPRIVCONTEXT lpImcP;
UINT uNumMsg;
int iRet;
wCharCode = HIWORD(uVirtKey);
uVirtKey = LOBYTE(uVirtKey);
if (!hIMC)
{
return TranslateToAscii(uScanCode,
&lpTransBuf->TransMsg[0],
wCharCode);
}
lpIMC = (LPINPUTCONTEXT)ImmLockIMC(hIMC);
if (!lpIMC)
{
return TranslateToAscii(uScanCode,
&lpTransBuf->TransMsg[0],
wCharCode);
}
lpImcP = (LPPRIVCONTEXT)ImmLockIMCC(lpIMC->hPrivate);
if (!lpImcP)
{
ImmUnlockIMC(hIMC);
return TranslateToAscii(uScanCode,
&lpTransBuf->TransMsg[0],
wCharCode);
}
// Now all composition realated information already pass to app
// a brand new start
lpImcP->fdwImeMsg = lpImcP->fdwImeMsg & (MSG_STATIC_STATE) |
MSG_IN_IMETOASCIIEX;
iRet = ProcessKey(wCharCode,
uVirtKey,
uScanCode,
lpbKeyState,
lpIMC,
lpImcP);
if (iRet == CST_ALPHABET)
{
// A-Z convert to a-z, a-z convert to A-Z
wCharCode ^= 0x20;
iRet = CST_ALPHANUMERIC;
}
if (iRet == CST_ALPHANUMERIC)
{
uNumMsg = TranslateImeMessage(lpTransBuf, lpIMC, lpImcP);
uNumMsg += TranslateToAscii(uScanCode,
&lpTransBuf->TransMsg[uNumMsg],
wCharCode);
}
else if (iRet == CST_INPUT)
{
lpCompStr = (LPCOMPOSITIONSTRING)ImmLockIMCC(lpIMC->hCompStr);
lpGuideLine = (LPGUIDELINE)ImmLockIMCC(lpIMC->hGuideLine);
CompWord(wCharCode, hIMC, lpIMC, lpCompStr, lpGuideLine, lpImcP);
if (lpGuideLine)
{
ImmUnlockIMCC(lpIMC->hGuideLine);
}
if (lpCompStr)
{
ImmUnlockIMCC(lpIMC->hCompStr);
}
uNumMsg = TranslateImeMessage(lpTransBuf, lpIMC, lpImcP);
}
else if (iRet == CST_BLOCKINPUT)
{
//
// This codepoint should be blocked. We don't compose it for IME.
// Nor do we pass it to normal input. Instead, we beep.
//
MessageBeep(-1);
uNumMsg = 0;
}
else
{
uNumMsg = TranslateToAscii(uScanCode,
&lpTransBuf->TransMsg[0],
wCharCode);
}
lpImcP->fdwImeMsg &= (MSG_STATIC_STATE);
lpImcP->fdwGcsFlag = 0;
ImmUnlockIMCC(lpIMC->hPrivate);
ImmUnlockIMC(hIMC);
return (uNumMsg);
}