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

1043 lines
29 KiB
C
Raw Normal View History

Add source files
2020-09-26 03:20:57 -05:00
/*++
Copyright (c) 1990-1999 Microsoft Corporation, All Rights Reserved
Module Name:
COMPOSE.c
++*/
#include <windows.h>
#include <immdev.h>
#include "imeattr.h"
#include "imedefs.h"
#if !defined(ROMANIME)
BOOL IsBig5Character( WCHAR wChar )
{
CHAR szBig5[3];
WCHAR wszUnicode[2];
BOOL bUsedDefaultChar;
wszUnicode[0] = wChar;
wszUnicode[1] = 0x0000;
WideCharToMultiByte(NATIVE_ANSI_CP, WC_COMPOSITECHECK,
wszUnicode, -1, szBig5,
sizeof(szBig5), NULL, &bUsedDefaultChar);
if ( bUsedDefaultChar != TRUE )
return TRUE;
else
return FALSE;
}
#endif
#if !defined(ROMANIME)
/**********************************************************************/
/* AddCodeIntoCand() */
/**********************************************************************/
void PASCAL AddCodeIntoCand(
#ifdef UNIIME
LPIMEL lpImeL,
#endif
LPCANDIDATELIST lpCandList,
UINT uCode)
{
if (lpCandList->dwCount >= MAXCAND) {
// Grow memory here and do something,
// if you still want to process it.
return;
}
#ifndef UNICODE
// swap lead byte & second byte, UNICODE don't need it
uCode = HIBYTE(uCode) | (LOBYTE(uCode) << 8);
#endif
// Before add this char, check if BIG5ONLY mode is set
// if BIG5ONLY is set, and the character is out of Big5 Range
// we just ignore this character.
if ( lpImeL->fdwModeConfig & MODE_CONFIG_BIG5ONLY ) {
if ( IsBig5Character( (WCHAR)uCode ) == FALSE ) {
// this character is not in the range of Big5 charset
return ;
}
}
// add this string into candidate list
*(LPWSTR)((LPBYTE)lpCandList + lpCandList->dwOffset[
lpCandList->dwCount]) = (WCHAR)uCode;
// null terminator
*(LPTSTR)((LPBYTE)lpCandList + lpCandList->dwOffset[
lpCandList->dwCount] + sizeof(WCHAR)) = '\0';
lpCandList->dwCount++;
if (lpCandList->dwCount >= MAXCAND) {
return;
}
lpCandList->dwOffset[lpCandList->dwCount] =
lpCandList->dwOffset[lpCandList->dwCount - 1] +
sizeof(WCHAR) + sizeof(TCHAR);
return;
}
/**********************************************************************/
/* ConvertSeqCode2Pattern() */
/**********************************************************************/
DWORD PASCAL ConvertSeqCode2Pattern(
#if defined(UNIIME)
LPIMEL lpImeL,
#endif
LPBYTE lpbSeqCode,
LPPRIVCONTEXT lpImcP)
{
#if defined(CHAJEI) || defined(WINAR30)
int iInputEnd, iGhostCard;
BOOL fGhostCard;
#endif
#if defined(WINAR30)
DWORD dwWildCardMask;
DWORD dwLastWildCard;
BOOL fWildCard;
#endif
DWORD dwPattern;
int i;
// we will convert the sequence codes into compact bits
dwPattern = 0;
#if defined(CHAJEI) || defined(WINAR30)
iInputEnd = iGhostCard = lpImeL->nMaxKey;
fGhostCard = FALSE;
#if defined(WINAR30)
dwWildCardMask = 0;
dwLastWildCard = 0;
fWildCard = FALSE;
#endif
#endif
#if defined(CHAJEI)
// only support X*Y
if (lpbSeqCode[0] == GHOSTCARD_SEQCODE) {
// not support *XY
goto CvtPatOvr;
} else if (lpbSeqCode[1] != GHOSTCARD_SEQCODE) {
} else if (lpbSeqCode[3]) {
// not support X*YZ
goto CvtPatOvr;
} else if (lpbSeqCode[2] == GHOSTCARD_SEQCODE) {
// not support X**
goto CvtPatOvr;
} else if (lpbSeqCode[2]) {
} else {
// not support X*
goto CvtPatOvr;
}
#endif
#if defined(QUICK)
if (lpbSeqCode[1]) {
lpImcP->iInputEnd = 2;
} else {
lpImcP->iInputEnd = 1;
}
#endif
for (i = 0; i < lpImeL->nMaxKey; i++, lpbSeqCode++) {
dwPattern <<= lpImeL->nSeqBits;
#if defined(WINAR30)
dwWildCardMask <<= lpImeL->nSeqBits;
dwLastWildCard <<= lpImeL->nSeqBits;
if (*lpbSeqCode == WILDCARD_SEQCODE) {
// X?Y
if (fGhostCard) {
// can not support wild card with ghost card X*Y?
dwPattern = 0;
break;
}
dwLastWildCard = lpImeL->dwSeqMask;
fWildCard = TRUE;
} else {
dwWildCardMask |= lpImeL->dwSeqMask;
}
#endif
#if defined(CHAJEI) || defined(WINAR30)
if (!*lpbSeqCode) {
if (i < iInputEnd) {
iInputEnd = i;
}
}
if (*lpbSeqCode == GHOSTCARD_SEQCODE) {
// X*Y
if (fGhostCard) {
// can not support multiple ghost cards X*Y*
dwPattern = 0;
break;
}
#if defined(WINAR30)
if (fWildCard) {
// can not support ghost card with wild card X?Y*
dwPattern = 0;
break;
}
dwLastWildCard = lpImeL->dwSeqMask;
#endif
iGhostCard = i;
}
#endif
#if defined(CHAJEI) || defined(WINAR30)
if (*lpbSeqCode == GHOSTCARD_SEQCODE) {
continue;
#if defined(WINAR30)
} else if (*lpbSeqCode == WILDCARD_SEQCODE) {
continue;
#endif
} else {
}
#endif
dwPattern |= *lpbSeqCode;
}
#if defined(CHAJEI)
CvtPatOvr:
#endif
if (lpImcP) {
lpImcP->dwPattern = dwPattern;
#if defined(QUICK)
lpImcP->iGhostCard = 1;
#endif
#if defined(CHAJEI) || defined(WINAR30)
if (dwPattern) {
lpImcP->iInputEnd = iInputEnd;
lpImcP->iGhostCard = iGhostCard;
#if defined(WINAR30)
lpImcP->dwWildCardMask = dwWildCardMask;
lpImcP->dwLastWildCard = dwLastWildCard;
#endif
} else {
lpImcP->iInputEnd = lpImcP->iGhostCard = lpImeL->nMaxKey;
#if defined(WINAR30)
lpImcP->dwWildCardMask = lpImeL->dwPatternMask;
lpImcP->dwLastWildCard = 0;
#endif
}
#endif
}
return (dwPattern);
}
/**********************************************************************/
/* CompEscapeKey() */
/**********************************************************************/
void PASCAL CompEscapeKey(
LPINPUTCONTEXT lpIMC,
LPCOMPOSITIONSTRING lpCompStr,
LPGUIDELINE lpGuideLine,
LPPRIVCONTEXT lpImcP)
{
if (!lpGuideLine) {
MessageBeep((UINT)-1);
} else if (lpGuideLine->dwLevel != GL_LEVEL_NOGUIDELINE) {
InitGuideLine(lpGuideLine);
lpImcP->fdwImeMsg |= MSG_GUIDELINE;
} else {
}
if (lpImcP->fdwImeMsg & MSG_OPEN_CANDIDATE) {
// we have candidate window, so keep composition
} else if ((lpImcP->fdwImeMsg & (MSG_ALREADY_OPEN|MSG_CLOSE_CANDIDATE)) ==
(MSG_ALREADY_OPEN)) {
// we have candidate window, so keep composition
} else if (lpImcP->fdwImeMsg & MSG_ALREADY_START) {
lpImcP->fdwImeMsg = (lpImcP->fdwImeMsg|MSG_END_COMPOSITION) &
~(MSG_START_COMPOSITION);
} else {
lpImcP->fdwImeMsg &= ~(MSG_END_COMPOSITION|MSG_START_COMPOSITION);
}
lpImcP->iImeState = CST_INIT;
*(LPDWORD)lpImcP->bSeq = 0;
#if defined(CHAJEI) || defined(WINAR30) || defined(UNIIME)
*(LPDWORD)&lpImcP->bSeq[4] = 0;
#endif
if (lpCompStr) {
InitCompStr(lpCompStr);
lpImcP->fdwImeMsg |= MSG_COMPOSITION;
lpImcP->dwCompChar = VK_ESCAPE;
lpImcP->fdwGcsFlag |= (GCS_COMPREAD|GCS_COMP|GCS_CURSORPOS|
GCS_DELTASTART);
}
return;
}
/**********************************************************************/
/* CompBackSpaceKey() */
/**********************************************************************/
void PASCAL CompBackSpaceKey(
HIMC hIMC,
LPINPUTCONTEXT lpIMC,
LPCOMPOSITIONSTRING lpCompStr,
LPPRIVCONTEXT lpImcP)
{
if (lpCompStr->dwCursorPos < sizeof(WCHAR) / sizeof(TCHAR)) {
lpCompStr->dwCursorPos = sizeof(WCHAR) / sizeof(TCHAR);
}
// go back a compsoition char
lpCompStr->dwCursorPos -= sizeof(WCHAR) / sizeof(TCHAR);
// clean the sequence code
lpImcP->bSeq[lpCompStr->dwCursorPos / (sizeof(WCHAR) / sizeof(TCHAR))] = 0;
#if defined(PHON)
// phonetic has index (position) for each symbol, if it is
// no symbol for this position we back more
for (; lpCompStr->dwCursorPos > 0; ) {
if (lpImcP->bSeq[lpCompStr->dwCursorPos / (sizeof(WCHAR) /
sizeof(TCHAR)) - 1]) {
break;
} else {
// no symbol in this position skip
lpCompStr->dwCursorPos -= sizeof(WCHAR) / sizeof(TCHAR);
}
}
#endif
lpImcP->fdwImeMsg |= MSG_COMPOSITION;
lpImcP->dwCompChar = '\b';
lpImcP->fdwGcsFlag |= (GCS_COMPREAD|GCS_COMP|GCS_CURSORPOS|
GCS_DELTASTART);
if (!lpCompStr->dwCursorPos) {
if (lpImcP->fdwImeMsg & (MSG_ALREADY_OPEN)) {
ClearCand(lpIMC);
lpImcP->fdwImeMsg = (lpImcP->fdwImeMsg | MSG_CLOSE_CANDIDATE) &
~(MSG_OPEN_CANDIDATE);
}
lpImcP->iImeState = CST_INIT;
if (lpImcP->fdwImeMsg & MSG_ALREADY_START) {
InitCompStr(lpCompStr);
lpImcP->fdwImeMsg = (lpImcP->fdwImeMsg | MSG_END_COMPOSITION) &
~(MSG_START_COMPOSITION);
return;
}
}
// reading string is composition string for some simple IMEs
// delta start is the same as cursor position for backspace
lpCompStr->dwCompReadAttrLen = lpCompStr->dwCompAttrLen =
lpCompStr->dwCompReadStrLen = lpCompStr->dwCompStrLen =
lpCompStr->dwDeltaStart = lpCompStr->dwCursorPos;
// clause also back one
*(LPDWORD)((LPBYTE)lpCompStr + lpCompStr->dwCompReadClauseOffset +
sizeof(DWORD)) = lpCompStr->dwCompReadStrLen;
#if defined(WINAR30)
// for quick key
if (lpIMC->fdwConversion & IME_CMODE_EUDC) {
} else if (lpImeL->fdwModeConfig & MODE_CONFIG_QUICK_KEY) {
Finalize(hIMC, lpIMC, lpCompStr, lpImcP, FALSE);
} else {
}
#endif
return;
}
#if defined(WINIME)
/**********************************************************************/
/* InternalCodeRange() */
/**********************************************************************/
BOOL PASCAL InternalCodeRange(
LPPRIVCONTEXT lpImcP,
WORD wCharCode)
{
if (!lpImcP->bSeq[0]) {
if (wCharCode >= '8' && wCharCode <= 'F') {
// 0x8??? - 0xF??? is OK
return (TRUE);
} else {
// there is no 0x0??? - 0x7???
return (FALSE);
}
} else if (!lpImcP->bSeq[1]) {
if (lpImcP->bSeq[0] == (0x08 + 1)) {
if (wCharCode <= '0') {
// there is no 0x80??
return (FALSE);
} else {
return (TRUE);
}
} else if (lpImcP->bSeq[0] == (0x0F + 1)) {
if (wCharCode >= 'F') {
// there is no 0xFF??
return (FALSE);
} else {
return (TRUE);
}
} else {
return (TRUE);
}
} else if (!lpImcP->bSeq[2]) {
if (wCharCode < '4') {
// there is no 0x??0?, 0x??1?, 0x??2?, 0x??3?
return (FALSE);
} else if (wCharCode < '8') {
return (TRUE);
} else if (wCharCode < 'A') {
// there is no 0x??8? & 0x??9?
return (FALSE);
} else {
return (TRUE);
}
} else if (!lpImcP->bSeq[3]) {
if (lpImcP->bSeq[2] == (0x07 + 1)) {
if (wCharCode >= 'F') {
// there is no 0x??7F
return (FALSE);
} else {
return (TRUE);
}
} else if (lpImcP->bSeq[2] == (0x0A + 1)) {
if (wCharCode <= '0') {
// there is no 0x??A0
return (FALSE);
} else {
return (TRUE);
}
} else if (lpImcP->bSeq[2] == (0x0F + 1)) {
if (wCharCode >= 'F') {
// there is no 0x??FF
return (FALSE);
} else {
return (TRUE);
}
} else {
return (TRUE);
}
} else {
return (TRUE);
}
}
#endif
/**********************************************************************/
/* CompStrInfo() */
/**********************************************************************/
void PASCAL CompStrInfo(
#if defined(UNIIME)
LPIMEL lpImeL,
#endif
LPCOMPOSITIONSTRING lpCompStr,
LPPRIVCONTEXT lpImcP,
LPGUIDELINE lpGuideLine,
WORD wCharCode)
{
#if defined(PHON)
DWORD i;
int cIndex;
#endif
register DWORD dwCursorPos;
if (lpCompStr->dwCursorPos < lpCompStr->dwCompStrLen) {
// for this kind of simple IME, previos is an error case
for (dwCursorPos = lpCompStr->dwCursorPos;
dwCursorPos < lpCompStr->dwCompStrLen;
dwCursorPos += sizeof(WCHAR) / sizeof(TCHAR)) {
lpImcP->bSeq[dwCursorPos / (sizeof(WCHAR) / sizeof(TCHAR))] = 0;
}
lpCompStr->dwCompReadAttrLen = lpCompStr->dwCompAttrLen =
lpCompStr->dwCompReadStrLen = lpCompStr->dwCompStrLen =
lpCompStr->dwDeltaStart = lpCompStr->dwCursorPos;
// tell app, there is a composition char changed
lpImcP->fdwImeMsg |= MSG_COMPOSITION;
lpImcP->fdwGcsFlag |= GCS_COMPREAD|GCS_COMP|
GCS_CURSORPOS|GCS_DELTASTART;
}
#if defined(PHON)
if (lpCompStr->dwCursorPos >= lpImeL->nMaxKey * sizeof(WCHAR) /
sizeof(TCHAR)) {
// this is for ImeSetCompositionString case
if (wCharCode == ' ') {
// finalized char is OK
lpImcP->dwCompChar = ' ';
return;
}
}
#else
if (wCharCode == ' ') {
// finalized char is OK
lpImcP->dwCompChar = ' ';
return;
}
#if defined(WINAR30) //**** 1996/2/5
if (wCharCode == 0x27) {
// finalized char is OK
lpImcP->dwCompChar = 0x27;
return;
}
#endif
if (lpCompStr->dwCursorPos < lpImeL->nMaxKey * sizeof(WCHAR) /
sizeof(TCHAR)) {
} else if (lpGuideLine) {
// exceed the max input key limitation
lpGuideLine->dwLevel = GL_LEVEL_ERROR;
lpGuideLine->dwIndex = GL_ID_TOOMANYSTROKE;
lpImcP->fdwImeMsg |= MSG_GUIDELINE;
#if defined(WINAR30) //1996/3/4
dwCursorPos = lpCompStr->dwCursorPos;
lpImcP->bSeq[dwCursorPos / (sizeof(WCHAR) / sizeof(TCHAR))] =
(BYTE)lpImeL->wChar2SeqTbl[wCharCode - ' '];
#endif
return;
} else {
MessageBeep((UINT)-1);
return;
}
#endif
if (lpImeL->fdwErrMsg & NO_REV_LENGTH) {
WORD nRevMaxKey;
nRevMaxKey = (WORD)ImmEscape(lpImeL->hRevKL, (HIMC)NULL,
IME_ESC_MAX_KEY, NULL);
if (nRevMaxKey > lpImeL->nMaxKey) {
lpImeL->nRevMaxKey = nRevMaxKey;
SetCompLocalData(lpImeL);
lpImcP->fdwImeMsg |= MSG_IMN_COMPOSITIONSIZE;
} else {
lpImeL->nRevMaxKey = lpImeL->nMaxKey;
if (!nRevMaxKey) {
lpImeL->hRevKL = NULL;
}
}
lpImeL->fdwErrMsg &= ~(NO_REV_LENGTH);
}
if (lpImcP->fdwImeMsg & MSG_ALREADY_START) {
lpImcP->fdwImeMsg &= ~(MSG_END_COMPOSITION);
} else {
lpImcP->fdwImeMsg = (lpImcP->fdwImeMsg | MSG_START_COMPOSITION) &
~(MSG_END_COMPOSITION);
}
if (lpImcP->iImeState == CST_INIT) {
// clean the 4 bytes in one time
*(LPDWORD)lpImcP->bSeq = 0;
#if defined(CHAJEI) || defined(WINAR30) || defined(UNIIME)
*(LPDWORD)&lpImcP->bSeq[4] = 0;
#endif
}
// get the sequence code, you can treat sequence code as a kind
// of compression - bo, po, mo, fo to 1, 2, 3, 4
// phonetic and array table file are in sequence code format
dwCursorPos = lpCompStr->dwCursorPos;
#if defined(PHON)
cIndex = cIndexTable[wCharCode - ' '];
if (cIndex * sizeof(WCHAR) / sizeof(TCHAR) >= dwCursorPos) {
} else if (lpGuideLine) {
lpGuideLine->dwLevel = GL_LEVEL_WARNING;
lpGuideLine->dwIndex = GL_ID_READINGCONFLICT;
lpImcP->fdwImeMsg |= MSG_GUIDELINE;
} else {
}
if (lpImcP->iImeState != CST_INIT) {
} else if (cIndex != 3) {
} else if (lpGuideLine) {
lpGuideLine->dwLevel = GL_LEVEL_WARNING;
lpGuideLine->dwIndex = GL_ID_TYPINGERROR;
lpImcP->fdwImeMsg |= MSG_GUIDELINE;
return;
} else {
MessageBeep((UINT)-1);
return;
}
lpImcP->bSeq[cIndex] = (BYTE)lpImeL->wChar2SeqTbl[wCharCode - ' '];
for (i = lpCompStr->dwCompReadStrLen; i < cIndex * sizeof(WCHAR) /
sizeof(TCHAR); i += sizeof(WCHAR) / sizeof(TCHAR)) {
// clean sequence code
lpImcP->bSeq[i / (sizeof(WCHAR) / sizeof(TCHAR))] = 0;
// add full shape space among the blank part
*((LPWSTR)((LPBYTE)lpCompStr + lpCompStr->dwCompReadStrOffset +
sizeof(TCHAR) * i)) = sImeG.wFullSpace;
}
dwCursorPos = cIndex * sizeof(WCHAR) / sizeof(TCHAR);
#else
lpImcP->bSeq[dwCursorPos / (sizeof(WCHAR) / sizeof(TCHAR))] =
(BYTE)lpImeL->wChar2SeqTbl[wCharCode - ' '];
#endif
// composition/reading string - bo po mo fo, reversed internal code
lpImcP->dwCompChar = (DWORD)lpImeL->wSeq2CompTbl[
lpImcP->bSeq[dwCursorPos / (sizeof(WCHAR) / sizeof(TCHAR))]];
// assign to reading string
*((LPWSTR)((LPBYTE)lpCompStr + lpCompStr->dwCompReadStrOffset +
dwCursorPos * sizeof(TCHAR))) = (WCHAR)lpImcP->dwCompChar;
#if defined(PHON)
// if the index greater, reading should be the same with index
if (lpCompStr->dwCompReadStrLen < (cIndex + 1) * (sizeof(WCHAR) /
sizeof(TCHAR))) {
lpCompStr->dwCompReadStrLen = (cIndex + 1) * (sizeof(WCHAR) /
sizeof(TCHAR));
}
#else
// add one composition reading for this input key
if (lpCompStr->dwCompReadStrLen <= dwCursorPos) {
lpCompStr->dwCompReadStrLen += sizeof(WCHAR) / sizeof(TCHAR);
}
#endif
// composition string is reading string for some simple IMEs
lpCompStr->dwCompStrLen = lpCompStr->dwCompReadStrLen;
// composition/reading attribute length is equal to reading string length
lpCompStr->dwCompReadAttrLen = lpCompStr->dwCompReadStrLen;
lpCompStr->dwCompAttrLen = lpCompStr->dwCompStrLen;
#ifdef UNICODE
*((LPBYTE)lpCompStr + lpCompStr->dwCompReadAttrOffset +
dwCursorPos) = ATTR_TARGET_CONVERTED;
#else
// composition/reading attribute - IME has converted these chars
*((LPWORD)((LPBYTE)lpCompStr + lpCompStr->dwCompReadAttrOffset +
dwCursorPos)) = ((ATTR_TARGET_CONVERTED << 8)|ATTR_TARGET_CONVERTED);
#endif
// composition/reading clause, 1 clause only
lpCompStr->dwCompReadClauseLen = 2 * sizeof(DWORD);
lpCompStr->dwCompClauseLen = lpCompStr->dwCompReadClauseLen;
*(LPDWORD)((LPBYTE)lpCompStr + lpCompStr->dwCompReadClauseOffset +
sizeof(DWORD)) = lpCompStr->dwCompReadStrLen;
// delta start from previous cursor position
lpCompStr->dwDeltaStart = lpCompStr->dwCursorPos;
#if defined(PHON)
if (dwCursorPos < lpCompStr->dwDeltaStart) {
lpCompStr->dwDeltaStart = dwCursorPos;
}
#endif
// cursor is next to the composition string
lpCompStr->dwCursorPos = lpCompStr->dwCompStrLen;
lpImcP->iImeState = CST_INPUT;
// tell app, there is a composition char generated
lpImcP->fdwImeMsg |= MSG_COMPOSITION;
#if !defined(UNICODE)
// swap the char from reversed internal code to internal code
lpImcP->dwCompChar = HIBYTE(lpImcP->dwCompChar) |
(LOBYTE(lpImcP->dwCompChar) << 8);
#endif
lpImcP->fdwGcsFlag |= GCS_COMPREAD|GCS_COMP|GCS_CURSORPOS|GCS_DELTASTART;
return;
}
/**********************************************************************/
/* Finalize() */
/* Return vlaue */
/* the number of candidates in the candidate list */
/**********************************************************************/
UINT PASCAL Finalize( // finalize Chinese word(s) by searching table
#if defined(UNIIME)
LPINSTDATAL lpInstL,
LPIMEL lpImeL,
#endif
HIMC hIMC,
LPINPUTCONTEXT lpIMC,
LPCOMPOSITIONSTRING lpCompStr,
LPPRIVCONTEXT lpImcP,
BOOL fFinalized)
{
LPCANDIDATEINFO lpCandInfo;
LPCANDIDATELIST lpCandList;
UINT nCand;
#if defined(WINIME) || defined(UNICDIME)
// quick key case
if (!lpImcP->bSeq[1]) {
lpImcP->fdwImeMsg = (lpImcP->fdwImeMsg | MSG_CLOSE_CANDIDATE) &
~(MSG_OPEN_CANDIDATE|MSG_CHANGE_CANDIDATE);
return (0);
}
#endif
if (!lpIMC->hCandInfo) {
return (0);
}
lpCandInfo = (LPCANDIDATEINFO)ImmLockIMCC(lpIMC->hCandInfo);
if (!lpCandInfo) {
return (0);
}
lpCandList = (LPCANDIDATELIST)
((LPBYTE)lpCandInfo + lpCandInfo->dwOffset[0]);
// start from 0
lpCandList->dwCount = 0;
// default start from 0
lpCandList->dwPageStart = lpCandList->dwSelection = 0;
#if defined(PHON)
if (!fFinalized) {
lpImcP->bSeq[3] = 0x26; // ' '
}
#endif
if (!ConvertSeqCode2Pattern(
#if defined(UNIIME)
lpImeL,
#endif
lpImcP->bSeq, lpImcP)) {
goto FinSrchOvr;
}
#if defined(WINAR30)
if (!fFinalized) {
if (lpImcP->iGhostCard != lpImeL->nMaxKey) {
// do not preview the ghost card '*'
goto FinSrchOvr;
} else if (lpImcP->dwLastWildCard) {
// do not preview the wild card '?'
goto FinSrchOvr;
} else if (!lpImcP->bSeq[2]) {
SearchQuickKey(lpCandList, lpImcP);
} else {
// search the IME tables
SearchTbl(0, lpCandList, lpImcP);
}
} else {
#else
{
#endif
// search the IME tables
SearchTbl(
#if defined(UNIIME)
lpImeL,
#endif
0, lpCandList, lpImcP);
}
#if !defined(WINIME) && !defined(UNICDIME) && !defined(ROMANIME)
#if defined(WINAR30)
if (!fFinalized) {
// quick key is not in fault tolerance table & user dictionary
goto FinSrchOvr;
}
#endif
if (lpInstL->hUsrDicMem) {
SearchUsrDic(
#if defined(UNIIME)
lpImeL,
#endif
lpCandList, lpImcP);
}
#endif
FinSrchOvr:
nCand = lpCandList->dwCount;
if (!fFinalized) {
#if defined(PHON)
lpImcP->bSeq[3] = 0x00; // clean previous assign one
#endif
// for quick key
lpCandInfo->dwCount = 1;
// open composition candidate UI window for the string(s)
if (lpImcP->fdwImeMsg & MSG_ALREADY_OPEN) {
lpImcP->fdwImeMsg = (lpImcP->fdwImeMsg | MSG_CHANGE_CANDIDATE) &
~(MSG_CLOSE_CANDIDATE);
} else {
lpImcP->fdwImeMsg = (lpImcP->fdwImeMsg | MSG_OPEN_CANDIDATE) &
~(MSG_CLOSE_CANDIDATE);
}
} else if (nCand == 0) { // nothing found, error
// move cursor back because this is wrong
#if defined(PHON)
// go back a compsoition char
lpCompStr->dwCursorPos -= sizeof(WCHAR) / sizeof(TCHAR);
for (; lpCompStr->dwCursorPos > 0; ) {
if (lpImcP->bSeq[lpCompStr->dwCursorPos / (sizeof(WCHAR) /
sizeof(TCHAR)) - 1]) {
break;
} else {
// no symbol in this position skip
lpCompStr->dwCursorPos -= sizeof(WCHAR) / sizeof(TCHAR);
}
}
if (lpCompStr->dwCursorPos < sizeof(WCHAR) / sizeof(TCHAR)) {
lpCompStr->dwCursorPos = 0;
lpImcP->iImeState = CST_INIT;
}
#elif defined(QUICK) || defined(WINIME) || defined(UNICDIME)
if (lpCompStr->dwCursorPos > sizeof(WCHAR) / sizeof(TCHAR)) {
lpCompStr->dwCursorPos = lpCompStr->dwCompReadStrLen -
sizeof(WCHAR) / sizeof(TCHAR);
} else {
lpCompStr->dwCursorPos = 0;
lpImcP->iImeState = CST_INIT;
}
#else
lpCompStr->dwCursorPos = 0;
lpImcP->iImeState = CST_INIT;
#endif
lpCompStr->dwDeltaStart = lpCompStr->dwCursorPos;
if (lpImcP->fdwImeMsg & MSG_ALREADY_START) {
lpImcP->fdwImeMsg = (lpImcP->fdwImeMsg | MSG_COMPOSITION) &
~(MSG_END_COMPOSITION);
} else {
lpImcP->fdwImeMsg = (lpImcP->fdwImeMsg | MSG_START_COMPOSITION) &
~(MSG_END_COMPOSITION);
}
// for quick key
lpCandInfo->dwCount = 0;
// close the quick key
if (lpImcP->fdwImeMsg & MSG_ALREADY_OPEN) {
lpImcP->fdwImeMsg = (lpImcP->fdwImeMsg | MSG_CLOSE_CANDIDATE) &
~(MSG_OPEN_CANDIDATE|MSG_CHANGE_CANDIDATE);
} else {
lpImcP->fdwImeMsg &= ~(MSG_OPEN_CANDIDATE|MSG_CLOSE_CANDIDATE);
}
lpImcP->fdwGcsFlag |= GCS_CURSORPOS|GCS_DELTASTART;
} else if (nCand == 1) { // only one choice
SelectOneCand(
#if defined(UNIIME)
lpImeL,
#endif
hIMC, lpIMC, lpCompStr, lpImcP, lpCandList);
} else {
lpCandInfo->dwCount = 1;
// there are more than one strings, open composition candidate UI window
if (lpImcP->fdwImeMsg & MSG_ALREADY_OPEN) {
lpImcP->fdwImeMsg = (lpImcP->fdwImeMsg | MSG_CHANGE_CANDIDATE) &
~(MSG_CLOSE_CANDIDATE);
} else {
lpImcP->fdwImeMsg = (lpImcP->fdwImeMsg | MSG_OPEN_CANDIDATE) &
~(MSG_CLOSE_CANDIDATE);
}
lpImcP->iImeState = CST_CHOOSE;
}
if (fFinalized) {
LPGUIDELINE lpGuideLine;
lpGuideLine = ImmLockIMCC(lpIMC->hGuideLine);
if (!lpGuideLine) {
} else if (!nCand) {
// nothing found, end user, you have an error now
lpGuideLine->dwLevel = GL_LEVEL_ERROR;
lpGuideLine->dwIndex = GL_ID_TYPINGERROR;
lpImcP->fdwImeMsg |= MSG_GUIDELINE;
} else if (nCand == 1) {
} else if (lpImeL->fwProperties1 & IMEPROP_CAND_NOBEEP_GUIDELINE) {
} else {
lpGuideLine->dwLevel = GL_LEVEL_WARNING;
// multiple selection
lpGuideLine->dwIndex = GL_ID_CHOOSECANDIDATE;
lpImcP->fdwImeMsg |= MSG_GUIDELINE;
}
if (lpGuideLine) {
ImmUnlockIMCC(lpIMC->hGuideLine);
}
}
ImmUnlockIMCC(lpIMC->hCandInfo);
return (nCand);
}
/**********************************************************************/
/* CompWord() */
/**********************************************************************/
void PASCAL CompWord( // compose the Chinese word(s) according to
// input key
#if defined(UNIIME)
LPINSTDATAL lpInstL,
LPIMEL lpImeL,
#endif
WORD wCharCode,
HIMC hIMC,
LPINPUTCONTEXT lpIMC,
LPCOMPOSITIONSTRING lpCompStr,
LPGUIDELINE lpGuideLine,
LPPRIVCONTEXT lpImcP)
{
if (!lpCompStr) {
MessageBeep((UINT)-1);
return;
}
// escape key
if (wCharCode == VK_ESCAPE) { // not good to use VK as char, but...
CompEscapeKey(lpIMC, lpCompStr, lpGuideLine, lpImcP);
return;
}
if (wCharCode == '\b') {
CompBackSpaceKey(hIMC, lpIMC, lpCompStr, lpImcP);
return;
}
if (wCharCode >= 'a' && wCharCode <= 'z') {
wCharCode ^= 0x20;
}
#if defined(PHON)
{
// convert to standard phonetic layout
wCharCode = bStandardLayout[lpImeL->nReadLayout][wCharCode - ' '];
}
#endif
#if defined(WINIME)
if (InternalCodeRange(lpImcP, wCharCode)) {
} else if (lpGuideLine) {
lpGuideLine->dwLevel = GL_LEVEL_ERROR;
lpGuideLine->dwIndex = GL_ID_TYPINGERROR;
lpImcP->fdwImeMsg |= MSG_GUIDELINE;
return;
} else {
MessageBeep((UINT)-1);
return;
}
#endif
// build up composition string info
CompStrInfo(
#if defined(UNIIME)
lpImeL,
#endif
lpCompStr, lpImcP, lpGuideLine, wCharCode);
if (lpIMC->fdwConversion & IME_CMODE_EUDC) {
#if defined(PHON) || defined(WINIME) || defined(UNICDIME)
if (lpCompStr->dwCompReadStrLen >= sizeof(WCHAR) / sizeof(TCHAR) *
lpImeL->nMaxKey) {
#else
if (wCharCode == ' ') {
#endif
lpImcP->fdwImeMsg |= MSG_COMPOSITION;
lpImcP->fdwGcsFlag |= GCS_RESULTREAD|GCS_RESULTSTR;
}
} else {
#if defined(PHON) || defined(WINIME) || defined(UNICDIME)
if (lpCompStr->dwCompReadStrLen < sizeof(WCHAR) / sizeof(TCHAR) *
lpImeL->nMaxKey) {
#elif defined(QUICK)
if (wCharCode != ' ' &&
lpCompStr->dwCompReadStrLen < sizeof(WCHAR) / sizeof(TCHAR) * 2) {
#else
if (wCharCode != ' ') {
#endif
#if defined(WINAR30)
// quick key
if(wCharCode != 0x27) //19963/9
{
if (lpImeL->fdwModeConfig & MODE_CONFIG_QUICK_KEY) {
Finalize(hIMC, lpIMC, lpCompStr, lpImcP, FALSE);
}
}
else
{
Finalize(
#if defined(UNIIME)
lpInstL, lpImeL,
#endif
hIMC, lpIMC, lpCompStr, lpImcP, TRUE);
}
#endif
return;
}
Finalize(
#if defined(UNIIME)
lpInstL, lpImeL,
#endif
hIMC, lpIMC, lpCompStr, lpImcP, TRUE);
}
return;
}
#endif
Reference in a new issue Copy permalink