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

650 lines
21 KiB
C
Raw Normal View History

2020-09-26 03:20:57 -05:00
/*************************************************
* compose.c *
* *
* Copyright (C) 1999 Microsoft Inc. *
* *
*************************************************/
#include <windows.h>
#include <immdev.h>
#include "imeattr.h"
#include "imedefs.h"
/**********************************************************************/
/* SearchTbl() */
/* Description: */
/* file format can be changed in different version for */
/* performance consideration, ISVs should not assume its format */
/**********************************************************************/
void PASCAL SearchTbl( // searching the standard table files
UINT uTblIndex,
LPCANDIDATELIST lpCandList,
LPPRIVCONTEXT lpImcP)
{
UINT uCode;
uCode = (lpImcP->bSeq[0] - 1) << 12;
uCode |= (lpImcP->bSeq[1] - 1) << 8;
uCode |= (lpImcP->bSeq[2] - 1) << 4;
uCode |= (lpImcP->bSeq[3] - 1);
if (uCode <= 0x001F ||
(uCode >= 0x007F && uCode <=0x009F))
{
//
// We want to block control code to avoid confusion.
//
return;
}
AddCodeIntoCand(lpCandList, uCode);
return;
}
/**********************************************************************/
/* AddCodeIntoCand() */
/**********************************************************************/
void PASCAL AddCodeIntoCand(
LPCANDIDATELIST lpCandList,
UINT uCode)
{
if (lpCandList->dwCount >= MAXCAND) {
// Grow memory here and do something,
// if you still want to process it.
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;
}
/**********************************************************************/
/* CompEscapeKey() */
/**********************************************************************/
void PASCAL CompEscapeKey(
LPINPUTCONTEXT lpIMC,
LPCOMPOSITIONSTRING lpCompStr,
LPPRIVCONTEXT lpImcP)
{
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 (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;
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;
return;
}
/**********************************************************************/
/* CompStrInfo() */
/**********************************************************************/
void PASCAL CompStrInfo(
LPCOMPOSITIONSTRING lpCompStr,
LPPRIVCONTEXT lpImcP,
LPGUIDELINE lpGuideLine,
WORD wCharCode)
{
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 (wCharCode == ' ') {
// finalized char is OK
lpImcP->dwCompChar = ' ';
return;
}
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;
return;
} else {
MessageBeep((UINT)-1);
return;
}
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;
}
// 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;
lpImcP->bSeq[dwCursorPos / (sizeof(WCHAR) / sizeof(TCHAR))] =
(BYTE)lpImeL->wChar2SeqTbl[wCharCode - ' '];
// 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;
// add one composition reading for this input key
if (lpCompStr->dwCompReadStrLen <= dwCursorPos) {
lpCompStr->dwCompReadStrLen += sizeof(WCHAR) / sizeof(TCHAR);
}
// 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;
*((LPBYTE)lpCompStr + lpCompStr->dwCompReadAttrOffset +
dwCursorPos) = ATTR_TARGET_CONVERTED;
// 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;
// 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;
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
HIMC hIMC,
LPINPUTCONTEXT lpIMC,
LPCOMPOSITIONSTRING lpCompStr,
LPPRIVCONTEXT lpImcP,
BOOL fFinalized)
{
LPCANDIDATEINFO lpCandInfo;
LPCANDIDATELIST lpCandList;
UINT nCand;
// quick key case
if (!lpImcP->bSeq[1]) {
lpImcP->fdwImeMsg = (lpImcP->fdwImeMsg | MSG_CLOSE_CANDIDATE) &
~(MSG_OPEN_CANDIDATE|MSG_CHANGE_CANDIDATE);
return (0);
}
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;
// search the IME tables
SearchTbl( 0, lpCandList, lpImcP);
nCand = lpCandList->dwCount;
if (!fFinalized) {
// 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 (lpCompStr->dwCursorPos > sizeof(WCHAR) / sizeof(TCHAR)) {
lpCompStr->dwCursorPos = lpCompStr->dwCompReadStrLen -
sizeof(WCHAR) / sizeof(TCHAR);
} else {
lpCompStr->dwCursorPos = 0;
lpImcP->iImeState = CST_INIT;
}
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(
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
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, lpImcP);
return;
}
if (wCharCode == '\b') {
CompBackSpaceKey(hIMC, lpIMC, lpCompStr, lpImcP);
return;
}
if (wCharCode >= 'a' && wCharCode <= 'z') {
wCharCode ^= 0x20;
}
// build up composition string info
CompStrInfo(lpCompStr, lpImcP, lpGuideLine, wCharCode);
if (lpIMC->fdwConversion & IME_CMODE_EUDC) {
if (lpCompStr->dwCompReadStrLen >= sizeof(WCHAR) / sizeof(TCHAR) *
lpImeL->nMaxKey) {
lpImcP->fdwImeMsg |= MSG_COMPOSITION;
lpImcP->fdwGcsFlag |= GCS_RESULTREAD|GCS_RESULTSTR;
}
} else {
if (lpCompStr->dwCompReadStrLen < sizeof(WCHAR) / sizeof(TCHAR) *
lpImeL->nMaxKey) {
return;
}
Finalize( hIMC, lpIMC, lpCompStr, lpImcP, TRUE);
}
return;
}
/**********************************************************************/
/* SelectOneCand() */
/**********************************************************************/
void PASCAL SelectOneCand(
HIMC hIMC,
LPINPUTCONTEXT lpIMC,
LPCOMPOSITIONSTRING lpCompStr,
LPPRIVCONTEXT lpImcP,
LPCANDIDATELIST lpCandList)
{
DWORD dwCompStrLen;
DWORD dwReadClauseLen, dwReadStrLen;
LPTSTR lpSelectStr;
LPGUIDELINE lpGuideLine;
if (!lpCompStr) {
MessageBeep((UINT)-1);
return;
}
if (!lpImcP) {
MessageBeep((UINT)-1);
return;
}
// backup the dwCompStrLen, this value decide whether
// we go for phrase prediction
dwCompStrLen = lpCompStr->dwCompStrLen;
// backup the value, this value will be destroyed in InitCompStr
dwReadClauseLen = lpCompStr->dwCompReadClauseLen;
dwReadStrLen = lpCompStr->dwCompReadStrLen;
lpSelectStr = (LPTSTR)((LPBYTE)lpCandList + lpCandList->dwOffset[
lpCandList->dwSelection]);
InitCompStr(lpCompStr);
// the result reading clause = compsotion reading clause
CopyMemory((LPBYTE)lpCompStr + lpCompStr->dwResultReadClauseOffset,
(LPBYTE)lpCompStr + lpCompStr->dwCompReadClauseOffset,
dwReadClauseLen * sizeof(TCHAR) + sizeof(TCHAR));
lpCompStr->dwResultReadClauseLen = dwReadClauseLen;
// the result reading string = compsotion reading string
CopyMemory((LPBYTE)lpCompStr + lpCompStr->dwResultReadStrOffset,
(LPBYTE)lpCompStr + lpCompStr->dwCompReadStrOffset,
dwReadStrLen * sizeof(TCHAR) + sizeof(TCHAR));
lpCompStr->dwResultReadStrLen = dwReadStrLen;
// calculate result string length
lpCompStr->dwResultStrLen = lstrlen(lpSelectStr);
// the result string = the selected candidate;
CopyMemory((LPBYTE)lpCompStr + lpCompStr->dwResultStrOffset, lpSelectStr,
lpCompStr->dwResultStrLen * sizeof(TCHAR) + sizeof(TCHAR));
lpCompStr->dwResultClauseLen = 2 * sizeof(DWORD);
*(LPDWORD)((LPBYTE)lpCompStr + lpCompStr->dwResultClauseOffset +
sizeof(DWORD)) = lpCompStr->dwResultStrLen;
// tell application, there is a reslut string
lpImcP->fdwImeMsg |= MSG_COMPOSITION;
lpImcP->dwCompChar = 0;
lpImcP->fdwGcsFlag |= GCS_COMPREAD|GCS_COMP|GCS_CURSORPOS|
GCS_DELTASTART|GCS_RESULTREAD|GCS_RESULT;
if (lpImcP->fdwImeMsg & MSG_ALREADY_OPEN) {
lpImcP->fdwImeMsg = (lpImcP->fdwImeMsg | MSG_CLOSE_CANDIDATE) &
~(MSG_OPEN_CANDIDATE|MSG_CHANGE_CANDIDATE);
} else {
lpImcP->fdwImeMsg &= ~(MSG_CLOSE_CANDIDATE|MSG_OPEN_CANDIDATE);
}
// no candidate now, the right candidate string already be finalized
lpCandList->dwCount = 0;
lpImcP->iImeState = CST_INIT;
*(LPDWORD)lpImcP->bSeq = 0;
//if ((WORD)lpIMC->fdwSentence != IME_SMODE_PHRASEPREDICT) {
if (!(lpIMC->fdwSentence & IME_SMODE_PHRASEPREDICT)) {
// not in phrase prediction mode
} else if (!dwCompStrLen) {
} else if (lpCompStr->dwResultStrLen != sizeof(WCHAR) / sizeof(TCHAR)) {
}
if (!lpCandList->dwCount) {
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);
}
}
if (!lpImeL->hRevKL) {
return;
}
if (lpCompStr->dwResultStrLen != sizeof(WCHAR) / sizeof(TCHAR)) {
// we only can reverse convert one DBCS character for now
if (lpImcP->fdwImeMsg & MSG_GUIDELINE) {
return;
}
}
lpGuideLine = ImmLockIMCC(lpIMC->hGuideLine);
if (!lpGuideLine) {
return;
}
if (lpCompStr->dwResultStrLen != sizeof(WCHAR) / sizeof(TCHAR)) {
// we only can reverse convert one DBCS character for now
lpGuideLine->dwLevel = GL_LEVEL_NOGUIDELINE;
lpGuideLine->dwIndex = GL_ID_UNKNOWN;
} else {
TCHAR szStrBuf[4];
UINT uSize;
*(LPDWORD)szStrBuf = 0;
*(LPWSTR)szStrBuf = *(LPWSTR)((LPBYTE)lpCompStr +
lpCompStr->dwResultStrOffset);
uSize = ImmGetConversionList(lpImeL->hRevKL, (HIMC)NULL, szStrBuf,
(LPCANDIDATELIST)((LPBYTE)lpGuideLine + lpGuideLine->dwPrivateOffset),
lpGuideLine->dwPrivateSize, GCL_REVERSECONVERSION);
if (uSize) {
lpGuideLine->dwLevel = GL_LEVEL_INFORMATION;
lpGuideLine->dwIndex = GL_ID_REVERSECONVERSION;
lpImcP->fdwImeMsg |= MSG_GUIDELINE;
if (lpImcP->fdwImeMsg & MSG_ALREADY_START) {
lpImcP->fdwImeMsg &= ~(MSG_END_COMPOSITION|
MSG_START_COMPOSITION);
} else {
lpImcP->fdwImeMsg = (lpImcP->fdwImeMsg|
MSG_START_COMPOSITION) & ~(MSG_END_COMPOSITION);
}
} else {
lpGuideLine->dwLevel = GL_LEVEL_NOGUIDELINE;
lpGuideLine->dwIndex = GL_ID_UNKNOWN;
}
}
ImmUnlockIMCC(lpIMC->hGuideLine);
return;
}