Microsoft/WindowsXP-SP1
Microsoft/WindowsXP-SP1
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
f7ca35dddd
WindowsXP-SP1/windows/feime/cht/init.c
Microsoft f7ca35dddd First commit
2020-09-30 16:53:49 +02:00

1103 lines
34 KiB
C
Raw Blame History

/*++
Copyright (c) 1990-1999 Microsoft Corporation, All Rights Reserved
Module Name:
INIT.c
Abstract:
IME sample source code. This is pure UNICODE implementation of IME.
++*/
#include <windows.h>
#include <commdlg.h>
#include <winerror.h>
#include <immdev.h>
#include "imeattr.h"
#include "imerc.h"
#include "imedefs.h"
#if defined(MINIIME) || defined(UNIIME)
#include "uniime.h"
#endif
#if !defined(MINIIME)
/**********************************************************************/
/* InitImeGlobalData() */
/**********************************************************************/
void PASCAL InitImeGlobalData(void)
{
#if !defined(ROMANIME)
TCHAR szChiChar[4];
HDC hDC;
HGDIOBJ hOldFont;
LOGFONT lfFont;
SIZE lTextSize;
int xHalfWi[2];
#endif
HGLOBAL hResData;
int i;
#if !defined(ROMANIME)
DWORD dwSize;
HKEY hKeyNearCaret;
LONG lRet;
#endif
{
RECT rcWorkArea;
// get work area
SystemParametersInfo(SPI_GETWORKAREA, 0, &rcWorkArea, 0);
if (rcWorkArea.right < 2 * UI_MARGIN) {
} else if (rcWorkArea.bottom < 2 * UI_MARGIN) {
} else {
sImeG.rcWorkArea = rcWorkArea;
}
}
if (sImeG.wFullSpace) {
// the global data already init
return;
}
sImeG.uAnsiCodePage = NATIVE_ANSI_CP;
#if !defined(ROMANIME)
// get the Chinese char
LoadString(hInst, IDS_CHICHAR, szChiChar, sizeof(szChiChar)/sizeof(TCHAR));
// get size of Chinese char
hDC = GetDC(NULL);
hOldFont = GetCurrentObject(hDC, OBJ_FONT);
GetObject(hOldFont, sizeof(LOGFONT), &lfFont);
if (lfFont.lfCharSet != NATIVE_CHARSET) {
// Chicago Simplified Chinese
sImeG.fDiffSysCharSet = TRUE;
lfFont.lfCharSet = NATIVE_CHARSET;
lfFont.lfFaceName[0] = TEXT('\0');
} else {
sImeG.fDiffSysCharSet = FALSE;
}
lfFont.lfWeight = FW_DONTCARE;
SelectObject(hDC, CreateFontIndirect(&lfFont));
GetTextExtentPoint(hDC, szChiChar, lstrlen(szChiChar), &lTextSize);
if (sImeG.rcWorkArea.right < 2 * UI_MARGIN) {
sImeG.rcWorkArea.left = 0;
sImeG.rcWorkArea.right = GetDeviceCaps(hDC, HORZRES);
}
if (sImeG.rcWorkArea.bottom < 2 * UI_MARGIN) {
sImeG.rcWorkArea.top = 0;
sImeG.rcWorkArea.bottom = GetDeviceCaps(hDC, VERTRES);
}
DeleteObject(SelectObject(hDC, hOldFont));
ReleaseDC(NULL, hDC);
// get text metrics to decide the width & height of composition window
// these IMEs always use system font to show
sImeG.xChiCharWi = lTextSize.cx;
sImeG.yChiCharHi = lTextSize.cy;
// if unfortunate the xChiCharWi is odd number, xHalfWi[0] != xHalfWi[1]
xHalfWi[0] = sImeG.xChiCharWi / 2;
xHalfWi[1] = sImeG.xChiCharWi - xHalfWi[0];
for (i = 0; i < sizeof(iDx) / sizeof(int); i++) {
#ifdef UNICODE
iDx[i] = sImeG.xChiCharWi;
#else
iDx[i] = xHalfWi[i % 2];
#endif
}
#endif
// load full ABC chars
hResData = LoadResource(hInst, FindResource(hInst,
MAKEINTRESOURCE(IDRC_FULLABC), RT_RCDATA));
*(LPFULLABC)sImeG.wFullABC = *(LPFULLABC)LockResource(hResData);
UnlockResource(hResData);
FreeResource(hResData);
// full shape space
sImeG.wFullSpace = sImeG.wFullABC[0];
#ifndef UNICODE
// reverse internal code to internal code, NT don't need it
for (i = 0; i < NFULLABC; i++) {
sImeG.wFullABC[i] = (sImeG.wFullABC[i] << 8) |
(sImeG.wFullABC[i] >> 8);
}
#endif
#if !defined(ROMANIME) && !defined(WINAR30)
// load symbol chars
hResData = LoadResource(hInst, FindResource(hInst,
MAKEINTRESOURCE(IDRC_SYMBOL), RT_RCDATA));
*(LPSYMBOL)sImeG.wSymbol = *(LPSYMBOL)LockResource(hResData);
UnlockResource(hResData);
FreeResource(hResData);
#ifndef UNICODE
// reverse internal code to internal code, UNICODE don't need it
for (i = 0; i < NSYMBOL; i++) {
sImeG.wSymbol[i] = (sImeG.wSymbol[i] << 8) |
(sImeG.wSymbol[i] >> 8);
}
#endif
#endif
#ifdef HANDLE_PRIVATE_HOTKEY
// get IME hot key
for (i = 0; i < NUM_OF_IME_HOTKEYS; i++) {
ImmGetHotKey(IME_ITHOTKEY_RESEND_RESULTSTR + i, &sImeG.uModifiers[i],
&sImeG.uVKey[i], NULL);
}
#endif
#if defined(UNIIME)
// phrase table files
hResData = LoadResource(hInst, FindResource(hInst,
MAKEINTRESOURCE(IDRC_PHRASETABLES), RT_RCDATA));
*(LPPHRASETABLES)sImeG.szTblFile[0] =
*(LPPHRASETABLES)LockResource(hResData);
UnlockResource(hResData);
FreeResource(hResData);
#endif
#if !defined(ROMANIME)
// get the UI offset for near caret operation
RegCreateKey(HKEY_CURRENT_USER, szRegNearCaret, &hKeyNearCaret);
#if defined(UNIIME) && defined(UNICODE)
// if the user has its own phrase table file, we will overwrite it
{
TCHAR szPhraseDictionary[MAX_PATH];
TCHAR szPhrasePointer[MAX_PATH];
dwSize = sizeof(szPhraseDictionary);
lRet = RegQueryValueEx(hKeyNearCaret, szPhraseDic, NULL, NULL,
(LPBYTE)&szPhraseDictionary, &dwSize);
if (lRet != ERROR_SUCCESS) {
goto PharseOvr;
}
if (dwSize >= sizeof(szPhraseDictionary)) {
goto PharseOvr;
} else {
szPhraseDictionary[dwSize / sizeof(TCHAR)] = TEXT('\0');
}
dwSize = sizeof(szPhrasePointer);
lRet = RegQueryValueEx(hKeyNearCaret, szPhrasePtr, NULL, NULL,
(LPBYTE)&szPhrasePointer, &dwSize);
if (lRet != ERROR_SUCCESS) {
goto PharseOvr;
}
if (dwSize >= sizeof(szPhrasePointer)) {
goto PharseOvr;
} else {
szPhrasePointer[dwSize / sizeof(TCHAR)] = TEXT('\0');
}
dwSize = dwSize / sizeof(TCHAR) - 1;
for (; dwSize > 0; dwSize--) {
if (szPhrasePointer[dwSize] == TEXT('\\')) {
CopyMemory(sImeG.szPhrasePath, szPhrasePointer,
(dwSize + 1) * sizeof(TCHAR));
sImeG.uPathLen = dwSize + 1;
// phrase pointer file name
CopyMemory(sImeG.szTblFile[0], &szPhrasePointer[dwSize + 1],
sizeof(sImeG.szTblFile[0]));
// phrase file name
CopyMemory(sImeG.szTblFile[1], &szPhraseDictionary[dwSize + 1],
sizeof(sImeG.szTblFile[1]));
break;
}
}
PharseOvr: ; // NULL statement for goto
}
#endif
dwSize = sizeof(dwSize);
lRet = RegQueryValueEx(hKeyNearCaret, szPara, NULL, NULL,
(LPBYTE)&sImeG.iPara, &dwSize);
if (lRet != ERROR_SUCCESS) {
sImeG.iPara = 0;
RegSetValueEx(hKeyNearCaret, szPara, 0, REG_DWORD,
(LPBYTE)&sImeG.iPara, sizeof(int));
}
dwSize = sizeof(dwSize);
lRet = RegQueryValueEx(hKeyNearCaret, szPerp, NULL, NULL,
(LPBYTE)&sImeG.iPerp, &dwSize);
if (lRet != ERROR_SUCCESS) {
sImeG.iPerp = sImeG.yChiCharHi;
RegSetValueEx(hKeyNearCaret, szPerp, 0, REG_DWORD,
(LPBYTE)&sImeG.iPerp, sizeof(int));
}
dwSize = sizeof(dwSize);
lRet = RegQueryValueEx(hKeyNearCaret, szParaTol, NULL, NULL,
(LPBYTE)&sImeG.iParaTol, &dwSize);
if (lRet != ERROR_SUCCESS) {
sImeG.iParaTol = sImeG.xChiCharWi * 4;
RegSetValueEx(hKeyNearCaret, szParaTol, 0, REG_DWORD,
(LPBYTE)&sImeG.iParaTol, sizeof(int));
}
dwSize = sizeof(dwSize);
lRet = RegQueryValueEx(hKeyNearCaret, szPerpTol, NULL, NULL,
(LPBYTE)&sImeG.iPerpTol, &dwSize);
if (lRet != ERROR_SUCCESS) {
sImeG.iPerpTol = sImeG.yChiCharHi;
RegSetValueEx(hKeyNearCaret, szPerpTol, 0, REG_DWORD,
(LPBYTE)&sImeG.iPerpTol, sizeof(int));
}
RegCloseKey(hKeyNearCaret);
#endif
return;
}
/**********************************************************************/
/* GetUserSetting() */
/**********************************************************************/
DWORD PASCAL GetUserSetting(
#if defined(UNIIME)
LPIMEL lpImeL,
#endif
LPCTSTR lpszValueName,
LPVOID lpbData,
DWORD dwDataSize)
{
HKEY hKeyAppUser, hKeyIMEUser;
RegCreateKey(HKEY_CURRENT_USER, szRegAppUser, &hKeyAppUser);
RegCreateKey(hKeyAppUser, lpImeL->szUIClassName, &hKeyIMEUser);
RegCloseKey(hKeyAppUser);
RegQueryValueEx(hKeyIMEUser, lpszValueName, NULL, NULL,
lpbData, &dwDataSize);
RegCloseKey(hKeyIMEUser);
return (dwDataSize);
}
/**********************************************************************/
/* SetUserSetting() */
/**********************************************************************/
void PASCAL SetUserSetting(
#if defined(UNIIME)
LPIMEL lpImeL,
#endif
LPCTSTR lpszValueName,
DWORD dwType,
LPBYTE lpbData,
DWORD dwDataSize)
{
HKEY hKeyAppUser, hKeyIMEUser;
RegCreateKey(HKEY_CURRENT_USER, szRegAppUser, &hKeyAppUser);
RegCreateKey(hKeyAppUser, lpImeL->szUIClassName, &hKeyIMEUser);
RegCloseKey(hKeyAppUser);
RegSetValueEx(hKeyIMEUser, lpszValueName, 0, dwType, lpbData,
dwDataSize);
RegCloseKey(hKeyIMEUser);
return;
}
void RemoveRearSpaces( LPTSTR lpStr )
{
INT iLen;
if (lpStr == NULL ) return;
iLen = lstrlen(lpStr);
if ( iLen == 0 ) return;
iLen = iLen - 1;
while ( iLen >= 0 ) {
if ( lpStr[iLen] == TEXT(' ') ) {
lpStr[iLen] = TEXT('\0');
iLen --;
}
else
break;
}
return;
}
/**********************************************************************/
/* InitImeLocalData() */
/**********************************************************************/
BOOL PASCAL InitImeLocalData(
LPINSTDATAL lpInstL,
LPIMEL lpImeL)
{
#if !defined(ROMANIME)
HGLOBAL hResData;
UINT i;
WORD nSeqCode;
#if defined(PHON)
UINT nReadLayout;
#endif
#endif
// the local data already init
if (lpImeL->szIMEName[0]) {
return (TRUE);
}
// we will use the same string length for W version so / sizeof(WORD)
// get the IME name
LoadString(lpInstL->hInst, IDS_IMENAME, lpImeL->szIMEName,
sizeof(lpImeL->szIMEName) / sizeof(WCHAR));
// get the UI class name
LoadString(lpInstL->hInst, IDS_IMEUICLASS, lpImeL->szUIClassName,
sizeof(lpImeL->szUIClassName) / sizeof(WCHAR));
RemoveRearSpaces(lpImeL->szUIClassName);
#if !defined(ROMANIME)
// get the composition class name
LoadString(lpInstL->hInst, IDS_IMECOMPCLASS, lpImeL->szCompClassName,
sizeof(lpImeL->szCompClassName) / sizeof(WCHAR));
RemoveRearSpaces(lpImeL->szCompClassName);
// get the candidate class name
LoadString(lpInstL->hInst, IDS_IMECANDCLASS, lpImeL->szCandClassName,
sizeof(lpImeL->szCandClassName) / sizeof(WCHAR));
RemoveRearSpaces(lpImeL->szCandClassName);
#endif
// get the status class name
LoadString(lpInstL->hInst, IDS_IMESTATUSCLASS, lpImeL->szStatusClassName,
sizeof(lpImeL->szStatusClassName) / sizeof(WCHAR));
RemoveRearSpaces(lpImeL->szStatusClassName);
// get the off caret class name
LoadString(lpInstL->hInst, IDS_IMEOFFCARETCLASS,
lpImeL->szOffCaretClassName,
sizeof(lpImeL->szOffCaretClassName) / sizeof(WCHAR));
RemoveRearSpaces(lpImeL->szOffCaretClassName);
LoadString(lpInstL->hInst, IDS_IMECMENUCLASS, lpImeL->szCMenuClassName,
sizeof(lpImeL->szCMenuClassName) / sizeof(WCHAR));
RemoveRearSpaces(lpImeL->szCMenuClassName);
#if defined(ROMANIME)
lpImeL->nMaxKey = 1;
#else
// table not loaded
// lpInstL->fdwTblLoad = TBL_NOTLOADED;
// reference count is 0
// lpInstL->cRefCount = 0;
// tables are NULL
// lpInstL->hMapTbl[] = (HANDLE)NULL;
// user dictionary is NULL
// lpInstL->hUsrDicMem = (HANLE)NULL;
// load valid char in choose/input state
hResData = LoadResource(lpInstL->hInst, FindResource(lpInstL->hInst,
MAKEINTRESOURCE(IDRC_VALIDCHAR), RT_RCDATA));
*(LPVALIDCHAR)&lpImeL->dwVersion = *(LPVALIDCHAR)LockResource(hResData);
UnlockResource(hResData);
FreeResource(hResData);
#if !defined(WINIME) && !defined(UNICDIME)
// IME table files
hResData = LoadResource(lpInstL->hInst, FindResource(lpInstL->hInst,
MAKEINTRESOURCE(IDRC_TABLEFILES), RT_RCDATA));
*(LPTABLEFILES)lpImeL->szTblFile[0] =
*(LPTABLEFILES)LockResource(hResData);
UnlockResource(hResData);
FreeResource(hResData);
#ifndef UNICODE
#if defined(DAYI) || defined(WINAR30)
for (i = 0; i < sizeof(lpImeL->wSymbol) / sizeof(WORD); i++) {
lpImeL->wSymbol[i] = (lpImeL->wSymbol[i] << 8) |
(lpImeL->wSymbol[i] >> 8);
}
#endif
#endif
// file name of user dictionary
lpImeL->szUsrDic[0] = TEXT('\0'); // default value
i = GetUserSetting(
#if defined(UNIIME)
lpImeL,
#endif
szRegUserDic, lpImeL->szUsrDic, sizeof(lpImeL->szUsrDic));
if (i >= sizeof(lpImeL->szUsrDic)) {
lpImeL->szUsrDic[sizeof(lpImeL->szUsrDic) / sizeof(TCHAR) - 1] = '\0';
} else {
lpImeL->szUsrDic[i / sizeof(TCHAR)] = '\0';
}
lpImeL->szUsrDicMap[0] = '\0';
if (lpImeL->szUsrDic[0]) {
TCHAR szTempDir[MAX_PATH];
TCHAR szTempFile[MAX_PATH];
GetTempPath(sizeof(szTempDir) / sizeof(TCHAR), szTempDir);
// we do not want to create a real file so we GetTickCount
i = (UINT)GetTickCount();
if (!i) {
i++;
}
GetTempFileName(szTempDir, lpImeL->szUIClassName, i, szTempFile);
GetFileTitle(szTempFile, lpImeL->szUsrDicMap,
sizeof(lpImeL->szUsrDicMap) / sizeof(TCHAR));
}
#endif
nSeqCode = 0x0001;
for (i = 1; i < sizeof(DWORD) * 8; i++) {
nSeqCode <<= 1;
if (nSeqCode > lpImeL->nSeqCode) {
lpImeL->nSeqBits = (WORD)i;
break;
}
}
// calculate sequence code mask for one stoke (reading char)
if (!lpImeL->dwSeqMask) { // check again, it is still possible
// that multiple thread reach here
for (i = 0; i < lpImeL->nSeqBits; i++) {
lpImeL->dwSeqMask <<= 1;
lpImeL->dwSeqMask |= 0x0001;
}
}
// data bytes for one finalized char
lpImeL->nSeqBytes = (lpImeL->nSeqBits * lpImeL->nMaxKey + 7) / 8;
// valid bits mask for all strokes
if (!lpImeL->dwPatternMask) { // check again, it is still possible
// that multiple thread reach here
for (i =0; i < lpImeL->nMaxKey; i++) {
lpImeL->dwPatternMask <<= lpImeL->nSeqBits;
lpImeL->dwPatternMask |= lpImeL->dwSeqMask;
}
}
lpImeL->hRevKL = NULL;
GetUserSetting(
#if defined(UNIIME)
lpImeL,
#endif
szRegRevKL, &lpImeL->hRevKL, sizeof(lpImeL->hRevKL));
// mark this event for later check reverse length
if (lpImeL->hRevKL) {
lpImeL->fdwErrMsg |= NO_REV_LENGTH;
}
// we assume the max key is the same as this IME, check later
lpImeL->nRevMaxKey = lpImeL->nMaxKey;
#if defined(PHON)
// keyboard arrangement, ACER ETen IBM ... for bo po mo fo
nReadLayout = READ_LAYOUT_DEFAULT; // default value
// can not use lpImeL->nReadLayout, its size is WORD only
GetUserSetting(
#if defined(UNIIME)
lpImeL,
#endif
szRegReadLayout, &nReadLayout, sizeof(nReadLayout));
lpImeL->nReadLayout = (WORD)nReadLayout;
if (lpImeL->nReadLayout >= READ_LAYOUTS) {
lpImeL->nReadLayout = READ_LAYOUT_DEFAULT;
}
#endif
#endif
#if defined(WINAR30)
lpImeL->fdwModeConfig = MODE_CONFIG_QUICK_KEY|MODE_CONFIG_PREDICT;
#elif defined(ROMANIME)
lpImeL->fdwModeConfig = 0;
#else
lpImeL->fdwModeConfig = MODE_CONFIG_PREDICT;
#endif
GetUserSetting(
#if defined(UNIIME)
lpImeL,
#endif
szRegModeConfig, &lpImeL->fdwModeConfig, sizeof(lpImeL->fdwModeConfig));
return (TRUE);
}
/**********************************************************************/
/* InitImeUIData() */
/**********************************************************************/
void PASCAL InitImeUIData( // initialize each UI component coordination
LPIMEL lpImeL)
{
int cxBorder, cyBorder, cxEdge, cyEdge, cxMinWindowWidth;
cxEdge = GetSystemMetrics(SM_CXEDGE);
cyEdge = GetSystemMetrics(SM_CYEDGE);
// border + raising edge
cxBorder = GetSystemMetrics(SM_CXBORDER);
cyBorder = GetSystemMetrics(SM_CYBORDER);
lpImeL->cxStatusBorder = cxBorder + cxEdge;
lpImeL->cyStatusBorder = cyBorder + cyEdge;
// the width/high and status position relative to status window
lpImeL->rcStatusText.left = 0;
lpImeL->rcStatusText.top = 0;
lpImeL->rcStatusText.bottom = lpImeL->rcStatusText.top + STATUS_DIM_Y;
// conversion mode status
lpImeL->rcInputText.left = lpImeL->rcStatusText.left;
lpImeL->rcInputText.top = lpImeL->rcStatusText.top;
lpImeL->rcInputText.right = lpImeL->rcInputText.left + STATUS_DIM_X;
lpImeL->rcInputText.bottom = lpImeL->rcStatusText.bottom;
// full/half shape status
lpImeL->rcShapeText.left = lpImeL->rcInputText.right;
lpImeL->rcShapeText.top = lpImeL->rcStatusText.top;
lpImeL->rcShapeText.right = lpImeL->rcShapeText.left + STATUS_DIM_X;
lpImeL->rcShapeText.bottom = lpImeL->rcStatusText.bottom;
lpImeL->rcStatusText.right = lpImeL->rcShapeText.right;
lpImeL->xStatusWi = (lpImeL->rcStatusText.right -
lpImeL->rcStatusText.left) + lpImeL->cxStatusBorder * 2;
lpImeL->yStatusHi = (lpImeL->rcStatusText.bottom -
lpImeL->rcStatusText.top) + lpImeL->cyStatusBorder * 2;
#if !defined(ROMANIME)
if (lpImeL->fdwModeConfig & MODE_CONFIG_OFF_CARET_UI) {
lpImeL->cxCompBorder = cxBorder + cxEdge;
lpImeL->cyCompBorder = cyBorder + cyEdge;
} else {
lpImeL->cxCompBorder = cxBorder;
lpImeL->cyCompBorder = cyBorder;
}
lpImeL->rcCompText.top = lpImeL->cyCompBorder;
lpImeL->rcCompText.bottom = lpImeL->rcCompText.top +
sImeG.yChiCharHi;
// two borders, outsize & candidate inside border
if (lpImeL->fdwModeConfig & MODE_CONFIG_OFF_CARET_UI) {
lpImeL->cxCandBorder = cxBorder + cxEdge;
lpImeL->cyCandBorder = cyBorder + cyEdge;
} else {
lpImeL->cxCandBorder = cxBorder;
lpImeL->cyCandBorder = cyBorder;
}
lpImeL->cxCandMargin = cxBorder + cxEdge;
lpImeL->cyCandMargin = cyBorder + cyEdge;
// the width/high and text position relative to candidate window
if (lpImeL->fdwModeConfig & MODE_CONFIG_OFF_CARET_UI) {
lpImeL->rcCandText.top = lpImeL->cyCandBorder;
#if defined(WINAR30)
lpImeL->rcCompText.left = lpImeL->rcStatusText.right +
lpImeL->cxCompBorder * 2;
lpImeL->rcCompText.right = lpImeL->rcCompText.left +
sImeG.xChiCharWi * lpImeL->nRevMaxKey;
lpImeL->rcCandText.left = lpImeL->rcCompText.right +
lpImeL->cxCompBorder * 2 + lpImeL->cxCandBorder;
lpImeL->rcCandText.right = lpImeL->rcCandText.left +
sImeG.xChiCharWi * CANDPERPAGE * 3 / 2;
#else
lpImeL->rcCandText.left = lpImeL->rcCompText.left =
lpImeL->rcStatusText.right + lpImeL->cxCompBorder +
lpImeL->cxCandBorder;
lpImeL->rcCandText.right = lpImeL->rcCompText.right =
lpImeL->rcCompText.left + sImeG.xChiCharWi * CANDPERPAGE * 3 / 2;
#endif
lpImeL->rcCandText.bottom = lpImeL->rcCandText.top + sImeG.yChiCharHi;
lpImeL->rcCandPrompt.left = lpImeL->rcCandText.right +
lpImeL->cxCandMargin + lpImeL->cxCandBorder;
lpImeL->rcCandPrompt.top = lpImeL->rcStatusText.top +
(STATUS_DIM_Y - CAND_PROMPT_DIM_Y) / 2;
lpImeL->rcCandPrompt.right = lpImeL->rcCandPrompt.left +
CAND_PROMPT_DIM_X;
lpImeL->rcCandPrompt.bottom = lpImeL->rcCandPrompt.top +
CAND_PROMPT_DIM_Y;
lpImeL->rcCandPageText.left = lpImeL->rcCandPrompt.right +
lpImeL->cxCandMargin + lpImeL->cxCandBorder;
lpImeL->rcCandPageText.top = lpImeL->rcStatusText.top +
(STATUS_DIM_Y - PAGE_DIM_Y) / 2;
lpImeL->rcCandPageText.bottom = lpImeL->rcCandPageText.top +
PAGE_DIM_Y;
lpImeL->rcCandPageUp.left = lpImeL->rcCandPageText.left;
lpImeL->rcCandPageUp.top = lpImeL->rcCandPageText.top;
lpImeL->rcCandPageUp.right = lpImeL->rcCandPageUp.left + PAGE_DIM_X;
lpImeL->rcCandPageUp.bottom = lpImeL->rcCandPageText.bottom;
lpImeL->rcCandHome.left = lpImeL->rcCandPageUp.right;
lpImeL->rcCandHome.top = lpImeL->rcCandPageUp.top;
lpImeL->rcCandHome.right = lpImeL->rcCandHome.left + PAGE_DIM_X;
lpImeL->rcCandHome.bottom = lpImeL->rcCandPageUp.bottom;
lpImeL->rcCandPageDn.left = lpImeL->rcCandHome.right;
lpImeL->rcCandPageDn.top = lpImeL->rcCandHome.top;
lpImeL->rcCandPageDn.right = lpImeL->rcCandPageDn.left + PAGE_DIM_X;
lpImeL->rcCandPageDn.bottom = lpImeL->rcCandHome.bottom;
lpImeL->rcCandPageText.right = lpImeL->rcCandPageDn.right;
lpImeL->xCompWi = lpImeL->rcCandPageDn.right +
lpImeL->cxCandMargin + lpImeL->cxCandBorder;
lpImeL->xCandWi = lpImeL->xCompWi;
lpImeL->xStatusWi = lpImeL->xCompWi;
} else {
lpImeL->rcCompText.left = lpImeL->cxCompBorder;
lpImeL->rcCompText.right = lpImeL->rcCompText.left +
sImeG.xChiCharWi * lpImeL->nRevMaxKey;
lpImeL->rcCandPrompt.left = lpImeL->cxCandMargin;
lpImeL->rcCandPrompt.top = lpImeL->cyCandBorder;
lpImeL->rcCandPrompt.right = lpImeL->rcCandPrompt.left +
CAND_PROMPT_DIM_X;
lpImeL->rcCandPrompt.bottom = lpImeL->rcCandPrompt.top +
CAND_PROMPT_DIM_Y;
lpImeL->rcCandPageText.top = lpImeL->rcCandPrompt.top;
lpImeL->rcCandPageText.bottom = lpImeL->rcCandPageText.top +
PAGE_DIM_Y;
lpImeL->rcCandPageUp.top = lpImeL->rcCandPageText.top;
lpImeL->rcCandPageUp.bottom = lpImeL->rcCandPageText.bottom;
lpImeL->rcCandHome.top = lpImeL->rcCandPageUp.top;
lpImeL->rcCandHome.bottom = lpImeL->rcCandPageUp.bottom;
lpImeL->rcCandPageDn.top = lpImeL->rcCandHome.top;
lpImeL->rcCandPageDn.bottom = lpImeL->rcCandHome.bottom;
lpImeL->rcCandText.left = lpImeL->cxCandMargin;
lpImeL->rcCandText.top = lpImeL->rcCandPageText.bottom +
lpImeL->cyCandBorder + lpImeL->cyCandMargin;
//Window width should be at least 8 characters AND greater than total
//width of the bitmaps.
cxMinWindowWidth= CAND_PROMPT_DIM_X + 2 * PAGE_DIM_X +
lpImeL->cxCandMargin + lpImeL->cxCandBorder;
lpImeL->rcCandText.right = lpImeL->rcCandText.left +
sImeG.xChiCharWi * 8 > cxMinWindowWidth ?
sImeG.xChiCharWi * 8 : cxMinWindowWidth;
lpImeL->rcCandText.bottom = lpImeL->rcCandText.top +
sImeG.yChiCharHi * CANDPERPAGE;
lpImeL->rcCandPageText.right = lpImeL->rcCandText.right;
lpImeL->rcCandPageDn.right = lpImeL->rcCandPageText.right;
lpImeL->rcCandPageDn.left = lpImeL->rcCandPageDn.right - PAGE_DIM_X;
lpImeL->rcCandPageUp.right = lpImeL->rcCandPageDn.left;
lpImeL->rcCandPageUp.left = lpImeL->rcCandPageUp.right - PAGE_DIM_X;
lpImeL->rcCandPageText.left = lpImeL->rcCandPageUp.left;
lpImeL->xCompWi = (lpImeL->rcCompText.right -
lpImeL->rcCompText.left) + lpImeL->cxCompBorder * 2 * 2;
lpImeL->xCandWi = (lpImeL->rcCandText.right -
lpImeL->rcCandText.left) + lpImeL->cxCandBorder * 2 +
lpImeL->cxCandMargin * 2;
}
lpImeL->yCompHi = (lpImeL->rcCompText.bottom - lpImeL->rcCompText.top) +
lpImeL->cyCompBorder * 2 * 2;
lpImeL->yCandHi = lpImeL->rcCandText.bottom + lpImeL->cyCandBorder * 2 +
lpImeL->cyCandMargin;
#endif
#if !defined(ROMANIME)
if (lpImeL->fdwModeConfig & MODE_CONFIG_OFF_CARET_UI) {
// the font in composition window is higher than status bitmap
if (lpImeL->yStatusHi < lpImeL->yCompHi) {
int cyDelta;
cyDelta = (lpImeL->yCompHi - lpImeL->yStatusHi) / 2;
lpImeL->yStatusHi = lpImeL->yCompHi;
lpImeL->rcShapeText.top = lpImeL->rcInputText.top =
lpImeL->rcStatusText.top += cyDelta;
lpImeL->rcShapeText.bottom = lpImeL->rcInputText.bottom =
lpImeL->rcStatusText.bottom += cyDelta;
lpImeL->rcCandPageUp.top = lpImeL->rcCandHome.top =
lpImeL->rcCandPageDn.top += cyDelta;
lpImeL->rcCandPageUp.bottom = lpImeL->rcCandHome.bottom =
lpImeL->rcCandPageDn.bottom += cyDelta;
}
// the font in composition window is smaller than status bitmap
if (lpImeL->yCompHi < lpImeL->yStatusHi) {
int cyDelta;
cyDelta = (lpImeL->yStatusHi - lpImeL->yCompHi) / 2;
lpImeL->yCandHi = lpImeL->yCompHi = lpImeL->yStatusHi;
lpImeL->rcCandText.top = lpImeL->rcCompText.top += cyDelta;
lpImeL->rcCandText.bottom = lpImeL->rcCompText.bottom += cyDelta;
}
}
#endif
return;
}
#if !defined(ROMANIME)
/**********************************************************************/
/* SetCompLocalData() */
/**********************************************************************/
void PASCAL SetCompLocalData(
LPIMEL lpImeL)
{
if (lpImeL->fdwModeConfig & MODE_CONFIG_OFF_CARET_UI) {
#if defined(WINAR30)
InitImeUIData(lpImeL);
#endif
return;
}
// text position relative to the composition window
lpImeL->rcCompText.right = lpImeL->rcCompText.left +
sImeG.xChiCharWi * lpImeL->nRevMaxKey;
// set the width & height for composition window
lpImeL->xCompWi = lpImeL->rcCompText.right + lpImeL->cxCompBorder * 3;
return;
}
#endif
/**********************************************************************/
/* RegisterImeClass() */
/**********************************************************************/
void PASCAL RegisterImeClass(
#if defined(UNIIME)
LPINSTDATAL lpInstL,
LPIMEL lpImeL,
#endif
WNDPROC lpfnUIWndProc,
#if !defined(ROMANIME)
WNDPROC lpfnCompWndProc,
WNDPROC lpfnCandWndProc,
#endif
WNDPROC lpfnStatusWndProc,
WNDPROC lpfnOffCaretWndProc,
WNDPROC lpfnContextMenuWndProc)
{
WNDCLASSEX wcWndCls;
// IME UI class
wcWndCls.cbSize = sizeof(WNDCLASSEX);
wcWndCls.cbClsExtra = 0;
wcWndCls.cbWndExtra = WND_EXTRA_SIZE;
wcWndCls.hIcon = LoadIcon(lpInstL->hInst,
MAKEINTRESOURCE(IDIC_IME_ICON));
wcWndCls.hInstance = lpInstL->hInst;
wcWndCls.hCursor = LoadCursor(NULL, IDC_ARROW);
wcWndCls.hbrBackground = GetStockObject(NULL_BRUSH);
wcWndCls.lpszMenuName = (LPTSTR)NULL;
wcWndCls.hIconSm = LoadImage(lpInstL->hInst,
MAKEINTRESOURCE(IDIC_IME_ICON), IMAGE_ICON, 16, 16, LR_DEFAULTCOLOR);
// IME UI class
if (!GetClassInfoEx(lpInstL->hInst, lpImeL->szUIClassName, &wcWndCls)) {
wcWndCls.style = CS_IME;
wcWndCls.lpfnWndProc = lpfnUIWndProc;
wcWndCls.lpszClassName = lpImeL->szUIClassName;
RegisterClassEx(&wcWndCls);
}
wcWndCls.style = CS_IME|CS_HREDRAW|CS_VREDRAW;
wcWndCls.hbrBackground = GetStockObject(LTGRAY_BRUSH);
#if !defined(ROMANIME)
// IME composition class
if (!GetClassInfoEx(lpInstL->hInst, lpImeL->szCompClassName, &wcWndCls)) {
wcWndCls.lpfnWndProc = lpfnCompWndProc;
wcWndCls.lpszClassName = lpImeL->szCompClassName;
RegisterClassEx(&wcWndCls);
}
// IME candidate class
if (!GetClassInfoEx(lpInstL->hInst, lpImeL->szCandClassName, &wcWndCls)) {
wcWndCls.lpfnWndProc = lpfnCandWndProc;
wcWndCls.lpszClassName = lpImeL->szCandClassName;
RegisterClassEx(&wcWndCls);
}
#endif
// IME status class
if (!GetClassInfoEx(lpInstL->hInst, lpImeL->szStatusClassName, &wcWndCls)) {
wcWndCls.lpfnWndProc = lpfnStatusWndProc;
wcWndCls.lpszClassName = lpImeL->szStatusClassName;
RegisterClassEx(&wcWndCls);
}
// IME off caret class
if (!GetClassInfoEx(lpInstL->hInst, lpImeL->szOffCaretClassName, &wcWndCls)) {
wcWndCls.lpfnWndProc = lpfnOffCaretWndProc;
wcWndCls.lpszClassName = lpImeL->szOffCaretClassName;
RegisterClassEx(&wcWndCls);
}
// IME context menu class
if (!GetClassInfoEx(lpInstL->hInst, lpImeL->szCMenuClassName, &wcWndCls)) {
wcWndCls.style = 0;
wcWndCls.hbrBackground = GetStockObject(NULL_BRUSH);
wcWndCls.lpfnWndProc = lpfnContextMenuWndProc;
wcWndCls.lpszClassName = lpImeL->szCMenuClassName;
RegisterClassEx(&wcWndCls);
}
return;
}
/**********************************************************************/
/* AttachIME() / UniAttachMiniIME() */
/**********************************************************************/
#if defined(UNIIME)
void WINAPI UniAttachMiniIME(
#else
void PASCAL AttachIME(
#endif
#if defined(UNIIME)
LPINSTDATAL lpInstL,
LPIMEL lpImeL,
#endif
WNDPROC lpfnUIWndProc,
#if !defined(ROMANIME)
WNDPROC lpfnCompWndProc,
WNDPROC lpfnCandWndProc,
#endif
WNDPROC lpfnStatusWndProc,
WNDPROC lpfnOffCaretWndProc,
WNDPROC lpfnContextMenuWndProc)
{
#if !defined(UNIIME)
InitImeGlobalData();
#endif
InitImeLocalData(lpInstL, lpImeL);
if (!lpImeL->rcStatusText.bottom) {
InitImeUIData(lpImeL);
}
RegisterImeClass(
#if defined(UNIIME)
lpInstL, lpImeL,
#endif
lpfnUIWndProc,
#if !defined(ROMANIME)
lpfnCompWndProc, lpfnCandWndProc,
#endif
lpfnStatusWndProc, lpfnOffCaretWndProc,
lpfnContextMenuWndProc);
return;
}
/**********************************************************************/
/* DetachIME() / UniDetachMiniIME() */
/**********************************************************************/
#if defined(UNIIME)
void WINAPI UniDetachMiniIME(
#else
void PASCAL DetachIME(
#endif
LPINSTDATAL lpInstL,
LPIMEL lpImeL)
{
WNDCLASSEX wcWndCls;
if (GetClassInfoEx(lpInstL->hInst, lpImeL->szCMenuClassName, &wcWndCls)) {
UnregisterClass(lpImeL->szCMenuClassName, lpInstL->hInst);
}
if (GetClassInfoEx(lpInstL->hInst, lpImeL->szOffCaretClassName, &wcWndCls)) {
UnregisterClass(lpImeL->szOffCaretClassName, lpInstL->hInst);
}
if (GetClassInfoEx(lpInstL->hInst, lpImeL->szStatusClassName, &wcWndCls)) {
UnregisterClass(lpImeL->szStatusClassName, lpInstL->hInst);
}
#if !defined(ROMANIME)
if (GetClassInfoEx(lpInstL->hInst, lpImeL->szCandClassName, &wcWndCls)) {
UnregisterClass(lpImeL->szCandClassName, lpInstL->hInst);
}
if (GetClassInfoEx(lpInstL->hInst, lpImeL->szCompClassName, &wcWndCls)) {
UnregisterClass(lpImeL->szCompClassName, lpInstL->hInst);
}
#endif
if (!GetClassInfoEx(lpInstL->hInst, lpImeL->szUIClassName, &wcWndCls)) {
} else if (!UnregisterClass(lpImeL->szUIClassName, lpInstL->hInst)) {
} else {
DestroyIcon(wcWndCls.hIcon);
DestroyIcon(wcWndCls.hIconSm);
}
#if !defined(ROMANIME)
FreeTable(lpInstL);
#endif
}
#endif // !defined(MINIIME)
/**********************************************************************/
/* ImeDllInit() / UniImeDllInit() */
/* Return Value: */
/* TRUE - successful */
/* FALSE - failure */
/**********************************************************************/
#if defined(UNIIME)
BOOL CALLBACK UniImeDllInit(
#else
BOOL CALLBACK ImeDllInit(
#endif
HINSTANCE hInstance, // instance handle of this library
DWORD fdwReason, // reason called
LPVOID lpvReserve) // reserve pointer
{
switch (fdwReason) {
case DLL_PROCESS_ATTACH:
hInst = hInstance;
#if !defined(UNIIME)
if (lpInstL) {
// the local instance data already init
return (TRUE);
}
lpInstL = &sInstL;
lpInstL->hInst = hInstance;
lpInstL->lpImeL = lpImeL = &sImeL;
#endif
#if defined(MINIIME)
UniAttachMiniIME(lpInstL, lpImeL, UIWndProc, CompWndProc,
CandWndProc, StatusWndProc, OffCaretWndProc,
ContextMenuWndProc);
#elif defined(UNIIME)
InitImeGlobalData();
{
LoadPhraseTable(sImeG.uPathLen, sImeG.szPhrasePath);
}
#else
AttachIME(UIWndProc,
#if !defined(ROMANIME)
CompWndProc, CandWndProc,
#endif
StatusWndProc, OffCaretWndProc, ContextMenuWndProc);
#endif
break;
case DLL_PROCESS_DETACH:
#if defined(MINIIME)
UniDetachMiniIME(lpInstL, lpImeL);
#elif defined(UNIIME)
{
int i;
for (i = 0; i < MAX_PHRASE_TABLES; i++) {
if (sInstG.hMapTbl[i]) {
CloseHandle(sInstG.hMapTbl[i]);
sInstG.hMapTbl[i] = (HANDLE)NULL;
}
}
}
#else
DetachIME(lpInstL, lpImeL);
#endif
break;
default:
break;
}
return (TRUE);
}
Reference in New Issue View Git Blame Copy Permalink