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

1635 lines
49 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:
ddis.c
++*/
#include <windows.h>
#include <windowsx.h>
#include <winerror.h>
#include <immdev.h>
#include <imedefs.h>
#include <resource.h>
#include <regstr.h>
#include <winuser.h>
HWND hCrtDlg = NULL;
/**********************************************************************/
/* ImeInquire() */
/* Return Value: */
/* TRUE - successful, FALSE - failure */
/**********************************************************************/
BOOL WINAPI ImeInquire( // initialized data structure of IME
LPIMEINFO lpImeInfo, // IME specific data report to IMM
LPTSTR lpszWndCls, // the class name of UI
DWORD dwSystemInfoFlags)
{
if (!lpImeInfo) {
return (FALSE);
}
lpImeInfo->dwPrivateDataSize = sizeof(PRIVCONTEXT);
lpImeInfo->fdwProperty = IME_PROP_KBD_CHAR_FIRST|
#ifdef UNICODE
IME_PROP_UNICODE|
#endif
IME_PROP_CANDLIST_START_FROM_1|
IME_PROP_IGNORE_UPKEYS;
lpImeInfo->fdwConversionCaps = IME_CMODE_NATIVE|IME_CMODE_FULLSHAPE|
IME_CMODE_CHARCODE|IME_CMODE_SOFTKBD|IME_CMODE_NOCONVERSION;
lpImeInfo->fdwSentenceCaps = 0;
// IME will have different distance base multiple of 900 escapement
lpImeInfo->fdwUICaps = UI_CAP_ROT90|UI_CAP_SOFTKBD;
// composition string is the reading string for simple IME
lpImeInfo->fdwSCSCaps = SCS_CAP_COMPSTR|SCS_CAP_MAKEREAD;
// IME want to decide conversion mode on ImeSelect
lpImeInfo->fdwSelectCaps = (DWORD)0;
lstrcpy(lpszWndCls, (LPTSTR)szUIClassName);
if ( lpImeL )
{
if ( dwSystemInfoFlags & IME_SYSINFO_WINLOGON )
{
// the client app is running in logon mode.
lpImeL->fWinLogon = TRUE;
}
else
lpImeL->fWinLogon = FALSE;
}
return (TRUE);
}
#if defined(CROSSREF)
/**********************************************************************/
/* ReverseConversionList() */
/**********************************************************************/
void PASCAL ReverseConversionList(HWND hLayoutListBox)
{
int nLayouts, i, nIMEs;
TCHAR szTmpImeName[24];
HKL FAR *lpKLMem;
LoadString(hInst, IDS_NONE, szTmpImeName, sizeof(szTmpImeName)/sizeof(TCHAR));
SendMessage(hLayoutListBox, LB_INSERTSTRING,
0, (LPARAM)szTmpImeName);
SendMessage(hLayoutListBox, LB_SELECTSTRING,
0, (LPARAM)szTmpImeName);
SendMessage(hLayoutListBox, LB_SETITEMDATA,
0, (LPARAM)(HKL)NULL);
nLayouts = GetKeyboardLayoutList(0, NULL);
lpKLMem = GlobalAlloc(GPTR, sizeof(HKL) * nLayouts);
if (!lpKLMem) {
return;
}
GetKeyboardLayoutList(nLayouts, lpKLMem);
for (i = 0, nIMEs = 0; i < nLayouts; i++) {
HKL hKL;
hKL = *(lpKLMem + i);
if (LOWORD(hKL) != NATIVE_LANGUAGE) {
// not support other language
continue;
}
if (!ImmGetConversionList(hKL, (HIMC)NULL, NULL,
NULL, 0, GCL_REVERSECONVERSION)) {
// this IME not support reverse conversion
continue;
}
if (!ImmEscape(hKL, (HIMC)NULL, IME_ESC_IME_NAME,
szTmpImeName)) {
// this IME does not report the IME name
continue;
}
if( lstrcmp(szTmpImeName, szImeName) == 0)
continue;
nIMEs++;
SendMessage(hLayoutListBox, LB_INSERTSTRING,
nIMEs, (LPARAM)szTmpImeName);
if (hKL == sImeG.hRevKL) {
SendMessage(hLayoutListBox, LB_SELECTSTRING, nIMEs,
(LPARAM)szTmpImeName);
}
SendMessage(hLayoutListBox, LB_SETITEMDATA,
nIMEs, (LPARAM)hKL);
}
GlobalFree((HGLOBAL)lpKLMem);
return;
}
#endif //CROSSREF
/**********************************************************************/
/* ImeSetDlgProc() */
/* Return Value: */
/* TRUE - successful, FALSE - failure */
/**********************************************************************/
BOOL FAR PASCAL ImeSetDlgProc( // dialog procedure of configuration
HWND hDlg,
UINT uMessage,
WORD wParam,
LONG lParam)
{
RECT rc;
LONG DlgWidth, DlgHeight;
static DWORD TempParam;
#ifdef CROSSREF
HIMC hIMC;
LPINPUTCONTEXT lpIMC;
HWND hLayoutListBox;
static HIMC hOldIMC;
#endif //CROSSREF
switch (uMessage) {
case WM_INITDIALOG:
hCrtDlg = hDlg;
// reset position
GetWindowRect(hDlg, &rc);
DlgWidth = rc.right - rc.left;
DlgHeight = rc.bottom - rc.top;
SetWindowPos(hDlg, HWND_TOP,
(int)(sImeG.rcWorkArea.right - DlgWidth)/2,
(int)(sImeG.rcWorkArea.bottom - DlgHeight)/2,
(int)0, (int)0, SWP_NOSIZE);
TempParam = sImeG.IC_Trace;
CheckDlgButton (hDlg, IDC_TRACE, sImeG.IC_Trace);
#ifdef CROSSREF
hLayoutListBox = GetDlgItem(hDlg, IDD_LAYOUT_LIST);
hIMC = ImmGetContext(hLayoutListBox);
if(hIMC){
ImmSetOpenStatus(hIMC, FALSE);
}
ImmReleaseContext(hLayoutListBox, hIMC);
// put all reverse conversion hKL into this list
ReverseConversionList(hLayoutListBox);
#endif //CROSSREF
return (TRUE); // don't want to set focus to special control
case WM_COMMAND:
switch (wParam) {
case IDOK:
{
HKEY hKeyCurrVersion;
HKEY hKeyGB;
DWORD retCode;
//CHAR Buf[LINE_LEN];
sImeG.IC_Trace = TempParam;
retCode = OpenReg_PathSetup(&hKeyCurrVersion);
if (retCode) {
RegCreateKey(HKEY_CURRENT_USER,
REGSTR_PATH_SETUP,
&hKeyCurrVersion);
}
#if defined(COMBO_IME)
if ( hKeyCurrVersion != NULL )
{
retCode = RegCreateKeyEx(hKeyCurrVersion,
szImeRegName,
0,
NULL,
REG_OPTION_NON_VOLATILE,
KEY_ALL_ACCESS,
NULL,
&hKeyGB,
NULL);
}
#else
if ( hKeyCurrVersion != NULL )
{
retCode = RegCreateKeyEx(hKeyCurrVersion,
szImeName,
0,
NULL,
REG_OPTION_NON_VOLATILE,
KEY_ALL_ACCESS,
NULL,
&hKeyGB,
NULL);
}
#endif //COMBO_IME
if (hKeyGB != NULL){
RegSetValueEx (hKeyGB,
szTrace,
(DWORD)0,
REG_DWORD,
(LPBYTE)&sImeG.IC_Trace,
sizeof(DWORD));
RegCloseKey(hKeyGB);
}
if ( hKeyCurrVersion )
RegCloseKey(hKeyCurrVersion);
#ifdef CROSSREF
{
HWND hLayoutListBox;
int iCurSel;
HKL hKL;
DWORD retCode;
hLayoutListBox = GetDlgItem(hDlg, IDD_LAYOUT_LIST);
iCurSel = (int)SendMessage(hLayoutListBox, LB_GETCURSEL, 0, 0);
hKL = (HKL)SendMessage(hLayoutListBox, LB_GETITEMDATA,
iCurSel, 0);
if (sImeG.hRevKL != hKL) {
WORD nRevMaxKey;
HKEY hKeyAppUser, hKeyIMEUser;
LPPRIVCONTEXT lpImcP;
sImeG.hRevKL = hKL;
//set reverse layout to registry
retCode = OpenReg_PathSetup(&hKeyAppUser);
if (retCode) {
RegCreateKey(HKEY_CURRENT_USER, REGSTR_PATH_SETUP, &hKeyCurrVersion);
}
#if defined(COMBO_IME)
retCode = RegCreateKeyEx(hKeyAppUser, szImeRegName, 0,
NULL, REG_OPTION_NON_VOLATILE, KEY_ALL_ACCESS , NULL, &hKeyIMEUser, NULL);
if (retCode) {
DWORD dwDisposition;
retCode = RegCreateKeyEx (hKeyCurrVersion,
szImeRegName,
0,
0,
REG_OPTION_NON_VOLATILE,
KEY_ALL_ACCESS,
NULL,
&hKeyGB,
&dwDisposition);
}
#else
retCode = RegCreateKeyEx(hKeyAppUser, szImeName, 0,
NULL, REG_OPTION_NON_VOLATILE, KEY_ALL_ACCESS , NULL, &hKeyIMEUser, NULL);
if (retCode) {
DWORD dwDisposition;
retCode = RegCreateKeyEx (hKeyCurrVersion,
szImeName,
0,
0,
REG_OPTION_NON_VOLATILE,
KEY_ALL_ACCESS,
NULL,
&hKeyGB,
&dwDisposition);
}
#endif //COMBO_IME
RegSetValueEx(hKeyIMEUser, szRegRevKL, 0, REG_DWORD, (LPBYTE)&hKL,sizeof(hKL));
// get the new size
nRevMaxKey = (WORD)ImmEscape(hKL, (HIMC)NULL, IME_ESC_MAX_KEY,
NULL);
if (lpImeL->nMaxKey != nRevMaxKey) {
if(lpImeL->nMaxKey < nRevMaxKey)
lpImeL->nMaxKey = nRevMaxKey;
// set the width & height for composition window
lpImeL->rcCompText.right = lpImeL->rcCompText.left +
sImeG.xChiCharWi * ((lpImeL->nMaxKey+2)/2);
lpImeL->xCompWi = lpImeL->rcCompText.right + lpImeL->cxCompBorder * (2 + 4);
//generate message to broadcast change comp win size
hIMC = (HIMC)ImmGetContext(hDlg);
if (!hIMC) {
return TRUE;
}
lpIMC = (LPINPUTCONTEXT)ImmLockIMC(hIMC);
if (!lpIMC) {
return TRUE;
}
lpImcP = (LPPRIVCONTEXT)ImmLockIMCC(lpIMC->hPrivate);
if (!lpImcP) {
goto ChgConfigUnlockIMC;
}
lpImcP->fdwImeMsg |= MSG_IMN_COMPOSITIONPOS;
GenerateMessage(hIMC, lpIMC, lpImcP);
ImmUnlockIMCC(lpIMC->hPrivate);
ChgConfigUnlockIMC:
ImmUnlockIMC(hIMC);
} //end of change nMaxKey
RegSetValueEx(hKeyIMEUser, szRegRevMaxKey, 0, REG_DWORD, (LPBYTE)&lpImeL->nMaxKey,sizeof(DWORD));
RegCloseKey(hKeyAppUser);
RegCloseKey(hKeyIMEUser);
} //end of change RegRevKL
}
#endif //CROSSREF
}
#ifdef CROSSREF
hLayoutListBox = GetDlgItem(hDlg, IDD_LAYOUT_LIST);
hIMC = ImmGetContext(hLayoutListBox);
if(hIMC) {
ImmSetOpenStatus(hIMC, TRUE);
}
ImmReleaseContext(hLayoutListBox, hIMC);
#endif //CROSSREF
EndDialog(hDlg, FALSE);
break;
case IDCANCEL:
#ifdef CROSSREF
hLayoutListBox = GetDlgItem(hDlg, IDD_LAYOUT_LIST);
hIMC = ImmGetContext(hLayoutListBox);
if(hIMC) {
ImmSetOpenStatus(hIMC, TRUE);
}
ImmReleaseContext(hLayoutListBox, hIMC);
#endif //CROSSREF
EndDialog(hDlg, FALSE);
break;
case IDC_TRACE:
// Set Current InputMode Param(temp)
TempParam = (TempParam ^ 0x00000001) & 0x00000001;
break;
default:
return (FALSE);
}
return (TRUE);
case WM_PAINT:
{
RECT rc;
GetClientRect(hDlg, &rc);
DrawConvexRect(GetDC(hDlg),
rc.left + 7,
rc.top + 7,
rc.right - 7 - 1,
rc.bottom - 40 - 1);
DrawConvexRectP(GetDC(hDlg),
rc.left + 7,
rc.top + 7,
rc.right - 7,
rc.bottom - 40);
}
return (FALSE);
case WM_CLOSE:
#ifdef CROSSREF
hLayoutListBox = GetDlgItem(hDlg, IDD_LAYOUT_LIST);
hIMC = ImmGetContext(hLayoutListBox);
if(hIMC) {
ImmSetOpenStatus(hIMC, TRUE);
}
ImmReleaseContext(hLayoutListBox, hIMC);
#endif //CROSSREF
EndDialog(hDlg, FALSE);
return (TRUE);
default:
return (FALSE);
}
return (TRUE);
}
/**********************************************************************/
/* ImeConfigure() */
/* Return Value: */
/* TRUE - successful, FALSE - failure */
/**********************************************************************/
/*BOOL WINAPI ImeConfigure( // configurate the IME setting
HKL hKL, // hKL of this IME
HWND hAppWnd, // the owner window
DWORD dwMode) // mode of dialog
{*/
BOOL WINAPI ImeConfigure( // configurate the IME setting
HKL hKL, // hKL of this IME
HWND hAppWnd, // the owner window
DWORD dwMode,
LPVOID lpData) // mode of dialog
{
switch (dwMode) {
case IME_CONFIG_GENERAL:
DialogBox(hInst, TEXT("ImeSet"), (HWND)hAppWnd, (DLGPROC)ImeSetDlgProc);
break;
default:
return (FALSE);
break;
}
return (TRUE);
}
/**********************************************************************/
/* XGBConversion() */
/**********************************************************************/
DWORD PASCAL XGBConversion(
LPCTSTR lpszReading,
LPCANDIDATELIST lpCandList,
UINT uBufLen)
{
UINT MAX_COMP;
UINT uMaxCand;
UINT iRet;
WORD wCode;
LPPRIVCONTEXT lpImcP;
HGLOBAL hImcP;
int i;
DWORD dwSize;
if (!(lstrlen (lpszReading) == 4)) {
return (0);
}
hImcP = GlobalAlloc (GMEM_MOVEABLE,sizeof (PRIVCONTEXT));
if(!hImcP){
return(0);
}
lpImcP= GlobalLock (hImcP);
if(!lpImcP){
GlobalFree(hImcP);
return(0);
}
lstrcpy (lpImcP->bSeq,lpszReading);
if(lpImcP->bSeq[3] == TEXT('?')){
MAX_COMP = 178;
} else {
MAX_COMP = 1;
}
dwSize = // similar to ClearCand
// header length
sizeof(CANDIDATELIST) +
// candidate string pointers
sizeof(DWORD) * MAX_COMP +
// string plus NULL terminator
(sizeof(WORD) + sizeof(TCHAR)) * MAX_COMP;
if (!uBufLen) {
return (dwSize);
}
uMaxCand = uBufLen - sizeof(CANDIDATELIST);
uMaxCand /= sizeof(DWORD) + sizeof(WORD) + sizeof(TCHAR);
if (!uMaxCand) {
// can not even put one string
return (0);
}
lpCandList->dwSize = dwSize;
lpCandList->dwStyle = IME_CAND_READ; // candidate having same reading
lpCandList->dwCount = 0;
lpCandList->dwSelection = 0;
lpCandList->dwPageSize = CANDPERPAGE;
lpCandList->dwOffset[0] = sizeof(CANDIDATELIST) + sizeof(DWORD) *
(uMaxCand - 1);
lpImcP->bSeq[0] = 0;
lpImcP->bSeq[1] = 0;
lpImcP->bSeq[2] = 0;
lpImcP->bSeq[3] = 0;
for (i=0;i<4;i++) {
iRet = XGBProcessKey(*(LPBYTE)((LPBYTE)lpszReading+i),lpImcP);
if (iRet == CST_INPUT) {
lpImcP->bSeq[i] = *(LPBYTE)((LPBYTE)lpszReading+i);
} else {
return (DWORD)0;
}
}
wCode = XGBEngine(lpImcP);
wCode = HIBYTE(wCode) | (LOBYTE(wCode) << 8);
for (i = 0; i < (0x7e-0x40+1); i++, wCode++) {
XGBAddCodeIntoCand(lpCandList, wCode);
}
wCode ++;
for (i = 0; i < (0xfe-0x80+1); i++, wCode++) {
XGBAddCodeIntoCand(lpCandList, wCode);
}
GlobalUnlock (hImcP);
GlobalFree (hImcP);
return (dwSize);
}
/**********************************************************************/
/* Conversion() */
/**********************************************************************/
DWORD PASCAL Conversion(
LPCTSTR lpszReading,
LPCANDIDATELIST lpCandList,
UINT uBufLen)
{
UINT MAX_COMP,i;
UINT uMaxCand;
UINT iRet;
WORD wCode;
LPPRIVCONTEXT lpImcP;
HGLOBAL hImcP;
DWORD dwSize;
if (!(lstrlen (lpszReading) == 4)) {
return (0);
}
hImcP = GlobalAlloc (GMEM_MOVEABLE,sizeof (PRIVCONTEXT));
if(!hImcP){
return(0);
}
lpImcP= GlobalLock (hImcP);
if(!lpImcP){
GlobalFree(hImcP);
return(0);
}
lstrcpy (lpImcP->bSeq,lpszReading);
if(lpImcP->bSeq[3] == TEXT('?')){
MAX_COMP = 94;
} else {
MAX_COMP = 1;
}
dwSize = // similar to ClearCand
// header length
sizeof(CANDIDATELIST) +
// candidate string pointers
sizeof(DWORD) * MAX_COMP +
// string plus NULL terminator
(sizeof(WORD) + sizeof(TCHAR)) * MAX_COMP;
if (!uBufLen) {
return (dwSize);
}
uMaxCand = uBufLen - sizeof(CANDIDATELIST);
uMaxCand /= sizeof(DWORD) + sizeof(WORD) + sizeof(TCHAR);
if (!uMaxCand) {
// can not even put one string
return (0);
}
lpCandList->dwSize = dwSize;
lpCandList->dwStyle = IME_CAND_READ; // candidate having same reading
lpCandList->dwCount = 0;
lpCandList->dwSelection = 0;
lpCandList->dwPageSize = CANDPERPAGE;
lpCandList->dwOffset[0] = sizeof(CANDIDATELIST) + sizeof(DWORD) *
(uMaxCand - 1);
lpImcP->bSeq[0] = 0;
lpImcP->bSeq[1] = 0;
lpImcP->bSeq[2] = 0;
lpImcP->bSeq[3] = 0;
for (i=0;i<4;i++) {
iRet = GBProcessKey(*(LPBYTE)((LPBYTE)lpszReading+i),lpImcP);
if (iRet == CST_INPUT) {
lpImcP->bSeq[i] = *(LPBYTE)((LPBYTE)lpszReading+i);
} else {
return (DWORD)0;
}
}
wCode = GBEngine (lpImcP);
wCode = HIBYTE(wCode) | (LOBYTE(wCode) << 8);
for (i = 0; i < MAX_COMP;i++, wCode++) {
AddCodeIntoCand(lpCandList, wCode);
}
GlobalUnlock (hImcP);
GlobalFree (hImcP);
return (dwSize);
}
/**************************************************************************
BOOL DBCSToGBCode ( WORD wCode, BYTE AbSeq[5])
***************************************************************************/
BOOL DBCSToGBCode (
WORD wCode,
TCHAR AbSeq[5])
{
WORD AreaCode;
#ifdef UNICODE
//Converte Unicode to GBK
// change CP_ACP to 936, so that it can work under Multilingul Env.
WideCharToMultiByte(NATIVE_ANSI_CP, WC_COMPOSITECHECK, &wCode, 1, (char *)&AreaCode, 2, NULL, NULL);
wCode = AreaCode;
#endif
//check valid GB range code first
#if defined(COMBO_IME)
if(sImeL.dwRegImeIndex==INDEX_GB){
if(LOBYTE(wCode) < 0xa1 || LOBYTE(wCode) > 0xfe
|| HIBYTE(wCode) < 0xa1 || HIBYTE(wCode) > 0xfe)
return FALSE;
AbSeq[1] = ((wCode -0xa0) % 256) % 10;
AbSeq[0] = ((wCode -0xa0) % 256) / 10;
AreaCode = (wCode - 0xa0 -AbSeq[0] * 10 -AbSeq[1])/256;
AbSeq[3] = ((AreaCode -0xa0) % 256) % 10;
AbSeq[2] = ((AreaCode -0xa0) % 256) / 10;
AbSeq[4] = TEXT('\0';)
}else if(sImeL.dwRegImeIndex==INDEX_GBK || sImeL.dwRegImeIndex==INDEX_UNICODE){
WORD tmp;
tmp = HIBYTE(wCode) | (LOBYTE(wCode)<<8);
wsprintf(AbSeq,TEXT("%04x"), tmp);
}
else
return FALSE;
#else //COMBO_IME
#ifdef GB
if(LOBYTE(wCode) < 0xa1 || LOBYTE(wCode) > 0xfe
|| HIBYTE(wCode) < 0xa1 || HIBYTE(wCode) > 0xfe)
return FALSE;
AbSeq[1] = ((wCode -0xa0) % 256) % 10;
AbSeq[0] = ((wCode -0xa0) % 256) / 10;
AreaCode = (wCode - 0xa0 -AbSeq[0] * 10 -AbSeq[1])/256;
AbSeq[3] = ((AreaCode -0xa0) % 256) % 10;
AbSeq[2] = ((AreaCode -0xa0) % 256) / 10;
AbSeq[4] = TEXT('\0');
#else
{
WORD tmp;
tmp = HIBYTE(wCode) | (LOBYTE(wCode)<<8);
wsprintf(AbSeq,TEXT("%04x"), tmp);
}
#endif //GB
#endif //COMBO_IME
return TRUE;
}
/***************************************************************************
BOOL AreaToGB ( BYTE AbSeq[5],BYTE GbSeq[5])
***************************************************************************/
BOOL AreaToGB (
TCHAR AbSeq[5],
TCHAR GbSeq[5])
{
TCHAR MbSeq[3]; // Temp string
// Area turn
wsprintf (MbSeq,TEXT("%lx"),(AbSeq[0] * 10 + AbSeq[1]+0xa0));
GbSeq[0] = MbSeq[0];
GbSeq[1] = MbSeq[1];
//position turn
wsprintf (MbSeq,TEXT("%lx"),(AbSeq[2] * 10 + AbSeq[3]+0xa0));
GbSeq[2] = MbSeq[0];
GbSeq[3] = MbSeq[1];
GbSeq[4] = TEXT('\0');
return TRUE;
}
#if defined(COMBO_IME)
/**********************************************************************/
/* UnicodeReverseConversion() */
/**********************************************************************/
DWORD PASCAL UnicodeReverseConversion(
WORD wCode,
LPCANDIDATELIST lpCandList,
UINT uBufLen)
{
UINT MAX_COMP = 1;
UINT nMaxKey = 4;
TCHAR AbSeq[5];
UINT uMaxCand;
DWORD dwSize = // similar to ClearCand
// header length
sizeof(CANDIDATELIST) +
// candidate string pointers
sizeof(DWORD) * MAX_COMP +
// string plus NULL terminator
(sizeof(TCHAR) * nMaxKey + sizeof(TCHAR));
if (!uBufLen) {
return (dwSize);
}
uMaxCand = uBufLen - sizeof(CANDIDATELIST);
uMaxCand /= sizeof(DWORD) +
(sizeof(TCHAR) * nMaxKey + sizeof(TCHAR));
if (uMaxCand == 0) {
// can not put one string
return (0);
}
lpCandList->dwSize = sizeof(CANDIDATELIST) +
sizeof(DWORD) * uMaxCand +
(sizeof(TCHAR) * nMaxKey + sizeof(TCHAR));
lpCandList->dwStyle = IME_CAND_READ;
lpCandList->dwCount = 0;
lpCandList->dwSelection = 0;
//lpCandList->dwPageSize = CANDPERPAGE; New Spac
lpCandList->dwOffset[0] = sizeof(CANDIDATELIST) + sizeof(DWORD) ;
#ifndef UNICODE
{
WCHAR szWideStr[2];
int i;
memset(szWideStr, 0, sizeof(szWideStr));
// change CP_ACP to 936, so that it can work under Multilingul Env.
MultiByteToWideChar(NATIVE_ANSI_CP, 0, (LPCSTR)&wCode, sizeof(WORD), szWideStr, sizeof(szWideStr));
wCode = HIBYTE((WORD)szWideStr[0]) | (LOBYTE((WORD)szWideStr[0]) << 8 );
}
if(!DBCSToGBCode (wCode, AbSeq))
return 0; //actual is DBCSToGBInternalCode
#endif
wsprintf(AbSeq,TEXT("%04x"), wCode);
lstrcpy((LPTSTR)((LPBYTE)lpCandList + lpCandList->dwOffset[0]),AbSeq);
// string count ++
lpCandList->dwCount = 1;
return (dwSize);
}
#endif //COMBO_IME
/**********************************************************************/
/* XGBReverseConversion() */
/**********************************************************************/
DWORD PASCAL XGBReverseConversion(
WORD wCode,
LPCANDIDATELIST lpCandList,
UINT uBufLen)
{
UINT MAX_COMP = 1;
UINT nMaxKey = 4;
TCHAR AbSeq[5];
UINT uMaxCand;
DWORD dwSize = // similar to ClearCand
// header length
sizeof(CANDIDATELIST) +
// candidate string pointers
sizeof(DWORD) * MAX_COMP +
// string plus NULL terminator
(sizeof(TCHAR) * nMaxKey + sizeof(TCHAR));
if (!uBufLen) {
return (dwSize);
}
uMaxCand = uBufLen - sizeof(CANDIDATELIST);
uMaxCand /= sizeof(DWORD) +
(sizeof(TCHAR) * nMaxKey + sizeof(TCHAR));
if (uMaxCand == 0) {
// can not put one string
return (0);
}
lpCandList->dwSize = sizeof(CANDIDATELIST) +
sizeof(DWORD) * uMaxCand +
(sizeof(TCHAR) * nMaxKey + sizeof(TCHAR));
lpCandList->dwStyle = IME_CAND_READ;
lpCandList->dwCount = 0;
lpCandList->dwSelection = 0;
//lpCandList->dwPageSize = CANDPERPAGE; New Spac
lpCandList->dwOffset[0] = sizeof(CANDIDATELIST) + sizeof(DWORD) ;
if(!DBCSToGBCode (wCode, AbSeq))
return 0; //actual is DBCSToGBInternalCode
lstrcpy((LPTSTR)((LPBYTE)lpCandList + lpCandList->dwOffset[0]),AbSeq);
// string count ++
lpCandList->dwCount = 1;
return (dwSize);
}
/**********************************************************************/
/* ReverseConversion() */
/**********************************************************************/
DWORD PASCAL ReverseConversion(
WORD wCode,
LPCANDIDATELIST lpCandList,
UINT uBufLen)
{
UINT MAX_COMP = 2;
UINT nMaxKey = 4;
TCHAR AbSeq[5];
TCHAR GbSeq[5];
UINT uMaxCand;
DWORD dwSize = // similar to ClearCand
// header length
sizeof(CANDIDATELIST) +
// candidate string pointers
sizeof(DWORD) * MAX_COMP +
// string plus NULL terminator
(sizeof(TCHAR) * nMaxKey + sizeof(TCHAR));
if (!uBufLen) {
return (dwSize);
}
uMaxCand = uBufLen - sizeof(CANDIDATELIST);
uMaxCand /= sizeof(DWORD) +
(sizeof(TCHAR) * nMaxKey + sizeof(TCHAR));
if (uMaxCand == 0) {
// can not put one string
return (0);
}
lpCandList->dwSize = sizeof(CANDIDATELIST) +
sizeof(DWORD) * uMaxCand +
(sizeof(TCHAR) * nMaxKey + sizeof(TCHAR));
lpCandList->dwStyle = IME_CAND_READ;
lpCandList->dwCount = 0;
lpCandList->dwSelection = 0;
//lpCandList->dwPageSize = CANDPERPAGE; New Spac
lpCandList->dwOffset[0] = sizeof(CANDIDATELIST) + sizeof(DWORD) ;
if(!DBCSToGBCode (wCode, AbSeq))
return 0;
AreaToGB (AbSeq, GbSeq);
AbSeq[1] +=TEXT('0');
AbSeq[0] +=TEXT('0');
AbSeq[3] +=TEXT('0');
AbSeq[2] +=TEXT('0');
lstrcpy((LPTSTR)((LPBYTE)lpCandList + lpCandList->dwOffset[0]),AbSeq);
lpCandList->dwOffset[1] =
lpCandList->dwOffset[0] + 4*sizeof(TCHAR) + sizeof(TCHAR);
lstrcpy((LPTSTR)((LPBYTE)lpCandList + lpCandList->dwOffset[1]),GbSeq);
// string count ++
lpCandList->dwCount = 2;
return (dwSize);
}
/**********************************************************************/
/* ImeConversionList() */
/**********************************************************************/
DWORD WINAPI ImeConversionList(
HIMC hIMC,
LPCTSTR lpszSrc,
LPCANDIDATELIST lpCandList,
DWORD uBufLen,
UINT uFlag)
{
WORD wCode;
LPINPUTCONTEXT lpIMC;
LPPRIVCONTEXT lpImcP;
if (!uBufLen) {
} else if (!lpszSrc) {
return (0);
} else if (!*lpszSrc) {
return (0);
} else if (!lpCandList) {
return (0);
} else if (uBufLen <= sizeof(CANDIDATELIST)) {
// buffer size can not even put the header information
return (0);
}
switch (uFlag) {
case GCL_CONVERSION:
lpIMC = (LPINPUTCONTEXT)ImmLockIMC(hIMC);
if (!lpIMC) {
return (FALSE);
}
lpImcP = (LPPRIVCONTEXT)ImmLockIMCC(lpIMC->hPrivate);
if (!lpImcP) {
ImmUnlockIMC(hIMC);
return (FALSE);
}
#if defined(COMBO_IME)
if(sImeL.dwRegImeIndex==INDEX_GB)
return (Conversion(lpszSrc, lpCandList, uBufLen));
else if(sImeL.dwRegImeIndex==INDEX_GBK)
return (XGBConversion(lpszSrc, lpCandList, uBufLen));
else if(sImeL.dwRegImeIndex==INDEX_UNICODE)
return (XGBConversion(lpszSrc, lpCandList, uBufLen));
#else //COMBO_IME
#ifdef GB
return (Conversion(lpszSrc, lpCandList, uBufLen));
#else
return (XGBConversion(lpszSrc, lpCandList, uBufLen));
#endif //GB
#endif //COMBO_IME
break;
case GCL_REVERSECONVERSION:
if (!uBufLen) {
#if defined(COMBO_IME)
return 1;
#else //COMBO_IME
#ifdef GB
return 1;
#else
return 1;
#endif //GB
#endif //COMBO_IME
}
// only support one DBCS char reverse conversion
if (*(LPTSTR)((LPBYTE)lpszSrc + sizeof(WORD)) != TEXT('\0')) {
return (0);
}
wCode = *(LPWORD)lpszSrc;
// swap lead byte & second byte, UNICODE don't need it
// wCode = HIBYTE(wCode) | (LOBYTE(wCode) << 8); For Big5
#if defined(COMBO_IME)
if(sImeL.dwRegImeIndex==INDEX_GB)
return (ReverseConversion(wCode, lpCandList, uBufLen));
else if(sImeL.dwRegImeIndex==INDEX_GBK)
return (XGBReverseConversion(wCode, lpCandList, uBufLen));
else if(sImeL.dwRegImeIndex==INDEX_UNICODE)
return (UnicodeReverseConversion(wCode, lpCandList, uBufLen));
#else //COMBO_IME
#ifdef GB
return (ReverseConversion(wCode, lpCandList, uBufLen));
#else
return (XGBReverseConversion(wCode, lpCandList, uBufLen));
#endif //GB
#endif //COMBO_IME
break;
default:
return (0);
break;
}
return (0);
}
/**********************************************************************/
/* ImeDestroy() */
/* Return Value: */
/* TRUE - successful, FALSE - failure */
/**********************************************************************/
BOOL WINAPI ImeDestroy( // this dll is unloaded
UINT uReserved)
{
if (uReserved) {
return (FALSE);
}
return (TRUE);
}
/**********************************************************************/
/* ImeEscape() */
/* Return Value: */
/* TRUE - successful, FALSE - failure */
/**********************************************************************/
#define IME_INPUTKEYTOSEQUENCE 0x22
LRESULT WINAPI ImeEscape( // escape function of IMEs
HIMC hIMC,
UINT uSubFunc,
LPVOID lpData)
{
LRESULT lRet;
switch (uSubFunc) {
case IME_ESC_QUERY_SUPPORT:
if ( lpData == NULL )
return FALSE;
switch (*(LPUINT)lpData) {
case IME_ESC_QUERY_SUPPORT:
case IME_ESC_MAX_KEY:
case IME_ESC_IME_NAME:
case IME_ESC_GETHELPFILENAME:
return (TRUE);
case IME_ESC_SEQUENCE_TO_INTERNAL:
case IME_ESC_GET_EUDC_DICTIONARY:
case IME_ESC_SET_EUDC_DICTIONARY:
case IME_INPUTKEYTOSEQUENCE: // will not supported in next version
return (FALSE); // will not supported in GB IME
default:
return (FALSE);
}
break;
case IME_ESC_SEQUENCE_TO_INTERNAL:
case IME_ESC_GET_EUDC_DICTIONARY:
case IME_ESC_SET_EUDC_DICTIONARY:
case IME_INPUTKEYTOSEQUENCE:
return (FALSE);
case IME_ESC_MAX_KEY:
return ((WORD) 4);
case IME_ESC_IME_NAME:
if ( lpData == NULL )
return FALSE;
lstrcpy(lpData, szImeName);
return (TRUE);
case IME_ESC_GETHELPFILENAME:
{
TCHAR szIMEGUDHlpName[MAX_PATH];
if (lpData == NULL )
return FALSE;
szIMEGUDHlpName[0] = 0;
GetWindowsDirectory((LPTSTR)szIMEGUDHlpName, MAX_PATH);
lstrcat((LPTSTR)szIMEGUDHlpName, TEXT("\\HELP\\WINGB.CHM"));
lstrcpy(lpData, szIMEGUDHlpName);
return TRUE;
}
default:
return (FALSE);
}
return (lRet);
}
/**********************************************************************/
/* InitCompStr() */
/**********************************************************************/
void PASCAL InitCompStr( // init setting for composing string
LPCOMPOSITIONSTRING lpCompStr)
{
if (!lpCompStr) {
return;
}
lpCompStr->dwCompReadAttrLen = 0;
lpCompStr->dwCompReadClauseLen = 0;
lpCompStr->dwCompReadStrLen = 0;
lpCompStr->dwCompAttrLen = 0;
lpCompStr->dwCompClauseLen = 0;
lpCompStr->dwCompStrLen = 0;
lpCompStr->dwCursorPos = 0;
lpCompStr->dwDeltaStart = 0;
lpCompStr->dwResultReadClauseLen = 0;
lpCompStr->dwResultReadStrLen = 0;
lpCompStr->dwResultClauseLen = 0;
lpCompStr->dwResultStrLen = 0;
return;
}
/**********************************************************************/
/* ClearCompStr() */
/* Return Value: */
/* TRUE - successful, FALSE - failure */
/**********************************************************************/
BOOL PASCAL ClearCompStr(
LPINPUTCONTEXT lpIMC)
{
HIMCC hMem;
LPCOMPOSITIONSTRING lpCompStr;
DWORD dwSize;
if(!lpIMC) {
return (FALSE);
}
dwSize =
// header length
sizeof(COMPOSITIONSTRING) +
// composition reading attribute plus NULL terminator
lpImeL->nMaxKey * sizeof(BYTE) + sizeof(BYTE) +
// composition reading clause
sizeof(DWORD) + sizeof(DWORD) +
// composition reading string plus NULL terminator
lpImeL->nMaxKey * sizeof(WORD) + sizeof(WORD) +
// result reading clause
sizeof(DWORD) + sizeof(DWORD) +
// result reading string plus NULL terminateor
lpImeL->nMaxKey * sizeof(WORD) + sizeof(WORD) +
// result clause
sizeof(DWORD) + sizeof(DWORD) +
// result string plus NULL terminateor
MAXSTRLEN * sizeof(WORD) + sizeof(WORD);
if (!lpIMC->hCompStr) {
// it maybe free by other IME, init it
lpIMC->hCompStr = ImmCreateIMCC(dwSize);
} else if (hMem = ImmReSizeIMCC(lpIMC->hCompStr, dwSize)) {
lpIMC->hCompStr = hMem;
} else {
ImmDestroyIMCC(lpIMC->hCompStr);
lpIMC->hCompStr = ImmCreateIMCC(dwSize);
return (FALSE);
}
if (!lpIMC->hCompStr) {
return (FALSE);
}
lpCompStr = (LPCOMPOSITIONSTRING)ImmLockIMCC(lpIMC->hCompStr);
if (!lpCompStr) {
ImmDestroyIMCC(lpIMC->hCompStr);
lpIMC->hCompStr = ImmCreateIMCC(dwSize);
return (FALSE);
}
lpCompStr->dwSize = dwSize;
// 1. composition (reading) string - simple IME
// 2. result reading string
// 3. result string
lpCompStr->dwCompReadAttrLen = 0;
lpCompStr->dwCompReadAttrOffset = sizeof(COMPOSITIONSTRING);
lpCompStr->dwCompReadClauseLen = 0;
lpCompStr->dwCompReadClauseOffset = lpCompStr->dwCompReadAttrOffset +
lpImeL->nMaxKey * sizeof(TCHAR) + sizeof(TCHAR);
lpCompStr->dwCompReadStrLen = 0;
lpCompStr->dwCompReadStrOffset = lpCompStr->dwCompReadClauseOffset +
sizeof(DWORD) + sizeof(DWORD);
// composition string is the same with composition reading string
// for simple IMEs
lpCompStr->dwCompAttrLen = 0;
lpCompStr->dwCompAttrOffset = lpCompStr->dwCompReadAttrOffset;
lpCompStr->dwCompClauseLen = 0;
lpCompStr->dwCompClauseOffset = lpCompStr->dwCompReadClauseOffset;
lpCompStr->dwCompStrLen = 0;
lpCompStr->dwCompStrOffset = lpCompStr->dwCompReadStrOffset;
lpCompStr->dwCursorPos = 0;
lpCompStr->dwDeltaStart = 0;
lpCompStr->dwResultReadClauseLen = 0;
lpCompStr->dwResultReadClauseOffset = lpCompStr->dwCompStrOffset +
lpImeL->nMaxKey * sizeof(WORD) + sizeof(WORD);
lpCompStr->dwResultReadStrLen = 0;
lpCompStr->dwResultReadStrOffset = lpCompStr->dwResultReadClauseOffset +
sizeof(DWORD) + sizeof(DWORD);
lpCompStr->dwResultClauseLen = 0;
lpCompStr->dwResultClauseOffset = lpCompStr->dwResultReadStrOffset +
lpImeL->nMaxKey * sizeof(WORD) + sizeof(WORD);
lpCompStr->dwResultStrOffset = 0;
lpCompStr->dwResultStrOffset = lpCompStr->dwResultClauseOffset +
sizeof(DWORD) + sizeof(DWORD);
GlobalUnlock((HGLOBAL)lpIMC->hCompStr);
return (TRUE);
}
/**********************************************************************/
/* ClearCand() */
/* Return Value: */
/* TRUE - successful, FALSE - failure */
/**********************************************************************/
BOOL PASCAL ClearCand(
LPINPUTCONTEXT lpIMC)
{
HIMCC hMem;
LPCANDIDATEINFO lpCandInfo;
LPCANDIDATELIST lpCandList;
DWORD dwSize =
// header length
sizeof(CANDIDATEINFO) + sizeof(CANDIDATELIST) +
// candidate string pointers
sizeof(DWORD) * (MAXCAND + 1) +
// string plus NULL terminator
(sizeof(WORD) + sizeof(WORD)) * (MAXCAND + 1);
if (!lpIMC) {
return (FALSE);
}
if (!lpIMC->hCandInfo) {
// it maybe free by other IME, init it
lpIMC->hCandInfo = ImmCreateIMCC(dwSize);
} else if (hMem = ImmReSizeIMCC(lpIMC->hCandInfo, dwSize)) {
lpIMC->hCandInfo = hMem;
} else {
ImmDestroyIMCC(lpIMC->hCandInfo);
lpIMC->hCandInfo = ImmCreateIMCC(dwSize);
return (FALSE);
}
if (!lpIMC->hCandInfo) {
return (FALSE);
}
lpCandInfo = (LPCANDIDATEINFO)ImmLockIMCC(lpIMC->hCandInfo);
if (!lpCandInfo) {
ImmDestroyIMCC(lpIMC->hCandInfo);
lpIMC->hCandInfo = ImmCreateIMCC(dwSize);
return (FALSE);
}
// ordering of strings are
// buffer size
lpCandInfo->dwSize = dwSize;
lpCandInfo->dwCount = 0;
lpCandInfo->dwOffset[0] = sizeof(CANDIDATEINFO);
lpCandList = (LPCANDIDATELIST)((LPBYTE)lpCandInfo +
lpCandInfo->dwOffset[0]);
// whole candidate info size - header
lpCandList->dwSize = lpCandInfo->dwSize - sizeof(CANDIDATEINFO);
lpCandList->dwStyle = IME_CAND_READ;
lpCandList->dwCount = 0;
lpCandList->dwSelection = 0;
lpCandList->dwPageSize = CANDPERPAGE;
lpCandList->dwOffset[0] = sizeof(CANDIDATELIST) +
sizeof(DWORD) * (MAXCAND );
ImmUnlockIMCC(lpIMC->hCandInfo);
return (TRUE);
}
/**********************************************************************/
/* ClearGuideLine() */
/* Return Value: */
/* TRUE - successful, FALSE - failure */
/**********************************************************************/
BOOL PASCAL ClearGuideLine(
LPINPUTCONTEXT lpIMC)
{
HIMCC hMem;
LPGUIDELINE lpGuideLine;
DWORD dwSize = sizeof(GUIDELINE) + sImeG.cbStatusErr;
if (!lpIMC->hGuideLine) {
// it maybe free by IME
lpIMC->hGuideLine = ImmCreateIMCC(dwSize);
} else if (hMem = ImmReSizeIMCC(lpIMC->hGuideLine, dwSize)) {
lpIMC->hGuideLine = hMem;
} else {
ImmDestroyIMCC(lpIMC->hGuideLine);
lpIMC->hGuideLine = ImmCreateIMCC(dwSize);
}
lpGuideLine = (LPGUIDELINE)ImmLockIMCC(lpIMC->hGuideLine);
if (!lpGuideLine) {
return (FALSE);
}
lpGuideLine->dwSize = dwSize;
lpGuideLine->dwLevel = GL_LEVEL_NOGUIDELINE;
lpGuideLine->dwIndex = GL_ID_UNKNOWN;
lpGuideLine->dwStrLen = 0;
lpGuideLine->dwStrOffset = sizeof(GUIDELINE);
CopyMemory((LPBYTE)lpGuideLine + lpGuideLine->dwStrOffset,
sImeG.szStatusErr, sImeG.cbStatusErr);
ImmUnlockIMCC(lpIMC->hGuideLine);
return (TRUE);
}
/**********************************************************************/
/* InitContext() */
/**********************************************************************/
void PASCAL InitContext(
LPINPUTCONTEXT lpIMC)
{
if (lpIMC->fdwInit & INIT_STATUSWNDPOS) {
} else if (!lpIMC->hWnd) {
} else {
#ifdef MUL_MONITOR
RECT rcWorkArea;
rcWorkArea = ImeMonitorWorkAreaFromWindow(lpIMC->hWnd);
lpIMC->ptStatusWndPos.x = rcWorkArea.left;
lpIMC->ptStatusWndPos.y = rcWorkArea.bottom -
sImeG.yStatusHi;
#else
POINT ptWnd;
ptWnd.x = 0;
ptWnd.y = 0;
ClientToScreen(lpIMC->hWnd, &ptWnd);
if (ptWnd.x < sImeG.rcWorkArea.left) {
lpIMC->ptStatusWndPos.x = sImeG.rcWorkArea.left;
} else if (ptWnd.x + sImeG.xStatusWi > sImeG.rcWorkArea.right) {
lpIMC->ptStatusWndPos.x = sImeG.rcWorkArea.right -
sImeG.xStatusWi;
} else {
lpIMC->ptStatusWndPos.x = ptWnd.x;
}
lpIMC->ptStatusWndPos.y = sImeG.rcWorkArea.bottom -
sImeG.yStatusHi;
#endif
lpIMC->fdwInit |= INIT_STATUSWNDPOS;
}
if (lpIMC->fdwInit & INIT_COMPFORM) {
} else if (!lpIMC->hWnd) {
} else {
POINT ptWnd;
ptWnd = lpImeL->ptDefComp;
ScreenToClient(lpIMC->hWnd, &ptWnd);
lpIMC->cfCompForm.dwStyle = CFS_DEFAULT;
lpIMC->cfCompForm.ptCurrentPos = ptWnd;
lpIMC->fdwInit |= INIT_COMPFORM;
}
return;
}
/**********************************************************************/
/* Select() */
/* Return Value: */
/* TRUE - successful, FALSE - failure */
/**********************************************************************/
BOOL PASCAL Select(
HIMC hIMC,
LPINPUTCONTEXT lpIMC,
BOOL fSelect)
{
LPPRIVCONTEXT lpImcP;
UINT i;
if (fSelect) {
if (!ClearCompStr(lpIMC))
return FALSE;
if (!ClearCand(lpIMC))
return FALSE;
ClearGuideLine(lpIMC);
}
if (lpIMC->cfCandForm[0].dwIndex != 0)
lpIMC->cfCandForm[0].dwStyle = CFS_DEFAULT;
// We add this hack for switching from other IMEs, this IME has a bug.
// Before this bug fixed in this IME, it depends on this hack.
if (lpIMC->cfCandForm[0].dwStyle == CFS_DEFAULT) {
lpIMC->cfCandForm[0].dwIndex = (DWORD)-1;
}
if (!lpIMC->hPrivate)
return FALSE;
lpImcP = (LPPRIVCONTEXT)ImmLockIMCC(lpIMC->hPrivate);
if (!lpImcP)
return FALSE;
if (fSelect) {
//
// init fields of hPrivate
//
lpImcP->iImeState = CST_INIT;
lpImcP->fdwImeMsg = (DWORD)0;
lpImcP->dwCompChar = (DWORD)0;
lpImcP->fdwGcsFlag = (DWORD)0;
lpImcP->uSYHFlg = (UINT)0;
lpImcP->uDYHFlg = (UINT)0;
lpImcP->uDSMHCount = (UINT)0;
lpImcP->uDSMHFlg = (UINT)0;
//lpImcP->fdwSentence = (DWORD)NULL;
//
// reset SK State
//
*(LPDWORD)lpImcP->bSeq = 0;
#ifdef CROSSREF
lpImcP->hRevCandList = (HIMCC) NULL;
#endif //CROSSREF
lpIMC->fOpen = TRUE;
if (!(lpIMC->fdwInit & INIT_CONVERSION)) {
lpIMC->fdwConversion = (lpIMC->fdwConversion & IME_CMODE_SOFTKBD) |
IME_CMODE_NATIVE;
lpIMC->fdwInit |= INIT_CONVERSION;
}
if (lpIMC->fdwInit & INIT_SENTENCE) {
} else if (lpImeL->fModeConfig & MODE_CONFIG_PREDICT) {
lpIMC->fdwSentence = IME_SMODE_PHRASEPREDICT;
lpIMC->fdwInit |= INIT_SENTENCE;
}
if (!(lpIMC->fdwInit & INIT_LOGFONT)) {
HDC hDC;
HGDIOBJ hSysFont;
//hSysFont = GetStockObject(SYSTEM_FONT);
hDC = GetDC(NULL);
hSysFont = GetCurrentObject(hDC, OBJ_FONT);
GetObject(hSysFont, sizeof(LOGFONT), &lpIMC->lfFont.A);
ReleaseDC(NULL, hDC);
lpIMC->fdwInit |= INIT_LOGFONT;
}
InitContext(lpIMC);
//
// Set Caps status
//
{
DWORD fdwConversion;
if (GetKeyState(VK_CAPITAL) & 0x01) {
//
// Change to alphanumeric mode.
//
fdwConversion = lpIMC->fdwConversion &
~(IME_CMODE_NATIVE | IME_CMODE_CHARCODE | IME_CMODE_EUDC);
} else {
//
// Change to native mode
//
fdwConversion = (lpIMC->fdwConversion | IME_CMODE_NATIVE) &
~(IME_CMODE_CHARCODE | IME_CMODE_EUDC );
}
ImmSetConversionStatus(hIMC, fdwConversion, lpIMC->fdwSentence);
}
} else {
if (lpImeL->hSKMenu) {
DestroyMenu(lpImeL->hSKMenu);
lpImeL->hSKMenu = NULL;
}
if (lpImeL->hPropMenu) {
DestroyMenu(lpImeL->hPropMenu);
lpImeL->hPropMenu = NULL;
}
if (hCrtDlg) {
SendMessage(hCrtDlg, WM_CLOSE, (WPARAM)NULL, (LPARAM)NULL);
hCrtDlg = NULL;
}
}
ImmUnlockIMCC(lpIMC->hPrivate);
return (TRUE);
}
/**********************************************************************/
/* ImeSelect() */
/* Return Value: */
/* TRUE - successful, FALSE - failure */
/**********************************************************************/
BOOL WINAPI ImeSelect(
HIMC hIMC,
BOOL fSelect)
{
LPINPUTCONTEXT lpIMC;
BOOL fRet;
if (!hIMC) {
return (FALSE);
}
lpIMC = (LPINPUTCONTEXT)ImmLockIMC(hIMC);
if (!lpIMC) {
return (FALSE);
}
fRet = Select(hIMC, lpIMC, fSelect);
ImmUnlockIMC(hIMC);
return (fRet);
}
/**********************************************************************/
/* ImeSetActiveContext() */
/* Return Value: */
/* TRUE - successful, FALSE - failure */
/**********************************************************************/
BOOL WINAPI ImeSetActiveContext(
HIMC hIMC,
BOOL fOn)
{
if (!fOn) {
} else if (!hIMC) {
} else {
LPINPUTCONTEXT lpIMC;
lpIMC = (LPINPUTCONTEXT)ImmLockIMC(hIMC);
if (!lpIMC) {
return (FALSE);
}
InitContext(lpIMC);
ImmUnlockIMC(hIMC);
}
return (TRUE);
}
/**********************************************************************/
//OpenReg_PathSetup(HKEY *phKey);
/**********************************************************************/
LONG OpenReg_PathSetup(HKEY *phKey)
{
return RegOpenKeyEx (HKEY_CURRENT_USER,
REGSTR_PATH_SETUP,
0,
KEY_ENUMERATE_SUB_KEYS |
KEY_EXECUTE |
KEY_QUERY_VALUE,
phKey);
}
/**********************************************************************/
//LONG OpenReg_User(HKEY hKey, // handle of open key
// LPCTSTR lpszSubKey, // address of name of subkey to open
// PHKEY phkResult); // address of handle of open key
/**********************************************************************/
LONG OpenReg_User(HKEY hKey, // handle of open key
LPCTSTR lpszSubKey, // address of name of subkey to open
PHKEY phkResult) // address of handle of open key
{
return RegOpenKeyEx (hKey,
lpszSubKey,
0,
KEY_ALL_ACCESS,
phkResult);
}
VOID InfoMessage(HANDLE hWnd,WORD wMsgID)
{
TCHAR szStr[256];
LoadString(NULL,wMsgID,szStr, sizeof(szStr)/sizeof(TCHAR));
MessageBox(hWnd,szStr,szWarnTitle,MB_ICONINFORMATION|MB_OK);
}
VOID FatalMessage(HANDLE hWnd,WORD wMsgID)
{
TCHAR szStr[256];
LoadString(NULL,wMsgID,szStr, sizeof(szStr)/sizeof(TCHAR));
MessageBox(hWnd,szStr,szErrorTitle,MB_ICONSTOP|MB_OK);
}
Reference in a new issue Copy permalink