archive
/
windows-xp
mirror of https://github.com/tongzx/nt5src
2
0
Fork 0
Code Issues Projects Releases Wiki Activity
Source code of Windows XP (NT5)
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.
6 Commits
1 Branch
0 Tags
2.0 GiB
 
 
 
 
 
 
Tree: daad8a087a
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from 'daad8a087a'
${ noResults }
windows-xp/Source/XPSP1/NT/windows/feime/chs/ntime/ddis.c

1897 lines
56 KiB
Raw Blame History

/*++
Copyright (c) 1995-1999 Microsoft Corporation, All Rights Reserved
Module Name:
DDIS.C
++*/
#include <windows.h>
#include <windowsx.h>
#include <winerror.h>
#ifdef CROSSREF
#include <winuser.h>
#endif
#include <immdev.h>
#include <string.h>
#include <regstr.h>
#include <ctype.h>
#include <shlobj.h>
#include "imedefs.h"
#include "resource.h"
LPTSTR _rtcschr(LPTSTR string, TCHAR c);
LONG lLock = 0; // this variable is for Lock and Unlock.
//we must init hprivate->mb_name
//*******************************************************************
// InitMbName(hIMC);
//*******************************************************************
void InitMbName(HIMC hIMC)
{
LPINPUTCONTEXT lpIMC;
if (!hIMC) {
return ;
}
lpIMC = (LPINPUTCONTEXT)ImmLockIMC(hIMC);
if(!lpIMC){
return;
}
StartEngine(lpIMC->hPrivate);
ImmUnlockIMC(hIMC);
return;
}
// Get the current user's EMB file path, and IME's MB path
// fill global variable sImeG.szIMESystemPath and sImeG.szIMEUserPath
void GetCurrentUserEMBPath( )
{
PSECURITY_ATTRIBUTES psa = NULL;
TCHAR szModuleName[MAX_PATH], *lpszStart, *lpszDot;
int i;
// Get the path for MB and EMB
GetSystemDirectory(sImeG.szIMESystemPath, MAX_PATH);
GetModuleFileName(hInst, szModuleName, sizeof(szModuleName)/sizeof(TCHAR) );
lpszStart = szModuleName + lstrlen(szModuleName) - 1;
while ( (lpszStart != szModuleName) && ( *lpszStart != TEXT('\\') ) ) {
if ( *lpszStart == TEXT('.') ) {
lpszDot = lpszStart;
*lpszDot = TEXT('\0');
}
lpszStart --;
}
if ( *lpszStart == TEXT('\\') ) {
lpszStart ++;
}
if ( lpszStart != szModuleName ) {
for (i=0; i<lstrlen(lpszStart); i++)
szModuleName[i] = lpszStart[i];
szModuleName[i] = TEXT('\0');
}
// psa = CreateSecurityAttributes();
SHGetSpecialFolderPath(NULL,sImeG.szIMEUserPath,CSIDL_APPDATA, FALSE);
if ( sImeG.szIMEUserPath[lstrlen(sImeG.szIMEUserPath)-1] == TEXT('\\') )
sImeG.szIMEUserPath[lstrlen(sImeG.szIMEUserPath) - 1] = TEXT('\0');
// Because CreateDirectory( ) cannot create directory like \AA\BB,
// if AA and BB both do not exist. It can create only one layer of
// directory each time. so we must call twice CreateDirectory( ) for
// \AA\BB
lstrcat(sImeG.szIMEUserPath, TEXT("\\Microsoft") );
if ( GetFileAttributes(sImeG.szIMEUserPath) != FILE_ATTRIBUTE_DIRECTORY)
CreateDirectory(sImeG.szIMEUserPath, psa);
lstrcat(sImeG.szIMEUserPath, TEXT("\\IME") );
if ( GetFileAttributes(sImeG.szIMEUserPath) != FILE_ATTRIBUTE_DIRECTORY)
CreateDirectory(sImeG.szIMEUserPath, psa);
lstrcat(sImeG.szIMEUserPath, TEXT("\\") );
lstrcat(sImeG.szIMEUserPath, szModuleName);
//
// Create the directory, so that CreateFile( ) can work fine later.
// ortherwise, if the directory does not exist, and you try to create
// a file under that dir, CreateFile will return error.
//
if ( GetFileAttributes(sImeG.szIMEUserPath) != FILE_ATTRIBUTE_DIRECTORY)
CreateDirectory(sImeG.szIMEUserPath, psa);
// FreeSecurityAttributes(psa);
return;
}
/**********************************************************************/
/* 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|
IME_CMODE_EUDC;
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);
}
/**********************************************************************/
/* SetImeDlgProc() */
/* Return Value: */
/* TRUE - successful, FALSE - failure */
/**********************************************************************/
BOOL FAR PASCAL SetImeDlgProc(
HWND hDlg,
UINT uMessage,
DWORD wParam,
LONG lParam)
{
RECT rc;
LONG DlgWidth, DlgHeight;
HIMC hIMC;
#ifdef CROSSREF
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);
// Init CheckFrame State
SetImeCharac(hDlg, (int) 0, SIC_READY, 0);
CheckDlgButton (hDlg, IDC_LX,
MBIndex.IMEChara[0].IC_LX);
CheckDlgButton (hDlg, IDC_CZ,
MBIndex.IMEChara[0].IC_CZ);
CheckDlgButton (hDlg, IDC_TS,
MBIndex.IMEChara[0].IC_TS);
CheckDlgButton (hDlg, IDC_CTS,
MBIndex.IMEChara[0].IC_CTC);
CheckDlgButton (hDlg, IDC_TC,
MBIndex.IMEChara[0].IC_Trace);
//CHP
#ifdef FUSSYMODE
CheckDlgButton (hDlg, IDC_FCSR,
MBIndex.IMEChara[0].IC_FCSR);
CheckDlgButton (hDlg, IDC_FCTS,
MBIndex.IMEChara[0].IC_FCTS);
EnableWindow(GetDlgItem(hDlg, IDC_CZ), FALSE);
#endif //FUSSYMODE
#if defined(COMBO_IME)
if (MBIndex.IMEChara[0].IC_GB)
SendMessage(GetDlgItem(hDlg, IDC_GB),
BM_SETCHECK,
TRUE,
0L);
else
SendMessage(GetDlgItem(hDlg, IDC_GBK),
BM_SETCHECK,
TRUE,
0L);
#endif //COMBO_IME
if(MBIndex.IMEChara[0].IC_TS) {
EnableWindow(GetDlgItem(hDlg, IDC_CTS), TRUE);
} else {
EnableWindow(GetDlgItem(hDlg, IDC_CTS), FALSE);
}
#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 (LOWORD(wParam)) {
case IDOK:
SetImeCharac(hDlg, (int) 0, SIC_SAVE1, 0);
#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_LX:
case IDC_CZ:
case IDC_TS:
case IDC_CTS:
case IDC_TC:
//CHP
#ifdef FUSSYMODE
case IDC_FCSR:
case IDC_FCTS:
#endif //FUSSYMODE
// Set Current InputMode Param(temp)
SetImeCharac(hDlg, (wParam - IDC_LX), SIC_MODIFY, (int) 0);
break;
#if defined(COMBO_IME)
case IDC_GB:
case IDC_GBK:
// Set Current InputMode Param(temp)
SetImeCharac(hDlg, 7, SIC_MODIFY, (int) 0);
break;
#endif //COMBO_IME
default:
return (FALSE);
}
return (TRUE);
case WM_PAINT:
{
RECT rc;
GetClientRect(hDlg, &rc);
DrawConvexRect(GetDC(hDlg),
rc.left + 6,
rc.top + 8,
rc.right - 6 - 1,
rc.bottom - 40 - 1);
DrawConvexRectP(GetDC(hDlg),
rc.left + 6,
rc.top + 8,
rc.right - 6,
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);
}
/**********************************************************************/
/* SetImeCharac() */
/* Return Value: voide */
/* Entry: */
/* code=0, init */
/* code=1, Save temp */
/* code=2, Save resault */
/**********************************************************************/
void SetImeCharac (
HWND hDlg,
int ParamNum,
int Mode,
DWORD ObjImeIndex)
{
HIMC hIMC;
LPINPUTCONTEXT lpIMC;
LPPRIVCONTEXT lpImcP;
#if defined(COMBO_IME)
static DWORD TempParam[8];
#else
static DWORD TempParam[7];
#endif //COMBO_IME
HKEY hKeyCurrVersion;
HKEY hKey;
DWORD retCode;
#ifdef UNICODE
TCHAR ValueName[][9] = {
{0x8BCD, 0x8BED, 0x8054, 0x60F3, 0x0000},
{0x8BCD, 0x8BED, 0x8F93, 0x5165, 0x0000},
{0x9010, 0x6E10, 0x63D0, 0x793A, 0x0000},
{0x5916, 0x7801, 0x63D0, 0x793A, 0x0000},
{0x5149, 0x6807, 0x8DDF, 0x968F, 0x0000},
#else
TCHAR ValueName[][9] = {
TEXT("´ÊÓïÁªÏë"),
TEXT("´ÊÓïÊäÈë"),
TEXT("Öð½¥Ìáʾ"),
TEXT("ÍâÂëÌáʾ"),
TEXT("¹â±ê¸úËæ"),
#endif
TEXT("FC input"),
TEXT("FC aid"),
#if defined(COMBO_IME)
TEXT("GB/GBK")
#endif //COMBO_IME
};
UINT i;
switch (Mode)
{
case SIC_READY:
InitImeCharac(ObjImeIndex);
//CHP
#ifdef FUSSYMODE
if (MBIndex.IMEChara[ObjImeIndex].IC_FCSR)
{
if (MBIndex.IMEChara[ObjImeIndex].IC_FCTS)
EnableWindow(GetDlgItem(hDlg, IDD_LAYOUT_LIST), FALSE);
}
else
EnableWindow(GetDlgItem(hDlg, IDC_FCTS), FALSE);
#endif //FUSSYMODE
TempParam[0] = MBIndex.IMEChara[ObjImeIndex].IC_LX;
TempParam[1] = MBIndex.IMEChara[ObjImeIndex].IC_CZ;
TempParam[2] = MBIndex.IMEChara[ObjImeIndex].IC_TS;
TempParam[3] = MBIndex.IMEChara[ObjImeIndex].IC_CTC;
TempParam[4] = MBIndex.IMEChara[ObjImeIndex].IC_Trace;
//CHP
TempParam[5] = MBIndex.IMEChara[ObjImeIndex].IC_FCSR;
TempParam[6] = MBIndex.IMEChara[ObjImeIndex].IC_FCTS;
#if defined(COMBO_IME)
TempParam[7] = MBIndex.IMEChara[ObjImeIndex].IC_GB;
#endif //COMBO_IME
break;
case SIC_MODIFY:
TempParam[ParamNum] = (TempParam[ParamNum] ^ 0x00000001) & 0x00000001;
if(TempParam[2]) {
EnableWindow(GetDlgItem(hDlg, IDC_CTS), TRUE);
} else {
EnableWindow(GetDlgItem(hDlg, IDC_CTS), FALSE);
TempParam[3] = 0;
CheckDlgButton (hDlg, IDC_CTS, FALSE);
}
//CHP
#ifdef FUSSYMODE
if (TempParam[5])
{
EnableWindow(GetDlgItem(hDlg, IDC_FCTS), TRUE);
if (TempParam[6])
EnableWindow(GetDlgItem(hDlg, IDD_LAYOUT_LIST), FALSE);
else
EnableWindow(GetDlgItem(hDlg, IDD_LAYOUT_LIST), TRUE);
}
else
{
EnableWindow(GetDlgItem(hDlg, IDC_FCTS), FALSE);
EnableWindow(GetDlgItem(hDlg, IDD_LAYOUT_LIST), TRUE);
}
#endif //FUSSYMODE
break;
case SIC_SAVE1:
MBIndex.IMEChara[ObjImeIndex].IC_LX = TempParam[0];
MBIndex.IMEChara[ObjImeIndex].IC_CZ = TempParam[1];
MBIndex.IMEChara[ObjImeIndex].IC_TS = TempParam[2];
MBIndex.IMEChara[ObjImeIndex].IC_CTC = TempParam[3];
MBIndex.IMEChara[ObjImeIndex].IC_Trace = TempParam[4];
// CHP
#ifdef FUSSYMODE
MBIndex.IMEChara[ObjImeIndex].IC_FCSR = TempParam[5];
MBIndex.IMEChara[ObjImeIndex].IC_FCTS = TempParam[6];
#endif //FUSSYMODE
#if defined(COMBO_IME)
MBIndex.IMEChara[ObjImeIndex].IC_GB = TempParam[7];
#endif //COMBO_IME
retCode = OpenReg_PathSetup(&hKeyCurrVersion);
if (retCode) {
RegCreateKey(HKEY_CURRENT_USER, REGSTR_PATH_SETUP, &hKeyCurrVersion);
}
if ( hKeyCurrVersion )
retCode = RegCreateKeyEx(hKeyCurrVersion, MBIndex.MBDesc[ObjImeIndex].szName, 0,
NULL, REG_OPTION_NON_VOLATILE, KEY_ALL_ACCESS , NULL, &hKey, NULL);
else
return;
if ( hKey == NULL )
{
RegCloseKey(hKeyCurrVersion);
return;
}
#if defined(COMBO_IME)
for(i=0; i<8; i++) {
#else
for(i=0; i<7; i++) {
#endif //COMBO_IME
DWORD Value;
switch (i)
{
case 0:
Value = MBIndex.IMEChara[ObjImeIndex].IC_LX;
break;
case 1:
Value = MBIndex.IMEChara[ObjImeIndex].IC_CZ;
break;
case 2:
Value = MBIndex.IMEChara[ObjImeIndex].IC_TS;
break;
case 3:
Value = MBIndex.IMEChara[ObjImeIndex].IC_CTC;
break;
case 4:
Value = MBIndex.IMEChara[ObjImeIndex].IC_Trace;
break;
//CHP
#ifdef FUSSYMODE
case 5:
Value = MBIndex.IMEChara[ObjImeIndex].IC_FCSR;
break;
case 6:
Value = MBIndex.IMEChara[ObjImeIndex].IC_FCTS;
break;
#endif //FUSSYMODE
#if defined(COMBO_IME)
case 7:
Value = MBIndex.IMEChara[ObjImeIndex].IC_GB;
break;
#endif //COMBO_IME
}
if ( hKey != NULL )
{
RegSetValueEx (hKey, ValueName[i],
(DWORD) 0,
REG_DWORD,
(LPBYTE)&Value,
sizeof(DWORD));
}
}
RegCloseKey(hKey);
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);
//CHP
#ifdef FUSSYMODE
if (MBIndex.IMEChara[ObjImeIndex].IC_FCSR &&
MBIndex.IMEChara[ObjImeIndex].IC_FCTS)
hKL = GetKeyboardLayout(0);
#endif //FUSSYMODE
if (MBIndex.hRevKL != hKL) {
WORD nRevMaxKey;
HKEY hKeyAppUser, hKeyIMEUser;
LPPRIVCONTEXT lpImcP;
MBIndex.hRevKL = hKL;
//set reverse layout to registry
retCode = OpenReg_PathSetup(&hKeyAppUser);
if (retCode) {
RegCreateKey(HKEY_CURRENT_USER, REGSTR_PATH_SETUP, &hKeyCurrVersion);
}
retCode = RegCreateKeyEx(hKeyAppUser, MBIndex.MBDesc[0].szName, 0,
NULL, REG_OPTION_NON_VOLATILE, KEY_ALL_ACCESS , NULL, &hKeyIMEUser, NULL);
if (retCode) {
DWORD dwDisposition;
retCode = RegCreateKeyEx (hKeyCurrVersion,
MBIndex.MBDesc[0].szName,
0,
0,
REG_OPTION_NON_VOLATILE,
KEY_ALL_ACCESS,
NULL,
&hKey,
&dwDisposition);
}
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;
}
lpIMC = (LPINPUTCONTEXT)ImmLockIMC(hIMC);
if (!lpIMC) {
return;
}
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
break;
}
return;
}
#if defined(CROSSREF)
/**********************************************************************/
/* ReverseConversionList() */
/**********************************************************************/
void PASCAL ReverseConversionList(HWND hLayoutListBox)
{
int nLayouts, i, nIMEs;
TCHAR szImeName[16];
HKL FAR *lpKLMem;
LoadString(hInst, IDS_NONE, szImeName, sizeof(szImeName)/sizeof(TCHAR));
SendMessage(hLayoutListBox, LB_INSERTSTRING,
0, (LPARAM)szImeName);
SendMessage(hLayoutListBox, LB_SELECTSTRING,
0, (LPARAM)szImeName);
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;
}
// NULL hIMC ???????
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,
szImeName)) {
// this IME does not report the IME name
continue;
}
if( lstrcmp(szImeName, MBIndex.MBDesc[0].szName) == 0)
continue;
nIMEs++;
SendMessage(hLayoutListBox, LB_INSERTSTRING,
nIMEs, (LPARAM)szImeName);
if (hKL == MBIndex.hRevKL) {
SendMessage(hLayoutListBox, LB_SELECTSTRING, nIMEs,
(LPARAM)szImeName);
}
SendMessage(hLayoutListBox, LB_SETITEMDATA,
nIMEs, (LPARAM)hKL);
}
GlobalFree((HGLOBAL)lpKLMem);
return;
}
#endif //CROSSREF
#ifdef EUDC
//**********************************************************************
//BOOL EUDCDicName( HWND hWnd)
//**********************************************************************
BOOL EUDCDicName( HWND hWnd)
{
HANDLE hUsrDicFile;
BOOL fRet;
TCHAR szFileName[MAX_PATH];
TCHAR szMapFileName[MAX_PATH];
TCHAR EUDCMB_PathAndName[MAX_PATH];
TCHAR *tepstr;
HKEY hKeyCurrVersion,hKey;
PSECURITY_ATTRIBUTES psa;
LoadString(hInst, IDS_IMEMBFILENAME, szFileName, MAX_PATH);
tepstr = _rtcschr(szFileName,TEXT('.'));
if ( tepstr != NULL )
lstrcpy(tepstr,TEXT(".EMB"));
lstrcpy(EUDCMB_PathAndName, sImeG.szIMEUserPath);
lstrcat(EUDCMB_PathAndName, TEXT("\\") );
lstrcat(EUDCMB_PathAndName, szFileName);
psa = CreateSecurityAttributes();
hUsrDicFile = CreateFile(EUDCMB_PathAndName,
GENERIC_WRITE,
FILE_SHARE_READ|FILE_SHARE_WRITE,
psa,
OPEN_ALWAYS,
FILE_ATTRIBUTE_NORMAL,
(HANDLE)NULL);
if (hUsrDicFile == INVALID_HANDLE_VALUE) {
FreeSecurityAttributes(psa);
return (FALSE);
}
CloseHandle(hUsrDicFile);
FreeSecurityAttributes(psa);
lstrcpy(MBIndex.EUDCData.szEudcDictName, EUDCMB_PathAndName);
// if we have already got a map file, we just use it.
if (MBIndex.EUDCData.szEudcMapFileName[0]) {
return (TRUE);
}
// Otherwise, generate the Map File Name, which is Basic Filename plus EUDC
lstrcpy(szMapFileName, szFileName);
tepstr = _rtcschr(szMapFileName,TEXT('.'));
lstrcpy(tepstr, TEXT("EUDC"));
lstrcpy(MBIndex.EUDCData.szEudcMapFileName, szMapFileName);
fRet = OpenReg_PathSetup(&hKeyCurrVersion);
if (fRet) return FALSE;
fRet = OpenReg_User (hKeyCurrVersion,
MBIndex.MBDesc[0].szName,
&hKey);
if (fRet) {
DWORD dwDisposition;
fRet = RegCreateKeyEx (hKeyCurrVersion,
MBIndex.MBDesc[0].szName,
0,
0,
REG_OPTION_NON_VOLATILE,
KEY_ALL_ACCESS,
NULL,
&hKey,
&dwDisposition);
if (fRet != ERROR_SUCCESS) return FALSE;
}
fRet = RegSetValueEx (hKey,
szRegEudcDictName,
(DWORD) 0,
REG_SZ,
(const unsigned char *)MBIndex.EUDCData.szEudcDictName,
lstrlen(MBIndex.EUDCData.szEudcDictName)*sizeof(TCHAR));
if (fRet != ERROR_SUCCESS ) return FALSE;
fRet = RegSetValueEx (hKey,
szRegEudcMapFileName,
(DWORD) 0,
REG_SZ,
(const unsigned char *)MBIndex.EUDCData.szEudcMapFileName,
lstrlen(MBIndex.EUDCData.szEudcMapFileName)*sizeof(TCHAR));
if (fRet) return FALSE;
return (TRUE);
}
#endif //EUDC
/**********************************************************************/
/* 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
LPVOID lpData)
{
switch (dwMode) {
case IME_CONFIG_GENERAL:
DialogBox(hInst, TEXT("SETIME"), hAppWnd, (DLGPROC) SetImeDlgProc);
break;
#ifdef EUDC
case IME_CONFIG_SELECTDICTIONARY:
return(EUDCDicName(hAppWnd));
break;
#endif //EUDC
default:
return (FALSE);
break;
}
return (TRUE);
}
/**********************************************************************/
/* ForwordConversion() */
/**********************************************************************/
UINT PASCAL ForwordConversion(
HIMC hIMC,
LPCTSTR lpszSrc,
LPCANDIDATELIST lpCandList,
UINT uBufLen)
{
unsigned int i;
LPTSTR wCode;
LPINPUTCONTEXT lpIMC;
UINT uMaxCand;
DWORD dwSize;
wCode = ConverList.szSelectBuffer;
ConverList.szSelectBuffer[0] =TEXT('\0');
ConverList.szInBuffer[0] =TEXT('\0');
ConverList.Candi_Cnt =0;
ConverList.Candi_Pos[0] =TEXT('\0');
if (!hIMC) {
return (0);
}
lpIMC = (LPINPUTCONTEXT)ImmLockIMC(hIMC);
if (!lpIMC) {
return (0);
}
if (!Conversion (lpIMC->hPrivate,lpszSrc,0)) {
return (0);
}
ConverList.szSelectBuffer [lstrlen(ConverList.szSelectBuffer)-1]
=TEXT('\0');
dwSize =
// header length
sizeof(CANDIDATELIST) +
// candidate string pointers
sizeof(DWORD) * ConverList.Candi_Cnt+
// string plus NULL terminator
sizeof(TCHAR) * lstrlen (wCode);
if (!uBufLen) {
return (dwSize);
}
uMaxCand = uBufLen - sizeof(CANDIDATELIST);
uMaxCand /= sizeof(DWORD) + lstrlen (wCode);
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);
lstrcpy((LPTSTR)((LPBYTE)lpCandList + lpCandList->dwOffset[0]),
(LPTSTR)wCode);
lpCandList->dwCount =(DWORD)ConverList.Candi_Cnt;
for (i=1;i<lpCandList->dwCount;i++) {
lpCandList->dwOffset[i] = lpCandList->dwOffset[0]
+(DWORD)ConverList.Candi_Pos[i+1];
*(LPTSTR)((LPBYTE)lpCandList + lpCandList->dwOffset[i]-1) = TEXT('\0');
}
return (dwSize);
}
#if defined(CROSSREF)
//*******************************************************************
// The parameters are inherited from SelectOneCand
// CrossReverseConv()
//*******************************************************************
int CrossReverseConv(
LPINPUTCONTEXT lpIMC,
LPCOMPOSITIONSTRING lpCompStr,
LPPRIVCONTEXT lpImcP,
LPCANDIDATELIST lpCandList)
{
LPGUIDELINE lpGuideLine;
UINT uSize=0;
if (!MBIndex.hRevKL) {
return 0;
}
lpGuideLine = ImmLockIMCC(lpIMC->hGuideLine);
if (!lpGuideLine) {
return 0;
}
if (lpCompStr->dwResultStrLen != 2/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];
LPCANDIDATELIST lpRevCandList;
if(lpImcP->hRevCandList == (HIMCC)NULL){
//we alloc memory in lpImcP->hRevCandList, for reverse convert
//result codes; When finish reconvert, should read out this info.
REALLOC:
lpImcP->hRevCandList = (HIMCC)GlobalAlloc(GHND, sizeof(CANDIDATELIST)+1*sizeof(DWORD)+MAXCODE*sizeof(TCHAR)+1);
if (lpImcP->hRevCandList == (HIMCC)NULL) {
return 0 ;
}
lpRevCandList = (LPCANDIDATELIST)GlobalLock((HGLOBAL)lpImcP->hRevCandList);
if (lpRevCandList == NULL) {
return 0 ;
}
}else{
lpRevCandList = (LPCANDIDATELIST)GlobalLock((HGLOBAL)lpImcP->hRevCandList);
if (lpRevCandList == NULL) {
goto REALLOC;
}
}
*(LPUNAWORD)szStrBuf = *(LPUNAWORD)((LPBYTE)lpCompStr + lpCompStr->dwResultStrOffset);
szStrBuf[2/sizeof(TCHAR)] = TEXT('\0');
memset(lpRevCandList, 0, sizeof(CANDIDATELIST)+1*sizeof(DWORD)+MAXCODE*sizeof(TCHAR)+1);
lpRevCandList->dwSize = sizeof(CANDIDATELIST)+1*sizeof(DWORD)+MAXCODE*sizeof(TCHAR)+1;
uSize = ImmGetConversionList(MBIndex.hRevKL, (HIMC)NULL, szStrBuf,
(LPCANDIDATELIST)lpRevCandList,
lpRevCandList->dwSize, GCL_REVERSECONVERSION);
GlobalUnlock((HGLOBAL)lpImcP->hRevCandList);
if (uSize) {
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 {
GlobalFree((HGLOBAL)lpImcP->hRevCandList);
lpImcP->hRevCandList = (HIMCC)NULL;
}
}
ImmUnlockIMCC(lpIMC->hGuideLine);
//CHP
//We need to know the result.
return uSize;
}
#endif //CROSSREF
/**********************************************************************/
/* ReverseConversion() */
/**********************************************************************/
UINT PASCAL ReverseConversion(
HIMCC hPrivate,
LPCTSTR lpszSrc,
LPCANDIDATELIST lpCandList,
UINT uBufLen)
{
LPTSTR wCode;
UINT uMaxCand;
DWORD dwSize;
wCode = ConverList.szInBuffer;
ConverList.szSelectBuffer[0] =TEXT('\0');
ConverList.szInBuffer[0] =TEXT('\0');
ConverList.Candi_Cnt =0;
ConverList.Candi_Pos[0] =TEXT('\0');
dwSize =
// header length
sizeof(CANDIDATELIST) +
// candidate string pointers
sizeof(DWORD) +
// string plus NULL terminator
MAXCODE*sizeof(TCHAR);
if (!uBufLen) {
return (dwSize);
}
if(lpszSrc ==NULL){
return (0);
}
if (!Conversion (hPrivate,lpszSrc,1)) {
return (0);
}
uMaxCand = uBufLen - sizeof(CANDIDATELIST);
uMaxCand /= sizeof(DWORD) + lstrlen (wCode);
if (!uMaxCand) {
// can not even put one string
return (0);
}
lpCandList->dwSize = dwSize;
lpCandList->dwStyle = IME_CAND_READ; // candidate having same reading
lpCandList->dwCount = 1;
lpCandList->dwSelection = 0;
lpCandList->dwPageSize = CANDPERPAGE;
lpCandList->dwOffset[0] = sizeof(CANDIDATELIST) + sizeof(DWORD) *
(uMaxCand - 1);
lstrcpy((LPTSTR)((LPBYTE)lpCandList + lpCandList->dwOffset[0]),
(LPTSTR)wCode);
return (dwSize);
}
/**********************************************************************/
/* ImeConversionList() */
/**********************************************************************/
DWORD WINAPI ImeConversionList(
HIMC hIMC,
LPCTSTR lpszSrc,
LPCANDIDATELIST lpCandList,
DWORD dwBufLen,
UINT uFlag)
{
if (!dwBufLen) {
} else if (!lpszSrc) {
return (0);
} else if (!*lpszSrc) {
return (0);
} else if (!lpCandList) {
return (0);
} else if (dwBufLen <= sizeof(CANDIDATELIST)) {
// buffer size can not even put the header information
return (0);
} else {
}
switch (uFlag) {
case GCL_CONVERSION:
return ForwordConversion(hIMC,lpszSrc, lpCandList, dwBufLen);
break;
case GCL_REVERSECONVERSION:
if (!dwBufLen) {
return ReverseConversion(NULL,0, lpCandList, dwBufLen);
} else {
DWORD fRet=0;
HIMCC hPrivate;
hPrivate = (HIMCC)ImmCreateIMCC(sizeof(PRIVCONTEXT));
if(hPrivate == (HIMCC)NULL){
return 0;
}
StartEngine(hPrivate);
fRet = ReverseConversion(hPrivate,lpszSrc, lpCandList, dwBufLen);
EndEngine(hPrivate);
ImmDestroyIMCC(hPrivate);
return fRet;
}
break;
default:
return (0);
break;
}
}
/**********************************************************************/
/* 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:
#ifdef EUDC
case IME_ESC_GET_EUDC_DICTIONARY:
case IME_ESC_SET_EUDC_DICTIONARY:
#endif //EUDC
case IME_ESC_SEQUENCE_TO_INTERNAL:
case IME_ESC_MAX_KEY:
case IME_ESC_IME_NAME:
case IME_ESC_GETHELPFILENAME:
return (TRUE);
default:
return (FALSE);
}
break;
case IME_ESC_SEQUENCE_TO_INTERNAL:
if (!lpData || (*(LPBYTE)lpData) == '\0') {
return (FALSE);
}
lRet = *(LPWORD)lpData;
return (lRet);
#ifdef EUDC
case IME_ESC_GET_EUDC_DICTIONARY:
if (!lpData) {
return (FALSE);
}
if (MBIndex.EUDCData.szEudcDictName[0] == TEXT('\0')) {
*(LPTSTR)lpData = TEXT('\0');
return(TRUE);
} else {
lstrcpy((LPTSTR)lpData,MBIndex.EUDCData.szEudcDictName);
return TRUE;
}
case IME_ESC_SET_EUDC_DICTIONARY:
return TRUE;
#endif //EUDC
case IME_ESC_MAX_KEY:
#ifdef EUDC
{
TCHAR szFullFileName[MAX_PATH], szFileName[MAX_PATH];
unsigned int cb;
cb = MAX_PATH;
if (lpImeL->nMaxKey > EUDC_MAX_READING) {
GetModuleFileName(NULL,szFullFileName ,cb);
GetFileTitle(szFullFileName, szFileName, (WORD)cb);
#ifdef UNICODE
// Compare first 8 chars only
if (_wcsnicmp(szFileName,TEXT("EUDCEDIT.EXE"),8))
#else
if (_strnicmp(szFileName,"EUDCEDIT.EXE",8))
#endif
return (lpImeL->nMaxKey);
else
return EUDC_MAX_READING;
} else {
return (lpImeL->nMaxKey);
}
}
#else
return (lpImeL->nMaxKey);
#endif //EUDC
case IME_ESC_IME_NAME:
if ( lpData == NULL )
return FALSE;
lstrcpy(lpData,MBIndex.MBDesc[0].szName);
return (TRUE);
case IME_ESC_GETHELPFILENAME :
{
TCHAR szIMEGUDHlpName[MAX_PATH];
int iLen;
if (lpData == NULL )
return FALSE;
szIMEGUDHlpName[0] = 0;
GetWindowsDirectory((LPTSTR)szIMEGUDHlpName, MAX_PATH);
lstrcat((LPTSTR)szIMEGUDHlpName, TEXT("\\HELP\\"));
lstrcat((LPTSTR)szIMEGUDHlpName, (LPTSTR)szImeMBFileName);
iLen = lstrlen(szIMEGUDHlpName);
szIMEGUDHlpName[iLen-3] = 0;
lstrcat((LPTSTR)szIMEGUDHlpName, TEXT(".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) +
// string plus NULL terminator
(sizeof(WORD) * MAXSTRLEN + sizeof(WORD)) * MAXCAND;
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 - 1);
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 {
#if 0 // MultiMonitor support
POINT ptWnd;
// 10.10 modify
//ptWnd.x = sImeG.rcWorkArea.left;
//ptWnd.y = sImeG.rcWorkArea.top;
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;
#else
RECT rcWorkArea;
rcWorkArea = ImeMonitorWorkAreaFromWindow(lpIMC->hWnd);
lpIMC->ptStatusWndPos.x = rcWorkArea.left;
lpIMC->ptStatusWndPos.y = rcWorkArea.bottom -
sImeG.yStatusHi;
#endif
lpIMC->fdwInit |= INIT_STATUSWNDPOS;
}
if (!(lpIMC->fdwInit & INIT_COMPFORM)) {
lpIMC->cfCompForm.dwStyle = CFS_DEFAULT;
}
if (lpIMC->cfCompForm.dwStyle != CFS_DEFAULT) {
} 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;
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) {
static BOOL bFirstTimeCallHere = TRUE;
//
// Init. ime character
//
InitImeCharac(0);
InterlockedIncrement( &lLock );
if ( bFirstTimeCallHere == TRUE ) {
GetCurrentUserEMBPath( );
bFirstTimeCallHere = FALSE;
}
InterlockedDecrement( &lLock );
//
// init fields of hPrivate
//
lpImcP->iImeState = CST_INIT;
lpImcP->fdwImeMsg = (DWORD) 0;
lpImcP->dwCompChar = (DWORD) 0;
lpImcP->fdwGcsFlag = (DWORD) 0;
lpImcP->uSYHFlg = 0x00000000;
lpImcP->uDYHFlg = 0x00000000;
lpImcP->uDSMHCount = 0x00000000;
lpImcP->uDSMHFlg = 0x00000000;
lpImcP->iActMBIndex = 0;
lstrcpy(lpImcP->MB_Name, HMapTab[0].MB_Name);
lpImcP->PrivateArea.Comp_Status.dwSTLX = 0;
lpImcP->PrivateArea.Comp_Status.dwSTMULCODE = 0;
lpImcP->PrivateArea.Comp_Status.dwInvalid = 0;
lpImcP->PrivateArea.Comp_Status.OnLineCreWord = 0;
//
// Set IME properties
//
lpImcP->PrivateArea.Comp_Status.dwPPTLX = MBIndex.IMEChara[lpImcP->iActMBIndex].IC_LX;
lpImcP->PrivateArea.Comp_Status.dwPPCZ = MBIndex.IMEChara[lpImcP->iActMBIndex].IC_CZ;
lpImcP->PrivateArea.Comp_Status.dwPPTS = MBIndex.IMEChara[lpImcP->iActMBIndex].IC_TS;
lpImcP->PrivateArea.Comp_Status.dwPPCTS = MBIndex.IMEChara[lpImcP->iActMBIndex].IC_CTC;
lpImcP->PrivateArea.Comp_Status.dwTraceCusr = MBIndex.IMEChara[lpImcP->iActMBIndex].IC_Trace;
CWCodeStr[0] = 0;
CWDBCSStr[0] = 0;
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_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 (lpImeL->hObjImeMenu) {
DestroyMenu(lpImeL->hObjImeMenu);
lpImeL->hObjImeMenu = NULL;
}
if (hCrtDlg) {
SendMessage(hCrtDlg, WM_CLOSE, (WPARAM)NULL, (LPARAM)NULL);
hCrtDlg = NULL;
}
}
//
// Start or end MB engine
//
if (fSelect) {
StartEngine(lpIMC->hPrivate);
SaTC_Trace = MBIndex.IMEChara[0].IC_Trace;
} else {
EndEngine(lpIMC->hPrivate);
}
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;
LPPRIVCONTEXT lpImcP;
lpIMC = (LPINPUTCONTEXT)ImmLockIMC(hIMC);
if (!lpIMC) {
goto SetActEnd;
}
lpImcP = (LPPRIVCONTEXT)ImmLockIMCC(lpIMC->hPrivate);
if (!lpImcP) {
goto SetActUnlockIMC;
}
InitContext(lpIMC);
ImmUnlockIMCC(lpIMC->hPrivate);
SetActUnlockIMC:
ImmUnlockIMC(hIMC);
SetActEnd:
return (TRUE);
}
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_ENUMERATE_SUB_KEYS |
KEY_EXECUTE |
KEY_QUERY_VALUE|KEY_SET_VALUE,
phkResult);
}
VOID InfoMessage(HANDLE hWnd,WORD wMsgID)
{
TCHAR szStr[256];
LoadString(hInst,wMsgID,szStr, sizeof(szStr)/sizeof(TCHAR));
MessageBox(hWnd,szStr,szWarnTitle,MB_ICONINFORMATION|MB_OK);
}
VOID FatalMessage(HANDLE hWnd,WORD wMsgID)
{
TCHAR szStr[256];
LoadString(hInst,wMsgID,szStr, sizeof(szStr)/sizeof(TCHAR));
MessageBox(hWnd,szStr,szErrorTitle,MB_ICONSTOP|MB_OK);
}