able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/windows/feime/chs/ntabc/winabc/abc95ui.c
CryptoAlgo Inc b3cac27891 Add source files
2020-09-26 16:20:57 +08:00

9734 lines
303 KiB
C
Raw Blame History

This file contains ambiguous Unicode characters

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

/*************************************************
* abc95ui.c *
* *
* Copyright (C) 1995-1999 Microsoft Inc. *
* *
*************************************************/
#include <windows.h>
#include <winerror.h>
#include <winuser.h>
#include <windowsx.h>
#include <immdev.h>
#include <stdio.h>
#include <shlobj.h>
#include "abc95def.h"
#include "resource.h"
#include "resrc1.h"
#include "data.H"
#define IME_CMODE_SDA 0x80000000
HWND hCrtDlg = NULL;
LONG lLock = 0; // this var is for Lock and unLock.
void PASCAL ReInitIme2(HWND ,WORD);
// Get the current user's EMB file path, and IME's MB path
// fill global variable sImeG.szIMEUserPath
void GetCurrentUserEMBPath( )
{
TCHAR szModuleName[MAX_PATH], *lpszStart, *lpszDot;
int i;
// Get the path for MB and EMB
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');
}
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, NULL);
lstrcat(sImeG.szIMEUserPath, TEXT("\\IME") );
if ( GetFileAttributes(sImeG.szIMEUserPath) != FILE_ATTRIBUTE_DIRECTORY)
CreateDirectory(sImeG.szIMEUserPath, NULL);
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, NULL);
return;
}
//**************************************************************************
//* Name : *
//* void DrawConvexRect() *
//* Description : *
//* draw a convex rectangle *
//* Parameters : *
//* hDC - the handle of DC be drawed *
//* (x1,y1) *
//* +------------+ *
//* |+----1----> | *
//* ||2 x2-2| *
//* |Vy2-2 | *
//* | | *
//* +------------+ *
//* (x2,y2) *
//* Return Value: *
//* none *
//**************************************************************************
void DrawConvexRect(
HDC hDC,
int x1,
int y1,
int x2,
int y2)
{
// draw the most outer color =light gray and black
SelectObject(hDC,sImeG.LightGrayPen);
MoveToEx(hDC, x1, y1,NULL);
LineTo(hDC, x2-1, y1);
MoveToEx(hDC, x1, y1,NULL);
LineTo(hDC, x1, y2-1);
SelectObject(hDC,sImeG.BlackPen); //GetStockObject(BLACK_PEN));
MoveToEx(hDC, x1, y2,NULL);
LineTo(hDC, x2+1, y2);
MoveToEx(hDC, x2, y1,NULL);
LineTo(hDC, x2, y2);
// draw the second line color = white and grary
SelectObject(hDC, sImeG.WhitePen); //GetStockObject(WHITE_PEN));
MoveToEx(hDC, x1+1, y1+1,NULL);
LineTo(hDC, x2-1, y1+1);
MoveToEx(hDC, x1+1, y1+1,NULL);
LineTo(hDC, x1+1, y2-1);
SelectObject(hDC,sImeG.GrayPen);
MoveToEx(hDC, x1+1, y2-1,NULL);
LineTo(hDC, x2, y2-1);
MoveToEx(hDC, x2-1, y1+1,NULL);
LineTo(hDC, x2-1, y2-1);
// draw the fourth line color = gray and white
SelectObject(hDC,sImeG.GrayPen); // CreatePen(PS_SOLID, 1, 0x00808080));
MoveToEx(hDC, x1+3, y1+3,NULL);
LineTo(hDC, x2-3, y1+3);
MoveToEx(hDC, x1+3, y1+3,NULL);
LineTo(hDC, x1+3, y2-3);
SelectObject(hDC, sImeG.WhitePen);
MoveToEx(hDC, x1+3, y2-3,NULL);
LineTo(hDC, x2-2, y2-3);
MoveToEx(hDC, x2-3, y1+3,NULL);
LineTo(hDC, x2-3, y2-3);
}
//**************************************************************************
//* Name : *
//* void DrawConcaveRect() *
//* Description : *
//* draw a concave rectangle *
//* Parameters : *
//* hDC - the handle of DC be drawed *
//* (x1,y1) x2-1 *
//* +-----1----->+ *
//* | ^ y1+1 *
//* 2 | *
//* | 3 *
//* y2-1 V | *
//* <-----4------+ *
//* x1 (x2,y2) *
//* Return Value: *
//* none *
//**************************************************************************
void DrawStatusRect(
HDC hDC,
int x1,
int y1,
int x2,
int y2)
{
SelectObject(hDC,sImeG.LightGrayPen);
MoveToEx(hDC, x1, y1,NULL);
LineTo(hDC, x2-1, y1);
MoveToEx(hDC, x1, y1,NULL);
LineTo(hDC, x1, y2-1);
SelectObject(hDC,sImeG.BlackPen); //GetStockObject(BLACK_PEN));
MoveToEx(hDC, x1, y2,NULL);
LineTo(hDC, x2+1, y2);
MoveToEx(hDC, x2, y1,NULL);
LineTo(hDC, x2, y2);
// draw the second line color = white and grary
SelectObject(hDC, sImeG.WhitePen); //GetStockObject(WHITE_PEN));
MoveToEx(hDC, x1+1, y1+1,NULL);
LineTo(hDC, x2-1, y1+1);
MoveToEx(hDC, x1+1, y1+1,NULL);
LineTo(hDC, x1+1, y2-1);
SelectObject(hDC,sImeG.GrayPen);
MoveToEx(hDC, x1+1, y2-1,NULL);
LineTo(hDC, x2, y2-1);
MoveToEx(hDC, x2-1, y1+1,NULL);
LineTo(hDC, x2-1, y2-1);
}
/**********************************************************************/
/* ShowBitmap2() */
/* a subprgm for ShowBitmap */
/**********************************************************************/
void ShowBitmap2(
HDC hDC,
int x,
int y,
int Wi,
int Hi,
HBITMAP hBitmap)
{
HDC hMemDC ;
HBITMAP hOldBmp;
hMemDC = CreateCompatibleDC(hDC);
if ( hMemDC == NULL )
return;
hOldBmp = SelectObject(hMemDC, hBitmap);
BitBlt(hDC,
x,
y,
Wi,
Hi,
hMemDC,
0,
0,
SRCCOPY);
SelectObject(hMemDC, hOldBmp);
DeleteDC(hMemDC);
return ;
}
/**********************************************************************/
/* ShowBitmap() */
/**********************************************************************/
void ShowBitmap(
HDC hDC,
int x,
int y,
int Wi,
int Hi,
LPSTR BitmapName)
{
HBITMAP hBitmap ;
hBitmap = LoadBitmap(hInst, BitmapName);
if ( hBitmap )
{
ShowBitmap2(hDC, x,y,Wi,Hi,hBitmap);
DeleteObject(hBitmap);
}
return ;
}
/**********************************************************************/
/* CreateUIWindow() */
/**********************************************************************/
void PASCAL CreateUIWindow( // create composition window
HWND hUIWnd)
{
HGLOBAL hUIPrivate;
// create storage for UI setting
hUIPrivate = GlobalAlloc(GHND, sizeof(UIPRIV));
if (!hUIPrivate) { // Oh! Oh!
return;
}
SetWindowLongPtr(hUIWnd, IMMGWLP_PRIVATE, (LONG_PTR)hUIPrivate);
// set the default position for UI window, it is hide now
SetWindowPos(hUIWnd, NULL, 0, 0, 0, 0, SWP_NOACTIVATE|SWP_NOZORDER);
ShowWindow(hUIWnd, SW_SHOWNOACTIVATE);
return;
}
//ui.c skd #5
/**********************************************************************/
/* ShowSoftKbd */
/**********************************************************************/
void PASCAL ShowSoftKbd( // Show the soft keyboard window
HWND hUIWnd,
int nShowSoftKbdCmd)
{
HIMC hIMC;
LPINPUTCONTEXT lpIMC;
HGLOBAL hUIPrivate;
LPUIPRIV lpUIPrivate;
LPPRIVCONTEXT lpImcP;
hUIPrivate = (HGLOBAL)GetWindowLongPtr(hUIWnd, IMMGWLP_PRIVATE);
if (!hUIPrivate) { // can not darw status window
return;
}
lpUIPrivate = (LPUIPRIV)GlobalLock(hUIPrivate);
if (!lpUIPrivate) { // can not draw status window
return;
}
hIMC = (HIMC)GetWindowLongPtr(hUIWnd, IMMGWLP_IMC);
if (!hIMC)
return;
lpIMC =(LPINPUTCONTEXT)ImmLockIMC(hIMC);
if (!lpIMC)
return;
lpImcP =(LPPRIVCONTEXT)ImmLockIMCC(lpIMC->hPrivate);
if (!lpImcP){
ImmUnlockIMC(hIMC);
return;
}
CheckMenuItem(lpImeL->hSKMenu, IDM_SKL1, MF_UNCHECKED);
CheckMenuItem(lpImeL->hSKMenu, IDM_SKL2, MF_UNCHECKED);
CheckMenuItem(lpImeL->hSKMenu, IDM_SKL3, MF_UNCHECKED);
CheckMenuItem(lpImeL->hSKMenu, IDM_SKL4, MF_UNCHECKED);
CheckMenuItem(lpImeL->hSKMenu, IDM_SKL5, MF_UNCHECKED);
CheckMenuItem(lpImeL->hSKMenu, IDM_SKL6, MF_UNCHECKED);
CheckMenuItem(lpImeL->hSKMenu, IDM_SKL7, MF_UNCHECKED);
CheckMenuItem(lpImeL->hSKMenu, IDM_SKL8, MF_UNCHECKED);
CheckMenuItem(lpImeL->hSKMenu, IDM_SKL9, MF_UNCHECKED);
CheckMenuItem(lpImeL->hSKMenu, IDM_SKL10, MF_UNCHECKED);
CheckMenuItem(lpImeL->hSKMenu, IDM_SKL11, MF_UNCHECKED);
CheckMenuItem(lpImeL->hSKMenu, IDM_SKL12, MF_UNCHECKED);
CheckMenuItem(lpImeL->hSKMenu, IDM_SKL13, MF_UNCHECKED);
if (!lpUIPrivate->hSoftKbdWnd) {
// not in show status window mode
} else if (lpUIPrivate->nShowSoftKbdCmd != nShowSoftKbdCmd) {
ImmShowSoftKeyboard(lpUIPrivate->hSoftKbdWnd, nShowSoftKbdCmd);
if (nShowSoftKbdCmd != SW_HIDE){
SendMessage(lpUIPrivate->hSoftKbdWnd,WM_PAINT,0,0l);
ReDrawSdaKB(hIMC, lpImeL->dwSKWant, nShowSoftKbdCmd);
}
lpUIPrivate->nShowSoftKbdCmd = nShowSoftKbdCmd;
lpImcP->nShowSoftKbdCmd = nShowSoftKbdCmd;
if(!(lpImcP == NULL)) {
if(lpImeL->dwSKState[lpImeL->dwSKWant]) {
if(!(lpImeL->hSKMenu)) {
lpImeL->hSKMenu = LoadMenu (hInst, "SKMENU");
}
CheckMenuItem(lpImeL->hSKMenu,
lpImeL->dwSKWant + IDM_SKL1, MF_CHECKED);
}
}
}
ImmUnlockIMCC(lpIMC->hPrivate);
ImmUnlockIMC(hIMC);
GlobalUnlock(hUIPrivate);
return;
}
/**********************************************************************/
/* ChangeCompositionSize() */
/**********************************************************************/
void PASCAL ChangeCompositionSize(
HWND hUIWnd)
{
HWND hCompWnd, hCandWnd;
RECT rcWnd;
UINT nMaxKey;
HIMC hIMC;
LPINPUTCONTEXT lpIMC;
hCompWnd = GetCompWnd(hUIWnd);
if (!hCompWnd) {
return;
}
GetWindowRect(hCompWnd, &rcWnd);
if ((rcWnd.right - rcWnd.left) != lpImeL->xCompWi) {
} else if ((rcWnd.bottom - rcWnd.top) != lpImeL->yCompHi) {
} else {
return;
}
SetWindowPos(hCompWnd, NULL,
0, 0, lpImeL->xCompWi, lpImeL->yCompHi,
SWP_NOACTIVATE|SWP_NOMOVE|SWP_NOZORDER);
if (lpImeL->nRevMaxKey >= lpImeL->nMaxKey) {
nMaxKey = lpImeL->nRevMaxKey;
} else {
nMaxKey = lpImeL->nMaxKey;
}
SetWindowLong(hCompWnd, UI_MOVE_XY, nMaxKey);
// if (lpImeL->fdwModeConfig & MODE_CONFIG_OFF_CARET_UI) {
// return;
// }
hCandWnd = GetCandWnd(hUIWnd);
if (!hCandWnd) {
return;
}
hIMC = (HIMC)GetWindowLongPtr(hUIWnd, IMMGWLP_IMC);
if (!hIMC) {
return;
}
lpIMC = (LPINPUTCONTEXT)ImmLockIMC(hIMC);
if (!lpIMC) {
return;
}
CalcCandPos((LPPOINT)&rcWnd);
ImmUnlockIMC(hIMC);
SetWindowPos(hCandWnd, NULL,
rcWnd.left, rcWnd.top,
0, 0, SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOZORDER);
return;
}
/**********************************************************************/
/* ShowUI() */
/**********************************************************************/
void PASCAL ShowUI( // show the sub windows
HWND hUIWnd,
int nShowCmd)
{
HIMC hIMC;
LPINPUTCONTEXT lpIMC;
LPPRIVCONTEXT lpImcP;
HGLOBAL hUIPrivate;
LPUIPRIV lpUIPrivate;
if (nShowCmd == SW_HIDE) {
} else if (!(hIMC = (HIMC)GetWindowLongPtr(hUIWnd, IMMGWLP_IMC))) {
nShowCmd = SW_HIDE;
} else if (!(lpIMC = (LPINPUTCONTEXT)ImmLockIMC(hIMC))) {
nShowCmd = SW_HIDE;
} else if (!(lpImcP = (LPPRIVCONTEXT)ImmLockIMCC(lpIMC->hPrivate))) {
ImmUnlockIMC(hIMC);
nShowCmd = SW_HIDE;
} else {
}
if (nShowCmd == SW_HIDE) {
ShowStatus(
hUIWnd, nShowCmd);
ShowComp(
hUIWnd, nShowCmd);
ShowCand(
hUIWnd, nShowCmd);
ShowSoftKbd(hUIWnd, nShowCmd);
return;
}
hUIPrivate = (HGLOBAL)GetWindowLongPtr(hUIWnd, IMMGWLP_PRIVATE);
if (!hUIPrivate) { // can not darw status window
goto ShowUIUnlockIMCC;
}
lpUIPrivate = (LPUIPRIV)GlobalLock(hUIPrivate);
if (!lpUIPrivate) { // can not draw status window
goto ShowUIUnlockIMCC;
}
if( /*(lpUIPrivate->fdwSetContext & ISC_SHOWUICOMPOSITIONWINDOW)&& */
(lpImcP->fdwImeMsg & MSG_ALREADY_START)
&& (step_mode &1)){
if (lpUIPrivate->hCompWnd) {
if ((UINT)GetWindowLong(lpUIPrivate->hCompWnd, UI_MOVE_XY) !=
lpImeL->nRevMaxKey) {
ChangeCompositionSize(hUIWnd);
}
if (lpUIPrivate->nShowCompCmd != SW_HIDE) {
// some time the WM_NCPAINT is eaten by the app
// RedrawWindow(lpUIPrivate->hCompWnd, NULL, NULL,
// RDW_FRAME|RDW_INVALIDATE|RDW_ERASE);
}
SendMessage(lpUIPrivate->hCompWnd, WM_IME_NOTIFY,
IMN_SETCOMPOSITIONWINDOW, 0);
if (lpUIPrivate->nShowCompCmd == SW_HIDE) {
ShowComp(hUIWnd, nShowCmd);
}
} else {
StartComp(hUIWnd);
}
} else if (lpUIPrivate->nShowCompCmd == SW_HIDE) {
} else {
ShowComp(hUIWnd, SW_HIDE);
}
if ((lpUIPrivate->fdwSetContext & ISC_SHOWUICANDIDATEWINDOW) &&
(lpImcP->fdwImeMsg & MSG_ALREADY_OPEN)&&(step_mode == 1)) {
if (lpUIPrivate->hCandWnd) {
if (lpUIPrivate->nShowCandCmd != SW_HIDE) {
// some time the WM_NCPAINT is eaten by the app
RedrawWindow(lpUIPrivate->hCandWnd, NULL, NULL,
RDW_FRAME|RDW_INVALIDATE|RDW_ERASE);
}
SendMessage(lpUIPrivate->hCandWnd, WM_IME_NOTIFY,
IMN_SETCANDIDATEPOS, 0x0001);
if (lpUIPrivate->nShowCandCmd == SW_HIDE) {
ShowCand(hUIWnd, nShowCmd);
}
} else {
OpenCand(hUIWnd);
}
} else if (lpUIPrivate->nShowCandCmd == SW_HIDE) {
} else {
ShowCand(hUIWnd, SW_HIDE);
}
if (lpIMC->fdwInit & INIT_SENTENCE) {
// app set the sentence mode so we should not change it
// with the configure option set by end user
} else if (lpImeL->fdwModeConfig & MODE_CONFIG_PREDICT) {
if ((WORD)lpIMC->fdwSentence != IME_SMODE_PHRASEPREDICT) {
DWORD fdwSentence;
fdwSentence = lpIMC->fdwSentence;
*(LPUNAWORD)&fdwSentence = IME_SMODE_PHRASEPREDICT;
ImmSetConversionStatus(hIMC, lpIMC->fdwConversion, fdwSentence);
}
} else {
if ((WORD)lpIMC->fdwSentence == IME_SMODE_PHRASEPREDICT) {
DWORD fdwSentence;
fdwSentence = lpIMC->fdwSentence;
*(LPUNAWORD)&fdwSentence = IME_SMODE_NONE;
ImmSetConversionStatus(hIMC, lpIMC->fdwConversion, fdwSentence);
}
}
if (lpUIPrivate->fdwSetContext & ISC_OPEN_STATUS_WINDOW) {
if (!lpUIPrivate->hStatusWnd) {
OpenStatus(hUIWnd);
}
if (lpUIPrivate->nShowStatusCmd != SW_HIDE) {
// some time the WM_NCPAINT is eaten by the app
RedrawWindow(lpUIPrivate->hStatusWnd, NULL, NULL,
RDW_FRAME|RDW_INVALIDATE|RDW_ERASE);
}
SendMessage(lpUIPrivate->hStatusWnd, WM_IME_NOTIFY,
IMN_SETSTATUSWINDOWPOS, 0);
if (lpUIPrivate->nShowStatusCmd == SW_HIDE) {
ShowStatus(hUIWnd, nShowCmd);
}
else // add for bug 34131, a-zhanw, 1996-4-15
ShowStatus(hUIWnd, nShowCmd);
} else if (lpUIPrivate->hStatusWnd)
DestroyWindow(lpUIPrivate->hStatusWnd);
if (!lpIMC->fOpen) {
if (lpUIPrivate->nShowCompCmd != SW_HIDE) {
ShowSoftKbd(hUIWnd, SW_HIDE);
}
} else if ((lpUIPrivate->fdwSetContext & ISC_SHOW_SOFTKBD) &&
(lpIMC->fdwConversion & IME_CMODE_SOFTKBD)) {
if (!lpUIPrivate->hSoftKbdWnd) {
UpdateSoftKbd(hUIWnd);
} else if ((UINT)SendMessage(lpUIPrivate->hSoftKbdWnd,
WM_IME_CONTROL, IMC_GETSOFTKBDSUBTYPE, 0) !=
lpImeL->nReadLayout) {
UpdateSoftKbd(hUIWnd);
} else if (lpUIPrivate->nShowSoftKbdCmd == SW_HIDE) {
ShowSoftKbd(hUIWnd, nShowCmd);
} else if (lpUIPrivate->hIMC != hIMC) {
UpdateSoftKbd(hUIWnd);
} else {
RedrawWindow(lpUIPrivate->hSoftKbdWnd, NULL, NULL,
RDW_FRAME|RDW_INVALIDATE);
}
} else if (lpUIPrivate->nShowSoftKbdCmd == SW_HIDE) {
} else if (lpUIPrivate->fdwSetContext & ISC_OPEN_STATUS_WINDOW) {
lpUIPrivate->fdwSetContext |= ISC_HIDE_SOFTKBD;
ShowSoftKbd(hUIWnd, SW_HIDE);
} else {
ShowSoftKbd(hUIWnd, SW_HIDE);
}
// we switch to this hIMC
lpUIPrivate->hIMC = hIMC;
GlobalUnlock(hUIPrivate);
ShowUIUnlockIMCC:
ImmUnlockIMCC(lpIMC->hPrivate);
ImmUnlockIMC(hIMC);
return;
}
/**********************************************************************/
/* MoveCompCand() */
/**********************************************************************/
void PASCAL MoveCompCand( // show the sub windows
HWND hUIWnd)
{
HIMC hIMC;
LPINPUTCONTEXT lpIMC;
LPPRIVCONTEXT lpImcP;
if (!(hIMC = (HIMC)GetWindowLongPtr(hUIWnd, IMMGWLP_IMC)))
return;
if (!(lpIMC = (LPINPUTCONTEXT)ImmLockIMC(hIMC)))
return ;
if (!(lpImcP = (LPPRIVCONTEXT)ImmLockIMCC(lpIMC->hPrivate))) {
ImmUnlockIMC(hIMC);
return ;
}
{
HGLOBAL hUIPrivate;
LPUIPRIV lpUIPrivate;
hUIPrivate = (HGLOBAL)GetWindowLongPtr(hUIWnd, IMMGWLP_PRIVATE);
if (!hUIPrivate) { // Oh! Oh!
return;
}
lpUIPrivate = (LPUIPRIV)GlobalLock(hUIPrivate);
if (!lpUIPrivate) { // Oh! Oh!
return;
}
// composition window need to be destroyed
if (lpUIPrivate->hCandWnd) {
if (lpImcP->fdwImeMsg & MSG_ALREADY_OPEN)
MoveWindow(lpUIPrivate->hCandWnd,
lpImeL->ptDefCand.x,
lpImeL->ptDefCand.y,
sImeG.xCandWi,
sImeG.yCandHi,
TRUE);
}
// candidate window need to be destroyed
if (lpUIPrivate->hCompWnd) {
if (lpImcP->fdwImeMsg & MSG_ALREADY_START)
MoveWindow(
lpUIPrivate->hCompWnd,
lpImeL->ptDefComp.x,
lpImeL->ptDefComp.y,
lpImeL->xCompWi,lpImeL->yCompHi,
TRUE );
}
GlobalUnlock(hUIPrivate);
}
ImmUnlockIMCC(lpIMC->hPrivate);
ImmUnlockIMC(hIMC);
return;
}
/**********************************************************************/
/* CheckSoftKbdPosition() */
/**********************************************************************/
void PASCAL CheckSoftKbdPosition(
LPUIPRIV lpUIPrivate,
LPINPUTCONTEXT lpIMC)
{
UINT fPortionBits = 0;
UINT fPortionTest;
int xPortion, yPortion, nPortion;
RECT rcWnd;
// portion of dispaly
// 0 1
// 2 3
if (lpUIPrivate->hCompWnd) {
GetWindowRect(lpUIPrivate->hCompWnd, &rcWnd);
if (rcWnd.left > sImeG.rcWorkArea.right / 2) {
xPortion = 1;
} else {
xPortion = 0;
}
if (rcWnd.top > sImeG.rcWorkArea.bottom / 2) {
yPortion = 1;
} else {
yPortion = 0;
}
fPortionBits |= 0x0001 << (yPortion * 2 + xPortion);
}
if (lpUIPrivate->hStatusWnd) {
GetWindowRect(lpUIPrivate->hStatusWnd, &rcWnd);
if (rcWnd.left > sImeG.rcWorkArea.right / 2) {
xPortion = 1;
} else {
xPortion = 0;
}
if (rcWnd.top > sImeG.rcWorkArea.bottom / 2) {
yPortion = 1;
} else {
yPortion = 0;
}
fPortionBits |= 0x0001 << (yPortion * 2 + xPortion);
}
GetWindowRect(lpUIPrivate->hSoftKbdWnd, &rcWnd);
// start from portion 3
for (nPortion = 3, fPortionTest = 0x0008; fPortionTest;
nPortion--, fPortionTest >>= 1) {
if (fPortionTest & fPortionBits) {
// someone here!
continue;
}
if (nPortion % 2) {
lpIMC->ptSoftKbdPos.x = sImeG.rcWorkArea.right -
(rcWnd.right - rcWnd.left) - UI_MARGIN;
} else {
lpIMC->ptSoftKbdPos.x = sImeG.rcWorkArea.left;
}
if (nPortion / 2) {
lpIMC->ptSoftKbdPos.y = sImeG.rcWorkArea.bottom -
(rcWnd.bottom - rcWnd.top) - UI_MARGIN;
} else {
lpIMC->ptSoftKbdPos.y = sImeG.rcWorkArea.top;
}
lpIMC->fdwInit |= INIT_SOFTKBDPOS;
break;
}
return;
}
// sdk #6
/**********************************************************************/
/* SetSoftKbdData() */
/**********************************************************************/
void PASCAL SetSoftKbdData(
HWND hSoftKbdWnd,
LPINPUTCONTEXT lpIMC)
{
int i;
LPSOFTKBDDATA lpSoftKbdData;
LPPRIVCONTEXT lpImcP;
HGLOBAL hsSoftKbdData;
lpImcP = (LPPRIVCONTEXT)ImmLockIMCC(lpIMC->hPrivate);
if (!lpImcP) {
return;
}
hsSoftKbdData = GlobalAlloc(GHND, sizeof(SOFTKBDDATA) * 2);
if (!hsSoftKbdData) {
ImmUnlockIMCC(lpIMC->hPrivate);
return;
}
lpSoftKbdData = (LPSOFTKBDDATA)GlobalLock(hsSoftKbdData);
if (!lpSoftKbdData) { // can not draw soft keyboard window
ImmUnlockIMCC(lpIMC->hPrivate);
return;
}
lpSoftKbdData->uCount = 2;
for (i = 0; i < 48; i++) {
BYTE bVirtKey;
bVirtKey = VirtKey48Map[i];
if (!bVirtKey) {
continue;
}
{
WORD CHIByte, CLOByte;
CHIByte = SKLayout[lpImeL->dwSKWant][i*2] & 0x00ff;
CLOByte = SKLayout[lpImeL->dwSKWant][i*2 + 1] & 0x00ff;
lpSoftKbdData->wCode[0][bVirtKey] = (CHIByte << 8) | CLOByte;
CHIByte = SKLayoutS[lpImeL->dwSKWant][i*2] & 0x00ff;
CLOByte = SKLayoutS[lpImeL->dwSKWant][i*2 + 1] & 0x00ff;
lpSoftKbdData->wCode[1][bVirtKey] = (CHIByte << 8) | CLOByte;
}
}
SendMessage(hSoftKbdWnd, WM_IME_CONTROL, IMC_SETSOFTKBDDATA,
(LPARAM)lpSoftKbdData);
GlobalUnlock(hsSoftKbdData);
// free storage for UI settings
GlobalFree(hsSoftKbdData);
ImmUnlockIMCC(lpIMC->hPrivate);
return;
}
//sdk #7
/**********************************************************************/
/* UpdateSoftKbd() */
/**********************************************************************/
void PASCAL UpdateSoftKbd(
HWND hUIWnd)
{
HIMC hIMC;
LPINPUTCONTEXT lpIMC;
HGLOBAL hUIPrivate;
LPUIPRIV lpUIPrivate;
LPPRIVCONTEXT lpImcP;
hIMC = (HIMC)GetWindowLongPtr(hUIWnd, IMMGWLP_IMC);
if (!hIMC) {
return;
}
lpIMC = (LPINPUTCONTEXT)ImmLockIMC(hIMC);
if (!lpIMC) {
return;
}
lpImcP = (LPPRIVCONTEXT)ImmLockIMCC(lpIMC->hPrivate);
if (!lpImcP){
ImmUnlockIMC(hIMC);
return;
}
hUIPrivate = (HGLOBAL)GetWindowLongPtr(hUIWnd, IMMGWLP_PRIVATE);
if (!hUIPrivate) { // can not darw soft keyboard window
ImmUnlockIMCC(lpIMC->hPrivate);
ImmUnlockIMC(hIMC);
return;
}
lpUIPrivate = (LPUIPRIV)GlobalLock(hUIPrivate);
if (!lpUIPrivate) { // can not draw soft keyboard window
ImmUnlockIMCC(lpIMC->hPrivate);
ImmUnlockIMC(hIMC);
return;
}
if (!(lpIMC->fdwConversion & IME_CMODE_SOFTKBD)) {
if (lpUIPrivate->hSoftKbdWnd) {
ImmDestroySoftKeyboard(lpUIPrivate->hSoftKbdWnd);
lpImcP->hSoftKbdWnd = NULL;
lpUIPrivate->hSoftKbdWnd = NULL;
}
lpUIPrivate->nShowSoftKbdCmd = SW_HIDE;
lpImcP->nShowSoftKbdCmd = SW_HIDE;
} else if (!lpIMC->fOpen) {
if (lpUIPrivate->nShowSoftKbdCmd != SW_HIDE) {
ShowSoftKbd(hUIWnd, SW_HIDE/*, NULL*/);
}
} else {
if (!lpUIPrivate->hSoftKbdWnd) {
// create soft keyboard
lpUIPrivate->hSoftKbdWnd =
ImmCreateSoftKeyboard(SOFTKEYBOARD_TYPE_C1, hUIWnd,
0, 0);
lpImcP->hSoftKbdWnd = lpUIPrivate->hSoftKbdWnd;
}
if (!(lpIMC->fdwInit & INIT_SOFTKBDPOS)) {
CheckSoftKbdPosition(lpUIPrivate, lpIMC);
}
SetSoftKbdData(lpUIPrivate->hSoftKbdWnd, lpIMC);
if (lpUIPrivate->nShowSoftKbdCmd == SW_HIDE) {
SetWindowPos(lpUIPrivate->hSoftKbdWnd, NULL,
lpIMC->ptSoftKbdPos.x, lpIMC->ptSoftKbdPos.y,
0, 0, SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOZORDER);
// only show, if the application want to show it
//if (lpUIPrivate->fdwSetContext & ISC_SHOW_SOFTKBD) { //zst 95/9/28
ShowSoftKbd(hUIWnd, SW_SHOWNOACTIVATE/*, lpImcP*/);
// } zst 95/9/28
}
}
GlobalUnlock(hUIPrivate);
ImmUnlockIMCC(lpIMC->hPrivate);
ImmUnlockIMC(hIMC);
return;
}
/**********************************************************************/
/* ShowGuideLine */
/**********************************************************************/
void PASCAL ShowGuideLine(
HWND hUIWnd)
{
HIMC hIMC;
LPINPUTCONTEXT lpIMC;
LPGUIDELINE lpGuideLine;
hIMC = (HIMC)GetWindowLongPtr(hUIWnd, IMMGWLP_IMC);
if (!hIMC) {
return;
}
lpIMC = (LPINPUTCONTEXT)ImmLockIMC(hIMC);
if (!lpIMC) {
return;
}
lpGuideLine = (LPGUIDELINE)ImmLockIMCC(lpIMC->hGuideLine);
if (!lpGuideLine) {
} else if (lpGuideLine->dwLevel == GL_LEVEL_ERROR) {
MessageBeep((UINT)-1);
MessageBeep((UINT)-1);
} else if (lpGuideLine->dwLevel == GL_LEVEL_WARNING) {
MessageBeep((UINT)-1);
} else {
}
ImmUnlockIMCC(lpIMC->hGuideLine);
ImmUnlockIMC(hIMC);
return;
}
/**********************************************************************/
/* StatusWndMsg() */
/**********************************************************************/
void PASCAL StatusWndMsg( // set the show hide state and
HWND hUIWnd,
BOOL fOn)
{
HGLOBAL hUIPrivate;
HIMC hIMC;
HWND hStatusWnd;
register LPUIPRIV lpUIPrivate;
hUIPrivate = (HGLOBAL)GetWindowLongPtr(hUIWnd, IMMGWLP_PRIVATE);
if (!hUIPrivate) {
return;
}
lpUIPrivate = (LPUIPRIV)GlobalLock(hUIPrivate);
if (!lpUIPrivate) {
return;
}
hIMC = (HIMC)GetWindowLongPtr(hUIWnd, IMMGWLP_IMC);
if(!hIMC){
return;
}
if (fOn) {
lpUIPrivate->fdwSetContext |= ISC_OPEN_STATUS_WINDOW;
if (!lpUIPrivate->hStatusWnd) {
OpenStatus(
hUIWnd);
}
} else {
lpUIPrivate->fdwSetContext &= ~(ISC_OPEN_STATUS_WINDOW);
}
hStatusWnd = lpUIPrivate->hStatusWnd;
GlobalUnlock(hUIPrivate);
if (!hStatusWnd) {
return;
}
if (!fOn) {
register DWORD fdwSetContext;
/*
fdwSetContext = lpUIPrivate->fdwSetContext &
(ISC_SHOWUICOMPOSITIONWINDOW|ISC_HIDE_COMP_WINDOW);
if (fdwSetContext == ISC_HIDE_COMP_WINDOW) {
ShowComp(
hUIWnd, SW_HIDE);
}
fdwSetContext = lpUIPrivate->fdwSetContext &
(ISC_SHOWUICANDIDATEWINDOW|ISC_HIDE_CAND_WINDOW);
if (fdwSetContext == ISC_HIDE_CAND_WINDOW) {
ShowCand(
hUIWnd, SW_HIDE);
}
fdwSetContext = lpUIPrivate->fdwSetContext &
(ISC_SHOW_SOFTKBD|ISC_HIDE_SOFTKBD);
if (fdwSetContext == ISC_HIDE_SOFTKBD) {
lpUIPrivate->fdwSetContext &= ~(ISC_HIDE_SOFTKBD);
ShowSoftKbd(hUIWnd, SW_HIDE, NULL);
}
ShowStatus(
hUIWnd, SW_HIDE);
*/
ShowComp(hUIWnd, SW_HIDE);
ShowCand(hUIWnd, SW_HIDE);
// ShowSoftKbd(hUIWnd, SW_HIDE);
fdwSetContext = lpUIPrivate->fdwSetContext &
(ISC_SHOW_SOFTKBD|ISC_HIDE_SOFTKBD);
if (fdwSetContext == ISC_HIDE_SOFTKBD) {
lpUIPrivate->fdwSetContext &= ~(ISC_HIDE_SOFTKBD);
ShowSoftKbd(hUIWnd, SW_HIDE);
}
ShowStatus(hUIWnd, SW_HIDE);
} else if (hIMC) {
ShowStatus(
hUIWnd, SW_SHOWNOACTIVATE);
} else {
ShowStatus(
hUIWnd, SW_HIDE);
}
return;
}
/**********************************************************************/
/* NotifyUI() */
/**********************************************************************/
void PASCAL NotifyUI(
HWND hUIWnd,
WPARAM wParam,
LPARAM lParam)
{
HWND hStatusWnd;
switch (wParam) {
case IMN_OPENSTATUSWINDOW:
StatusWndMsg(hUIWnd, TRUE);
break;
case IMN_CLOSESTATUSWINDOW:
StatusWndMsg(hUIWnd, FALSE);
break;
case IMN_OPENCANDIDATE:
if (lParam & 0x00000001) {
OpenCand(hUIWnd);
}
break;
case IMN_CHANGECANDIDATE:
if (lParam & 0x00000001) {
HWND hCandWnd;
HDC hDC;
hCandWnd = GetCandWnd(hUIWnd);
if (!hCandWnd) {
return;
}
hDC = GetDC(hCandWnd);
UpdateCandWindow2(hCandWnd, hDC);
ReleaseDC(hCandWnd, hDC);
}
break;
case IMN_CLOSECANDIDATE:
if (lParam & 0x00000001) {
CloseCand(hUIWnd);
}
break;
case IMN_SETSENTENCEMODE:
break;
case IMN_SETCONVERSIONMODE:
case IMN_SETOPENSTATUS:
hStatusWnd = GetStatusWnd(hUIWnd);
if (hStatusWnd) {
InvalidateRect(hStatusWnd, &sImeG.rcStatusText, FALSE);
UpdateWindow(hStatusWnd);
}
break;
case IMN_SETCOMPOSITIONFONT:
// we are not going to change font, but an IME can do this if it want
break;
case IMN_SETCOMPOSITIONWINDOW:
SetCompWindow(hUIWnd);
break;
case IMN_SETSTATUSWINDOWPOS:
// SetStatusWindowPos(hUIWnd);
SetStatusWindowPos(GetStatusWnd(hUIWnd));
break;
case IMN_GUIDELINE:
ShowGuideLine(hUIWnd);
break;
case IMN_PRIVATE:
switch (lParam) {
case IMN_PRIVATE_UPDATE_SOFTKBD:
UpdateSoftKbd(hUIWnd);
break;
default:
break;
}
break;
default:
break;
}
return;
}
/**********************************************************************/
/* SetContext() */
/**********************************************************************/
void PASCAL SetContext( // the context activated/deactivated
HWND hUIWnd,
BOOL fOn,
LPARAM lShowUI)
{
HGLOBAL hUIPrivate;
register LPUIPRIV lpUIPrivate;
hUIPrivate = (HGLOBAL)GetWindowLongPtr(hUIWnd, IMMGWLP_PRIVATE);
if (!hUIPrivate) {
return;
}
lpUIPrivate = (LPUIPRIV)GlobalLock(hUIPrivate);
if (!lpUIPrivate) {
return;
}
if (fOn) {
HIMC hIMC;
LPINPUTCONTEXT lpIMC;
if(!sImeG.Prop)
InitUserSetting();
ReInitIme2(lpUIPrivate->hStatusWnd, lpImeL->wImeStyle);
lpUIPrivate->fdwSetContext = (lpUIPrivate->fdwSetContext &
~ISC_SHOWUIALL) | ((DWORD)lShowUI & ISC_SHOWUIALL) | ISC_SHOW_SOFTKBD;
hIMC = (HIMC)GetWindowLongPtr(hUIWnd, IMMGWLP_IMC);
if (!hIMC) {
goto SetCxtUnlockUIPriv;
}
lpIMC = (LPINPUTCONTEXT)ImmLockIMC(hIMC);
if (!lpIMC) {
goto SetCxtUnlockUIPriv;
}
if (lpIMC->cfCandForm[0].dwIndex != 0) {
lpIMC->cfCandForm[0].dwStyle = CFS_DEFAULT;
}
ImmUnlockIMC(hIMC);
} else {
lpUIPrivate->fdwSetContext &= ~ISC_SETCONTEXT_UI;
}
if(fOn){
BOOL x;
HIMC hIMC;
LPINPUTCONTEXT lpIMC;
hIMC = (HIMC)GetWindowLongPtr(hUIWnd, IMMGWLP_IMC);
if (!hIMC) {
goto SetCxtUnlockUIPriv;
}
lpIMC = (LPINPUTCONTEXT)ImmLockIMC(hIMC);
if (!lpIMC)
goto SetCxtUnlockUIPriv;
x = GetKeyState(VK_CAPITAL)&1;
if(!x && (lpIMC->fdwConversion & IME_CMODE_NOCONVERSION)){
lpIMC->fdwConversion = lpIMC->fdwConversion & (~IME_CMODE_NOCONVERSION)|IME_CMODE_NATIVE;
}
if(x && (lpIMC->fdwConversion & IME_CMODE_NATIVE)){
lpIMC->fdwConversion = lpIMC->fdwConversion & (~IME_CMODE_NATIVE) |(IME_CMODE_NOCONVERSION);
InitCvtPara();
}
//lpIMC->fdwConversion = IME_CMODE_NOCONVERSION;
ImmUnlockIMC(hIMC);
}
SetCxtUnlockUIPriv:
GlobalUnlock(hUIPrivate);
UIPaint(hUIWnd);
// PostMessage(hUIWnd, WM_PAINT, 0, 0); //zl3
return;
}
/**********************************************************************/
/* GetConversionMode() */
/* Return Value : */
/* the conversion mode */
/**********************************************************************/
LRESULT PASCAL GetConversionMode(
HWND hUIWnd)
{
HIMC hIMC;
LPINPUTCONTEXT lpIMC;
DWORD fdwConversion;
hIMC = (HIMC)GetWindowLongPtr(hUIWnd, IMMGWLP_IMC);
if (!hIMC) {
return (LRESULT)NULL;
}
lpIMC = (LPINPUTCONTEXT)ImmLockIMC(hIMC);
if (!lpIMC) {
return (LRESULT)NULL;
}
fdwConversion = lpIMC->fdwConversion;
ImmUnlockIMC(hIMC);
return (LRESULT)fdwConversion;
}
/**********************************************************************/
/* SetConversionMode() */
/* Return Value : */
/* NULL - successful, else - failure */
/**********************************************************************/
LRESULT PASCAL SetConversionMode( // set conversion mode
HWND hUIWnd,
DWORD dwNewConvMode)
{
HIMC hIMC;
DWORD dwOldConvMode, fdwOldSentence;
hIMC = (HIMC)GetWindowLongPtr(hUIWnd, IMMGWLP_IMC);
if (!hIMC) {
return (1L);
}
if (!ImmGetConversionStatus(hIMC, &dwOldConvMode, &fdwOldSentence))
return (LRESULT)(1L);
return (LRESULT)!ImmSetConversionStatus(hIMC, dwNewConvMode,
fdwOldSentence);
}
/**********************************************************************/
/* GetSentenceMode() */
/* Return Value : */
/* the sentence mode */
/**********************************************************************/
LRESULT PASCAL GetSentenceMode(
HWND hUIWnd)
{
HIMC hIMC;
LPINPUTCONTEXT lpIMC;
DWORD fdwSentence;
hIMC = (HIMC)GetWindowLongPtr(hUIWnd, IMMGWLP_IMC);
if (!hIMC) {
return (LRESULT)NULL;
}
lpIMC = (LPINPUTCONTEXT)ImmLockIMC(hIMC);
if (!lpIMC) {
return (LRESULT)NULL;
}
fdwSentence = lpIMC->fdwSentence;
ImmUnlockIMC(hIMC);
return (LRESULT)fdwSentence;
}
/**********************************************************************/
/* SetSentenceMode() */
/* Return Value : */
/* NULL - successful, else - failure */
/**********************************************************************/
LRESULT PASCAL SetSentenceMode( // set the sentence mode
HWND hUIWnd,
DWORD dwNewSentence)
{
HIMC hIMC;
DWORD dwOldConvMode, fdwOldSentence;
hIMC = (HIMC)GetWindowLongPtr(hUIWnd, IMMGWLP_IMC);
if (!hIMC) {
return (1L);
}
if (!ImmGetConversionStatus(hIMC, &dwOldConvMode, &fdwOldSentence)) {
return (LRESULT)(1L);
}
return (LRESULT)!ImmSetConversionStatus(hIMC, dwOldConvMode,
dwNewSentence);
}
/**********************************************************************/
/* GetOpenStatus() */
/* Return Value : */
/* the open status */
/**********************************************************************/
LRESULT PASCAL GetOpenStatus(
HWND hUIWnd)
{
HIMC hIMC;
LPINPUTCONTEXT lpIMC;
BOOL fOpen;
hIMC = (HIMC)GetWindowLongPtr(hUIWnd, IMMGWLP_IMC);
if (!hIMC) {
return (LRESULT)NULL;
}
lpIMC = (LPINPUTCONTEXT)ImmLockIMC(hIMC);
if (!lpIMC) {
return (LRESULT)NULL;
}
fOpen = (BOOL)lpIMC->fOpen;
ImmUnlockIMC(hIMC);
return (LRESULT)fOpen;
}
/**********************************************************************/
/* SetOpenStatus() */
/* Return Value : */
/* NULL - successful, else - failure */
/**********************************************************************/
LRESULT PASCAL SetOpenStatus( // set open/close status
HWND hUIWnd,
BOOL fNewOpenStatus)
{
HIMC hIMC;
hIMC = (HIMC)GetWindowLongPtr(hUIWnd, IMMGWLP_IMC);
if (!hIMC) {
return (1L);
}
return (LRESULT)!ImmSetOpenStatus(hIMC, fNewOpenStatus);
}
/**********************************************************************/
/* SetCompFont() */
/**********************************************************************/
LRESULT PASCAL SetCompFont(
HWND hUIWnd,
LPLOGFONT lplfFont)
{
HIMC hIMC;
hIMC = (HIMC)GetWindowLongPtr(hUIWnd, IMMGWLP_IMC);
if (!hIMC) {
return (1L);
}
return (LRESULT)!ImmSetCompositionFont(hIMC, lplfFont);
}
/**********************************************************************/
/* GetCompWindow() */
/**********************************************************************/
LRESULT PASCAL GetCompWindow(
HWND hUIWnd,
LPCOMPOSITIONFORM lpCompForm)
{
HWND hCompWnd;
RECT rcCompWnd;
hCompWnd = GetCompWnd(hUIWnd);
if (!hCompWnd) {
return (1L);
}
if (!GetWindowRect(hCompWnd, &rcCompWnd)) {
return (1L);
}
lpCompForm->dwStyle = CFS_POINT|CFS_RECT;
lpCompForm->ptCurrentPos = *(LPPOINT)&rcCompWnd;
lpCompForm->rcArea = rcCompWnd;
return (0L);
}
/**********************************************************************/
/* SelectIME() */
/**********************************************************************/
void PASCAL SelectIME( // switch IMEs
HWND hUIWnd,
BOOL fSelect)
{
if (!fSelect) {
ShowUI(hUIWnd, SW_HIDE);
} else {
HIMC hIMC;
LPINPUTCONTEXT lpIMC;
hIMC = (HIMC)GetWindowLongPtr(hUIWnd, IMMGWLP_IMC);
if (!hIMC) {
MessageBeep((UINT)-1);
return;
}
if (!(lpIMC = (LPINPUTCONTEXT)ImmLockIMC(hIMC))) {
MessageBeep((UINT)-1);
return;
}
if(GetKeyState(VK_CAPITAL)&1){
lpIMC->fdwConversion |= IME_CMODE_NOCONVERSION;
lpIMC->fdwConversion &= ~IME_CMODE_NATIVE;
cap_mode = 1;
}else{
lpIMC->fdwConversion |= IME_CMODE_NATIVE;
lpIMC->fdwConversion &= ~IME_CMODE_NOCONVERSION;
cap_mode = 0;
}
ImmUnlockIMC(hIMC);
UpdateSoftKbd(hUIWnd);
ShowUI(hUIWnd, SW_SHOWNOACTIVATE);
}
return;
}
/**********************************************************************/
/* ToggleUI() */
/**********************************************************************/
/*
void PASCAL ToggleUI(
HWND hUIWnd)
{
HGLOBAL hUIPrivate;
LPUIPRIV lpUIPrivate;
DWORD fdwFlag;
HIMC hIMC;
LPINPUTCONTEXT lpIMC;
LPPRIVCONTEXT lpImcP;
HWND hDestroyWnd;
hUIPrivate = (HGLOBAL)GetWindowLongPtr(hUIWnd, IMMGWLP_PRIVATE);
if (!hUIPrivate) {
return;
}
lpUIPrivate = (LPUIPRIV)GlobalLock(hUIPrivate);
if (!lpUIPrivate) {
return;
}
//if (lpUIPrivate->fdwSetContext & ISC_OFF_CARET_UI) {
// if (lpImeL->fdwModeConfig & MODE_CONFIG_OFF_CARET_UI) {
// goto ToggleUIOvr;
// } else {
// fdwFlag = 0;
// }
//} else {
// if (lpImeL->fdwModeConfig & MODE_CONFIG_OFF_CARET_UI) {
// fdwFlag = ISC_OFF_CARET_UI;
// } else {
// goto ToggleUIOvr;
// }
//}
hIMC = (HIMC)GetWindowLongPtr(hUIWnd, IMMGWLP_IMC);
if (!hIMC) {
goto ToggleUIOvr;
}
lpIMC = (LPINPUTCONTEXT)ImmLockIMC(hIMC);
if (!lpIMC) {
goto ToggleUIOvr;
}
lpImcP = (LPPRIVCONTEXT)ImmLockIMCC(lpIMC->hPrivate);
if (!lpImcP) {
goto CreateUIOvr;
}
if (fdwFlag & ISC_OFF_CARET_UI) {
lpUIPrivate->fdwSetContext |= (ISC_OFF_CARET_UI);
} else {
lpUIPrivate->fdwSetContext &= ~(ISC_OFF_CARET_UI);
}
hDestroyWnd = NULL;
// we need to dsetroy status first because lpUIPrivate->hStatusWnd
// may be NULL out in OffCreat UI destroy time
if (lpUIPrivate->hStatusWnd) {
if (lpUIPrivate->hStatusWnd != hDestroyWnd) {
hDestroyWnd = lpUIPrivate->hStatusWnd;
DestroyWindow(lpUIPrivate->hStatusWnd);
}
lpUIPrivate->hStatusWnd = NULL;
}
// destroy all off caret UI
if (lpUIPrivate->hCompWnd) {
if (lpUIPrivate->hCompWnd != hDestroyWnd) {
hDestroyWnd = lpUIPrivate->hCompWnd;
DestroyWindow(lpUIPrivate->hCompWnd);
}
lpUIPrivate->hCompWnd = NULL;
lpUIPrivate->nShowCompCmd = SW_HIDE;
}
if (lpUIPrivate->hCandWnd) {
if (lpUIPrivate->hCandWnd != hDestroyWnd) {
hDestroyWnd = lpUIPrivate->hCandWnd;
DestroyWindow(lpUIPrivate->hCandWnd);
}
lpUIPrivate->hCandWnd = NULL;
lpUIPrivate->nShowCandCmd = SW_HIDE;
}
if (lpUIPrivate->fdwSetContext & ISC_OPEN_STATUS_WINDOW) {
OpenStatus(hUIWnd);
}
if (!(lpUIPrivate->fdwSetContext & ISC_SHOWUICOMPOSITIONWINDOW)) {
} else if (lpImcP->fdwImeMsg & MSG_ALREADY_START) {
StartComp(hUIWnd);
} else {
}
if (!(lpUIPrivate->fdwSetContext & ISC_SHOWUICANDIDATEWINDOW)) {
} else if (lpImcP->fdwImeMsg & MSG_ALREADY_OPEN) {
if (!(fdwFlag & ISC_OFF_CARET_UI)) {
NotifyIME(hIMC, NI_SETCANDIDATE_PAGESIZE, 0, CANDPERPAGE);
}
OpenCand(hUIWnd);
} else {
}
ImmUnlockIMCC(lpIMC->hPrivate);
CreateUIOvr:
ImmUnlockIMC(hIMC);
ToggleUIOvr:
GlobalUnlock(hUIPrivate);
return;
}
*/
/**********************************************************************/
/* UIPaint() */
/**********************************************************************/
LRESULT PASCAL UIPaint(
HWND hUIWnd)
{
PAINTSTRUCT ps;
MSG sMsg;
HGLOBAL hUIPrivate;
LPUIPRIV lpUIPrivate;
// for safety
BeginPaint(hUIWnd, &ps);
EndPaint(hUIWnd, &ps);
// some application will not remove the WM_PAINT messages
PeekMessage(&sMsg, hUIWnd, WM_PAINT, WM_PAINT, PM_REMOVE|PM_NOYIELD);
hUIPrivate = (HGLOBAL)GetWindowLongPtr(hUIWnd, IMMGWLP_PRIVATE);
if (!hUIPrivate) {
return (0L);
}
lpUIPrivate = (LPUIPRIV)GlobalLock(hUIPrivate);
if (!lpUIPrivate) {
return (0L);
}
if (lpUIPrivate->fdwSetContext & ISC_SHOW_UI_ALL) { //ZL1
//if (lpUIPrivate->fdwSetContext & ISC_SETCONTEXT_UI) {
/*
if (lpUIPrivate->fdwSetContext & ISC_OFF_CARET_UI) {
if (!(lpImeL->fdwModeConfig & MODE_CONFIG_OFF_CARET_UI)){
ToggleUI(hUIWnd);
}
} else {
if (lpImeL->fdwModeConfig & MODE_CONFIG_OFF_CARET_UI) {
ToggleUI(hUIWnd);
}
}
*/
ShowUI(hUIWnd, SW_SHOWNOACTIVATE);
} else {
ShowUI(hUIWnd, SW_HIDE);
}
GlobalUnlock(hUIPrivate);
return (0L);
}
/**********************************************************************/
/* UIWndProc() */
/**********************************************************************/
LRESULT CALLBACK UIWndProc( // maybe not good but this UI
// window also is composition window
HWND hUIWnd,
UINT uMsg,
WPARAM wParam,
LPARAM lParam)
{
lpImeL->TempUIWnd = hUIWnd ;
switch (uMsg) {
case WM_NEW_WORD:
// DefNewNow = 0;
UpdateUser();
break;
case WM_CREATE:
CreateUIWindow(hUIWnd);
break;
case WM_DESTROY:
DestroyUIWindow(hUIWnd);
break;
case WM_IME_STARTCOMPOSITION:
// you can create a window as the composition window here
StartComp(hUIWnd);
if (lParam==0x6699)
show_char(NULL,0);
break;
case WM_IME_COMPOSITION:
if (lParam & GCS_RESULTSTR) {
MoveDefaultCompPosition(hUIWnd);
}
UpdateCompWindow(hUIWnd);
break;
case WM_IME_ENDCOMPOSITION:
// you can destroy the composition window here
EndComp(hUIWnd);
break;
case WM_IME_NOTIFY:
NotifyUI(hUIWnd, wParam, lParam);
break;
case WM_IME_SETCONTEXT:
SetContext(hUIWnd, (BOOL)wParam, lParam);
break;
case WM_IME_CONTROL:
switch (wParam) {
case IMC_SETCONVERSIONMODE:
return SetConversionMode(hUIWnd, (DWORD)lParam);
case IMC_SETSENTENCEMODE:
return SetSentenceMode(hUIWnd, (DWORD)lParam);
case IMC_SETOPENSTATUS:
return SetOpenStatus(hUIWnd, (BOOL)lParam);
case IMC_GETCANDIDATEPOS:
return GetCandPos(hUIWnd,(LPCANDIDATEFORM)lParam);
return (1L); // not implemented yet
case IMC_SETCANDIDATEPOS:
return SetCandPosition(hUIWnd, (LPCANDIDATEFORM)lParam);
case IMC_GETCOMPOSITIONFONT:
return (1L); // not implemented yet
case IMC_SETCOMPOSITIONFONT:
return SetCompFont(hUIWnd, (LPLOGFONT)lParam);
case IMC_GETCOMPOSITIONWINDOW:
return GetCompWindow(hUIWnd, (LPCOMPOSITIONFORM)lParam);
case IMC_SETCOMPOSITIONWINDOW:
{
HIMC hIMC;
hIMC = (HIMC)GetWindowLongPtr(hUIWnd, IMMGWLP_IMC);
if (!hIMC) {
return (1L);
}
return (LRESULT)!ImmSetCompositionWindow(hIMC,
(LPCOMPOSITIONFORM)lParam);
}
return (1L);
case IMC_GETSTATUSWINDOWPOS:
{
HWND hStatusWnd;
RECT rcStatusWnd;
LPARAM lParam;
hStatusWnd = GetStatusWnd(hUIWnd);
if (!hStatusWnd) {
return (0L); // fail, return (0, 0)?
}
if (!GetWindowRect(hStatusWnd, &rcStatusWnd)) {
return (0L); // fail, return (0, 0)?
}
lParam = MAKELRESULT(rcStatusWnd.left, rcStatusWnd.right);
return (lParam);
}
return (0L);
case IMC_SETSTATUSWINDOWPOS:
{
HIMC hIMC;
POINT ptPos;
ptPos.x = ((LPPOINTS)&lParam)->x;
ptPos.y = ((LPPOINTS)&lParam)->y;
hIMC = (HIMC)GetWindowLongPtr(hUIWnd, IMMGWLP_IMC);
if (!hIMC) {
return (1L);
}
return ImmSetStatusWindowPos(hIMC, &ptPos);
}
return (1L);
default:
return (1L);
}
break;
case WM_IME_COMPOSITIONFULL:
return (0L);
case WM_IME_SELECT:
SelectIME(hUIWnd, (BOOL)wParam);
return (0L);
case WM_MOUSEACTIVATE:
return (MA_NOACTIVATE);
case WM_PAINT:
UIPaint(hUIWnd);
return 0L; //ZL2
default:
return DefWindowProc(hUIWnd, uMsg, wParam, lParam);
}
return (0L);
}
/**********************************************************************/
/* DrawFrameBorder() */
/**********************************************************************/
void PASCAL DrawFrameBorder( // border of IME
HDC hDC,
HWND hWnd) // window of IME
{
RECT rcWnd;
int xWi, yHi;
GetWindowRect(hWnd, &rcWnd);
xWi = rcWnd.right - rcWnd.left;
yHi = rcWnd.bottom - rcWnd.top;
// 1, ->
PatBlt(hDC, 0, 0, xWi, 1, WHITENESS);
// 1, v
PatBlt(hDC, 0, 0, 1, yHi, WHITENESS);
// 1, _>
PatBlt(hDC, 0, yHi, xWi, -1, BLACKNESS);
// 1, v
PatBlt(hDC, xWi, 0, -1, yHi, BLACKNESS);
xWi -= 2;
yHi -= 2;
SelectObject(hDC, GetStockObject(LTGRAY_BRUSH));
// 2, ->
PatBlt(hDC, 1, 1, xWi, 1, PATCOPY);
// 2, v
PatBlt(hDC, 1, 1, 1, yHi, PATCOPY);
// 2, v
PatBlt(hDC, xWi + 1, 1, -1, yHi, PATCOPY);
SelectObject(hDC, GetStockObject(GRAY_BRUSH));
// 2, _>
PatBlt(hDC, 1, yHi + 1, xWi, -1, PATCOPY);
xWi -= 2;
yHi -= 2;
// 3, ->
PatBlt(hDC, 2, 2, xWi, 1, PATCOPY);
// 3, v
PatBlt(hDC, 2, 2, 1, yHi, PATCOPY);
// 3, v
PatBlt(hDC, xWi + 2, 3, -1, yHi - 1, WHITENESS);
SelectObject(hDC, GetStockObject(LTGRAY_BRUSH));
// 3, _>
PatBlt(hDC, 2, yHi + 2, xWi, -1, PATCOPY);
SelectObject(hDC, GetStockObject(GRAY_BRUSH));
xWi -= 2;
yHi -= 2;
// 4, ->
PatBlt(hDC, 3, 3, xWi, 1, PATCOPY);
// 4, v
PatBlt(hDC, 3, 3, 1, yHi, PATCOPY);
SelectObject(hDC, GetStockObject(LTGRAY_BRUSH));
// 4, v
PatBlt(hDC, xWi + 3, 4, -1, yHi - 1, PATCOPY);
// 4, _>
PatBlt(hDC, 3, yHi + 3, xWi, -1, WHITENESS);
return;
}
/**********************************************************************/
/* GetCompWnd */
/* Return Value : */
/* window handle of composition */
/**********************************************************************/
HWND PASCAL GetCompWnd(
HWND hUIWnd) // UI window
{
HGLOBAL hUIPrivate;
LPUIPRIV lpUIPrivate;
HWND hCompWnd;
hUIPrivate = (HGLOBAL)GetWindowLongPtr(hUIWnd, IMMGWLP_PRIVATE);
if (!hUIPrivate) { // can not darw candidate window
return (HWND)NULL;
}
lpUIPrivate = (LPUIPRIV)GlobalLock(hUIPrivate);
if (!lpUIPrivate) { // can not draw candidate window
return (HWND)NULL;
}
hCompWnd = lpUIPrivate->hCompWnd;
GlobalUnlock(hUIPrivate);
return (hCompWnd);
}
/**********************************************************************/
/* GetNearCaretPosition() */
/**********************************************************************/
void PASCAL GetNearCaretPosition( // decide a near caret position according
// to the caret position
LPPOINT lpptFont,
UINT uEsc,
UINT uRot,
LPPOINT lpptCaret,
LPPOINT lpptNearCaret,
BOOL fFlags)
{
LONG lFontSize;
LONG xWidthUI, yHeightUI, xBorder, yBorder;
if ((uEsc + uRot) & 0x0001) {
lFontSize = lpptFont->x;
} else {
lFontSize = lpptFont->y;
}
if (fFlags & NEAR_CARET_CANDIDATE) {
xWidthUI = sImeG.xCandWi;
yHeightUI = sImeG.yCandHi;
xBorder = sImeG.cxCandBorder;
yBorder = sImeG.cyCandBorder;
} else {
xWidthUI = lpImeL->xCompWi;
yHeightUI = lpImeL->yCompHi;
xBorder = lpImeL->cxCompBorder;
yBorder = lpImeL->cyCompBorder;
}
if (fFlags & NEAR_CARET_FIRST_TIME) {
lpptNearCaret->x = lpptCaret->x +
lFontSize * ncUIEsc[uEsc].iLogFontFacX +
sImeG.iPara * ncUIEsc[uEsc].iParaFacX +
sImeG.iPerp * ncUIEsc[uEsc].iPerpFacX;
if (ptInputEsc[uEsc].x >= 0) {
lpptNearCaret->x += xBorder * 2;
} else {
lpptNearCaret->x -= xWidthUI - xBorder * 2;
}
lpptNearCaret->y = lpptCaret->y +
lFontSize * ncUIEsc[uEsc].iLogFontFacY +
sImeG.iPara * ncUIEsc[uEsc].iParaFacY +
sImeG.iPerp * ncUIEsc[uEsc].iPerpFacY;
if (ptInputEsc[uEsc].y >= 0) {
lpptNearCaret->y += yBorder * 2;
} else {
lpptNearCaret->y -= yHeightUI - yBorder * 2;
}
} else {
lpptNearCaret->x = lpptCaret->x +
lFontSize * ncAltUIEsc[uEsc].iLogFontFacX +
sImeG.iPara * ncAltUIEsc[uEsc].iParaFacX +
sImeG.iPerp * ncAltUIEsc[uEsc].iPerpFacX;
if (ptAltInputEsc[uEsc].x >= 0) {
lpptNearCaret->x += xBorder * 2;
} else {
lpptNearCaret->x -= xWidthUI - xBorder * 2;
}
lpptNearCaret->y = lpptCaret->y +
lFontSize * ncAltUIEsc[uEsc].iLogFontFacY +
sImeG.iPara * ncAltUIEsc[uEsc].iParaFacY +
sImeG.iPerp * ncAltUIEsc[uEsc].iPerpFacY;
if (ptAltInputEsc[uEsc].y >= 0) {
lpptNearCaret->y += yBorder * 2;
} else {
lpptNearCaret->y -= yHeightUI - yBorder * 2;
}
}
if (lpptNearCaret->x < sImeG.rcWorkArea.left) {
lpptNearCaret->x = sImeG.rcWorkArea.left;
} else if (lpptNearCaret->x + xWidthUI > sImeG.rcWorkArea.right) {
lpptNearCaret->x = sImeG.rcWorkArea.right - xWidthUI;
} else {
}
if (lpptNearCaret->y < sImeG.rcWorkArea.top) {
lpptNearCaret->y = sImeG.rcWorkArea.top;
} else if (lpptNearCaret->y + yHeightUI > sImeG.rcWorkArea.bottom) {
lpptNearCaret->y = sImeG.rcWorkArea.bottom - yHeightUI;
} else {
}
return;
}
/**********************************************************************/
/* FitInLazyOperation() */
/* Return Value : */
/* TRUE or FALSE */
/**********************************************************************/
BOOL PASCAL FitInLazyOperation( // fit in lazy operation or not
LPPOINT lpptOrg,
LPPOINT lpptNearCaret, // the suggested near caret position
LPRECT lprcInputRect,
UINT uEsc)
{
POINT ptDelta, ptTol;
RECT rcUIRect, rcInterRect;
ptDelta.x = lpptOrg->x - lpptNearCaret->x;
ptDelta.x = (ptDelta.x >= 0) ? ptDelta.x : -ptDelta.x;
ptTol.x = sImeG.iParaTol * ncUIEsc[uEsc].iParaFacX +
sImeG.iPerpTol * ncUIEsc[uEsc].iPerpFacX;
ptTol.x = (ptTol.x >= 0) ? ptTol.x : -ptTol.x;
if (ptDelta.x > ptTol.x) {
return (FALSE);
}
ptDelta.y = lpptOrg->y - lpptNearCaret->y;
ptDelta.y = (ptDelta.y >= 0) ? ptDelta.y : -ptDelta.y;
ptTol.y = sImeG.iParaTol * ncUIEsc[uEsc].iParaFacY +
sImeG.iPerpTol * ncUIEsc[uEsc].iPerpFacY;
ptTol.y = (ptTol.y >= 0) ? ptTol.y : -ptTol.y;
if (ptDelta.y > ptTol.y) {
return (FALSE);
}
// build up the UI rectangle (composition window)
rcUIRect.left = lpptOrg->x;
rcUIRect.top = lpptOrg->y;
rcUIRect.right = rcUIRect.left + lpImeL->xCompWi;
rcUIRect.bottom = rcUIRect.top + lpImeL->yCompHi;
if (IntersectRect(&rcInterRect, &rcUIRect, lprcInputRect)) {
return (FALSE);
}
return (TRUE);
}
/**********************************************************************/
/* AdjustCompPosition() */
/* Return Value : */
/* the position of composition window is changed or not */
/**********************************************************************/
BOOL PASCAL AdjustCompPosition( // IME adjust position according to
// composition form
LPINPUTCONTEXT lpIMC,
LPPOINT lpptOrg, // original composition window
// and final position
LPPOINT lpptNew) // new expect position
{
POINT ptNearCaret, ptOldNearCaret, ptCompWnd;
UINT uEsc, uRot;
RECT rcUIRect, rcInputRect, rcInterRect;
POINT ptFont;
// we need to adjust according to font attribute
if (lpIMC->lfFont.A.lfWidth > 0) {
ptFont.x = lpIMC->lfFont.A.lfWidth * 2;
} else if (lpIMC->lfFont.A.lfWidth < 0) {
ptFont.x = -lpIMC->lfFont.A.lfWidth * 2;
} else if (lpIMC->lfFont.A.lfHeight > 0) {
ptFont.x = lpIMC->lfFont.A.lfHeight;
} else if (lpIMC->lfFont.A.lfHeight < 0) {
ptFont.x = -lpIMC->lfFont.A.lfHeight;
} else {
ptFont.x = lpImeL->yCompHi;
}
if (lpIMC->lfFont.A.lfHeight > 0) {
ptFont.y = lpIMC->lfFont.A.lfHeight;
} else if (lpIMC->lfFont.A.lfHeight < 0) {
ptFont.y = -lpIMC->lfFont.A.lfHeight;
} else {
ptFont.y = ptFont.x;
}
// if the input char is too big, we don't need to consider so much
if (ptFont.x > lpImeL->yCompHi * 8) {
ptFont.x = lpImeL->yCompHi * 8;
}
if (ptFont.y > lpImeL->yCompHi * 8) {
ptFont.y = lpImeL->yCompHi * 8;
}
if (ptFont.x < sImeG.xChiCharWi) {
ptFont.x = sImeG.xChiCharWi;
}
if (ptFont.y < sImeG.yChiCharHi) {
ptFont.y = sImeG.yChiCharHi;
}
// -450 to 450 index 0
// 450 to 1350 index 1
// 1350 to 2250 index 2
// 2250 to 3150 index 3
uEsc = (UINT)((lpIMC->lfFont.A.lfEscapement + 450) / 900 % 4);
uRot = (UINT)((lpIMC->lfFont.A.lfOrientation + 450) / 900 % 4);
// decide the input rectangle
rcInputRect.left = lpptNew->x;
rcInputRect.top = lpptNew->y;
// build up an input rectangle from escapemment
rcInputRect.right = rcInputRect.left + ptFont.x * ptInputEsc[uEsc].x;
rcInputRect.bottom = rcInputRect.top + ptFont.y * ptInputEsc[uEsc].y;
// be a normal rectangle, not a negative rectangle
if (rcInputRect.left > rcInputRect.right) {
LONG tmp;
tmp = rcInputRect.left;
rcInputRect.left = rcInputRect.right;
rcInputRect.right = tmp;
}
if (rcInputRect.top > rcInputRect.bottom) {
LONG tmp;
tmp = rcInputRect.top;
rcInputRect.top = rcInputRect.bottom;
rcInputRect.bottom = tmp;
}
GetNearCaretPosition(
&ptFont, uEsc, uRot, lpptNew, &ptNearCaret, NEAR_CARET_FIRST_TIME);
// 1st, use the adjust point
// build up the new suggest UI rectangle (composition window)
rcUIRect.left = ptNearCaret.x;
rcUIRect.top = ptNearCaret.y;
rcUIRect.right = rcUIRect.left + lpImeL->xCompWi;
rcUIRect.bottom = rcUIRect.top + lpImeL->yCompHi;
ptCompWnd = ptOldNearCaret = ptNearCaret;
// OK, no intersect between the near caret position and input char
if (IntersectRect(&rcInterRect, &rcUIRect, &rcInputRect)) {
} else if (CalcCandPos(
/*lpIMC,*/ &ptCompWnd)) {
// can not fit the candidate window
} else if (FitInLazyOperation(
lpptOrg, &ptNearCaret, &rcInputRect, uEsc)) {
// happy ending!!!, don't chaqge position
return (FALSE);
} else {
*lpptOrg = ptNearCaret;
// happy ending!!
return (TRUE);
}
// unhappy case
GetNearCaretPosition(&ptFont, uEsc, uRot, lpptNew, &ptNearCaret, 0);
// build up the new suggest UI rectangle (composition window)
rcUIRect.left = ptNearCaret.x;
rcUIRect.top = ptNearCaret.y;
rcUIRect.right = rcUIRect.left + lpImeL->xCompWi;
rcUIRect.bottom = rcUIRect.top + lpImeL->yCompHi;
ptCompWnd = ptNearCaret;
// OK, no intersect between the adjust position and input char
if (IntersectRect(&rcInterRect, &rcUIRect, &rcInputRect)) {
} else if (CalcCandPos(
/*lpIMC,*/ &ptCompWnd)) {
// can not fit the candidate window
} else if (FitInLazyOperation(
lpptOrg, &ptNearCaret, &rcInputRect, uEsc)) {
// happy ending!!!, don't chaqge position
return (FALSE);
} else {
*lpptOrg = ptNearCaret;
// happy ending!!
return (TRUE);
}
// unhappy ending! :-(
*lpptOrg = ptOldNearCaret;
return (TRUE);
}
/**********************************************************************/
/* AdjustCompPosition() */
/* Return Value : */
/* the position of composition window is changed or not */
/**********************************************************************/
/*BOOL PASCAL AdjustCompPosition( // IME adjust position according to
// composition form
LPINPUTCONTEXT lpIMC,
LPPOINT lpptOrg, // original composition window
// and final position
LPPOINT lpptNew) // new expect position
{
POINT ptAdjust, ptDelta;
UINT uEsc;
RECT rcUIRect, rcInputRect, rcInterRect;
POINT ptFont;
ptAdjust.x = lpptNew->x;
ptAdjust.y = lpptNew->y;
// we need to adjust according to font attribute
if (lpIMC->lfFont.A.lfWidth > 0) {
ptFont.x = lpIMC->lfFont.A.lfWidth;
} else if (lpIMC->lfFont.A.lfWidth == 0) {
ptFont.x = lpImeL->yCompHi;
} else {
ptFont.x = -lpIMC->lfFont.A.lfWidth;
}
if (lpIMC->lfFont.A.lfHeight > 0) {
ptFont.y = lpIMC->lfFont.A.lfHeight;
} else if (lpIMC->lfFont.A.lfWidth == 0) {
ptFont.y = lpImeL->yCompHi;
} else {
ptFont.y = -lpIMC->lfFont.A.lfHeight;
}
// if the input char is too big, we don't need to consider so much
if (ptFont.x > lpImeL->yCompHi * 8) {
ptFont.x = lpImeL->yCompHi * 8;
}
if (ptFont.y > lpImeL->yCompHi * 8) {
ptFont.y = lpImeL->yCompHi * 8;
}
if (ptFont.x < sImeG.xChiCharWi) {
ptFont.x = sImeG.xChiCharWi;
}
if (ptFont.y < sImeG.yChiCharHi) {
ptFont.y = sImeG.yChiCharHi;
}
// -450 to 450 index 0
// 450 to 1350 index 1
// 1350 to 2250 index 2
// 2250 to 3150 index 3
uEsc = (UINT)((lpIMC->lfFont.A.lfEscapement + 450) / 900 % 4);
// find the location after IME do an adjustment
ptAdjust.x = ptAdjust.x + sImeG.iPara * ncUIEsc[uEsc].iParaFacX +
sImeG.iPerp * ncUIEsc[uEsc].iPerpFacX;
ptAdjust.y = ptAdjust.y + ptFont.y * ncUIEsc[uEsc].iLogFontFac +
sImeG.iPara * ncUIEsc[uEsc].iParaFacY +
sImeG.iPerp * ncUIEsc[uEsc].iPerpFacY - lpImeL->cyCompBorder;
// Is the current location within tolerance?
ptDelta.x = lpptOrg->x - ptAdjust.x;
ptDelta.y = lpptOrg->y - ptAdjust.y;
ptDelta.x = (ptDelta.x > 0) ? ptDelta.x : -ptDelta.x;
ptDelta.y = (ptDelta.y > 0) ? ptDelta.y : -ptDelta.y;
// decide the input rectangle
rcInputRect.left = lpptNew->x;
rcInputRect.top = lpptNew->y;
// build up an input rectangle from escapemment
rcInputRect.right = rcInputRect.left + ptFont.x * ptInputEsc[uEsc].x;
rcInputRect.bottom = rcInputRect.top + ptFont.y * ptInputEsc[uEsc].y;
// be a normal rectangle, not a negative rectangle
if (rcInputRect.left > rcInputRect.right) {
int tmp;
tmp = rcInputRect.left;
rcInputRect.left = rcInputRect.right;
rcInputRect.right = tmp;
}
if (rcInputRect.top > rcInputRect.bottom) {
int tmp;
tmp = rcInputRect.top;
rcInputRect.top = rcInputRect.bottom;
rcInputRect.bottom = tmp;
}
// build up the UI rectangle (composition window)
rcUIRect.left = lpptOrg->x;
rcUIRect.top = lpptOrg->y;
rcUIRect.right = rcUIRect.left + lpImeL->xCompWi;
rcUIRect.bottom = rcUIRect.top + lpImeL->yCompHi;
// will it within lazy operation range (tolerance)
if (ptDelta.x > sImeG.iParaTol * ncUIEsc[uEsc].iParaFacX +
sImeG.iPerpTol * ncUIEsc[uEsc].iPerpFacX) {
} else if (ptDelta.y > sImeG.iParaTol * ncUIEsc[uEsc].iParaFacY +
sImeG.iPerpTol * ncUIEsc[uEsc].iPerpFacY) {
} else if (IntersectRect(&rcInterRect, &rcUIRect, &rcInputRect)) {
// If there are intersection, we need to fix that
} else {
// happy ending!!!, don't chaqge position
return (FALSE);
}
ptAdjust.x -= lpImeL->cxCompBorder;
ptAdjust.y -= lpImeL->cyCompBorder;
// lazy guy, move!
// 1st, use the adjust point
if (ptAdjust.x < sImeG.rcWorkArea.left) {
ptAdjust.x = sImeG.rcWorkArea.left;
} else if (ptAdjust.x + lpImeL->xCompWi > sImeG.rcWorkArea.right) {
ptAdjust.x = sImeG.rcWorkArea.right - lpImeL->xCompWi;
}
if (ptAdjust.y < sImeG.rcWorkArea.top) {
ptAdjust.y = sImeG.rcWorkArea.top;
} else if (ptAdjust.y + lpImeL->yCompHi > sImeG.rcWorkArea.bottom) {
ptAdjust.y = sImeG.rcWorkArea.bottom - lpImeL->yCompHi;
}
// build up the new suggest UI rectangle (composition window)
rcUIRect.left = ptAdjust.x;
rcUIRect.top = ptAdjust.y;
rcUIRect.right = rcUIRect.left + lpImeL->xCompWi;
rcUIRect.bottom = rcUIRect.top + lpImeL->yCompHi;
// OK, no intersect between the adjust position and input char
if (!IntersectRect(&rcInterRect, &rcUIRect, &rcInputRect)) {
// happy ending!!
lpptOrg->x = ptAdjust.x;
lpptOrg->y = ptAdjust.y;
return (TRUE);
}
// unhappy case
ptAdjust.x = lpptNew->x;
ptAdjust.y = lpptNew->y;
ClientToScreen((HWND)lpIMC->hWnd, &ptAdjust);
// IME do another adjustment
ptAdjust.x = ptAdjust.x + ptFont.x * ncUIEsc[uEsc].iParaFacX -
sImeG.iPara * ncUIEsc[uEsc].iParaFacX +
sImeG.iPerp * ncUIEsc[uEsc].iPerpFacX - lpImeL->cxCompBorder;
ptAdjust.y = ptAdjust.y + ptFont.y * ncUIEsc[uEsc].iLogFontFac -
sImeG.iPara * ncUIEsc[uEsc].iParaFacY +
sImeG.iPerp * ncUIEsc[uEsc].iPerpFacY - lpImeL->cyCompBorder;
if (ptAdjust.x < sImeG.rcWorkArea.left) {
ptAdjust.x = sImeG.rcWorkArea.left;
} else if (ptAdjust.x + lpImeL->xCompWi > sImeG.rcWorkArea.right) {
ptAdjust.x = sImeG.rcWorkArea.right - lpImeL->xCompWi;
}
if (ptAdjust.y < sImeG.rcWorkArea.top) {
ptAdjust.y = sImeG.rcWorkArea.top;
} else if (ptAdjust.y + lpImeL->yCompHi > sImeG.rcWorkArea.bottom) {
ptAdjust.y = sImeG.rcWorkArea.bottom - lpImeL->yCompHi;
}
// unhappy ending! :-(
lpptOrg->x = ptAdjust.x;
lpptOrg->y = ptAdjust.y;
return (TRUE);
} */
/**********************************************************************/
/* SetCompPosFix() */
/**********************************************************************/
void PASCAL SetCompPosFix( // set the composition window position
HWND hCompWnd,
LPINPUTCONTEXT lpIMC)
{
POINT ptWnd;
BOOL fChange = FALSE;
HGLOBAL hUIPrivate;
LPUIPRIV lpUIPrivate;
// the client coordinate position (0, 0) of composition window
ptWnd.x = 0;
ptWnd.y = 0;
// convert to screen coordinates
ClientToScreen(hCompWnd, &ptWnd);
ptWnd.x -= lpImeL->cxCompBorder;
ptWnd.y -= lpImeL->cyCompBorder;
if (ptWnd.x != lpImeL->ptDefComp.x) {
ptWnd.x = lpImeL->ptDefComp.x;
fChange = TRUE;
}
if (ptWnd.y != lpImeL->ptDefComp.y) {
ptWnd.y = lpImeL->ptDefComp.y;
fChange = TRUE;
}
if (!fChange ) return;
//## 8
SetWindowPos(hCompWnd, NULL,
ptWnd.x, ptWnd.y,
lpImeL->xCompWi, lpImeL->yCompHi, SWP_NOACTIVATE/*|SWP_NOSIZE*/|SWP_NOZORDER);
hUIPrivate = (HGLOBAL)GetWindowLongPtr(GetWindow(hCompWnd, GW_OWNER),
IMMGWLP_PRIVATE);
if (!hUIPrivate) {
return;
}
lpUIPrivate = (LPUIPRIV)GlobalLock(hUIPrivate);
if (!lpUIPrivate) {
return;
}
if (!lpUIPrivate->hCandWnd) {
GlobalUnlock(hUIPrivate);
return;
}
// decide the position of candidate window by UI's position
// ##1
SetWindowPos(lpUIPrivate->hCandWnd, NULL,
lpImeL->ptDefCand.x, lpImeL->ptDefCand.y ,
sImeG.xCandWi,sImeG.yCandHi, SWP_NOACTIVATE|/*SWP_NOSIZE|*/SWP_NOZORDER);
GlobalUnlock(hUIPrivate);
return;
}
/**********************************************************************/
/* SetCompPosition() */
/**********************************************************************/
void PASCAL SetCompPosition( // set the composition window position
HWND hCompWnd,
LPINPUTCONTEXT lpIMC)
{
POINT ptWnd, ptCaret;
BOOL fChange = FALSE;
HGLOBAL hUIPrivate;
LPUIPRIV lpUIPrivate;
HWND hCandWnd;
if (lpImeL->wImeStyle == IME_APRS_FIX){
SetCompPosFix(hCompWnd, lpIMC);
return;
}
// the client coordinate position (0, 0) of composition window
ptWnd.x = 0;
ptWnd.y = 0;
// convert to screen coordinates
ClientToScreen(hCompWnd, &ptWnd);
ptWnd.x -= lpImeL->cxCompBorder;
ptWnd.y -= lpImeL->cyCompBorder;
if (lpIMC->cfCompForm.dwStyle & CFS_FORCE_POSITION) {
POINT ptNew; // new position of UI
ptNew.x = lpIMC->cfCompForm.ptCurrentPos.x;
ptNew.y = lpIMC->cfCompForm.ptCurrentPos.y;
ClientToScreen((HWND)lpIMC->hWnd, &ptNew);
if (ptWnd.x != ptNew.x) {
ptWnd.x = ptNew.x;
fChange = TRUE;
}
if (ptWnd.y != ptNew.y) {
ptWnd.y = ptNew.y;
fChange = TRUE;
}
if (fChange) {
ptWnd.x -= lpImeL->cxCompBorder;
ptWnd.y -= lpImeL->cyCompBorder;
}
} else if (lpIMC->cfCompForm.dwStyle != CFS_DEFAULT) {
// aplication tell us the position, we need to adjust
POINT ptNew; // new position of UI
ptNew.x = lpIMC->cfCompForm.ptCurrentPos.x;
ptNew.y = lpIMC->cfCompForm.ptCurrentPos.y;
ClientToScreen((HWND)lpIMC->hWnd, &ptNew);
fChange = AdjustCompPosition(lpIMC, &ptWnd, &ptNew);
} else {
POINT ptNew; // new position of UI
/*ptNew.x = lpIMC->ptStatusWndPos.x + sImeG.xStatusWi + UI_MARGIN;
if (ptNew.x + lpImeL->xCompWi > sImeG.rcWorkArea.right) {
ptNew.x = lpIMC->ptStatusWndPos.x -
lpImeL->xCompWi - lpImeL->cxCompBorder * 2 -
UI_MARGIN;
}
ptNew.y = sImeG.rcWorkArea.bottom - lpImeL->yCompHi;// - 2 * UI_MARGIN ;*/
ptNew.x = lpImeL->ptZLComp.x;
ptNew.y = lpImeL->ptZLComp.y;
if (ptWnd.x != ptNew.x) {
ptWnd.x = ptNew.x;
fChange = TRUE;
}
if (ptWnd.y != ptNew.y) {
ptWnd.y = ptNew.y;
fChange = TRUE;
}
if (fChange) {
lpIMC->cfCompForm.ptCurrentPos = ptNew;
ScreenToClient(lpIMC->hWnd, &lpIMC->cfCompForm.ptCurrentPos);
}
}
/*if (GetCaretPos(&ptCaret)) {
// application don't set position, OK we need to near caret
ClientToScreen(lpIMC->hWnd, &ptCaret);
fChange = AdjustCompPosition(lpIMC, &ptWnd, &ptCaret);
} else {
// no caret information!
if (ptWnd.x != lpImeL->ptDefComp.x) {
ptWnd.x = lpImeL->ptDefComp.y;
fChange = TRUE;
}
if (ptWnd.y != lpImeL->ptDefComp.x) {
ptWnd.y = lpImeL->ptDefComp.y;
fChange = TRUE;
}
if (ptWnd.x != lpImeL->ptDefComp.x) {
ptWnd.x =lpIMC->ptStatusWndPos.x + sImeG.TextLen+8;//lpImeL->ptDefComp.y;
fChange = TRUE;
}
if (ptWnd.y != lpImeL->ptDefComp.x) {
ptWnd.y =lpIMC->ptStatusWndPos.
} y ;//lpImeL->ptDefComp.y;
fChange = TRUE;
} */
if (!(fChange|CandWndChange)) {
return;
}
CandWndChange = 0;
// ##2
if(TypeOfOutMsg & COMP_NEEDS_END){
CloseCand(GetWindow(hCompWnd, GW_OWNER));
EndComp(GetWindow(hCompWnd, GW_OWNER));
//CloseCand(GetWindow(hCandWnd, GW_OWNER));
TypeOfOutMsg = TypeOfOutMsg & ~(COMP_NEEDS_END);
}
SetWindowPos(hCompWnd, NULL,
ptWnd.x, ptWnd.y,
lpImeL->xCompWi,lpImeL->yCompHi, SWP_NOACTIVATE/*|SWP_NOSIZE*/|SWP_NOZORDER);
hUIPrivate = (HGLOBAL)GetWindowLongPtr(GetWindow(hCompWnd, GW_OWNER),
IMMGWLP_PRIVATE);
if (!hUIPrivate) {
return;
}
lpUIPrivate = (LPUIPRIV)GlobalLock(hUIPrivate);
if (!lpUIPrivate) {
return;
}
if (!lpUIPrivate->hCandWnd) {
GlobalUnlock(hUIPrivate);
return;
}
// decide the position of candidate window by UI's position
CalcCandPos(&ptWnd);
//##3
SetWindowPos(lpUIPrivate->hCandWnd, NULL,
ptWnd.x, ptWnd.y,
sImeG.xCandWi,sImeG.yCandHi , SWP_NOACTIVATE/*|SWP_NOSIZE*/|SWP_NOZORDER);
GlobalUnlock(hUIPrivate);
return;
}
/**********************************************************************/
/* SetCompWindow() */
/**********************************************************************/
void PASCAL SetCompWindow( // set the position of composition window
HWND hUIWnd)
{
HIMC hIMC;
LPINPUTCONTEXT lpIMC;
HWND hCompWnd;
hIMC = (HIMC)GetWindowLongPtr(hUIWnd, IMMGWLP_IMC);
if (!hIMC) {
return;
}
hCompWnd = GetCompWnd(hUIWnd);
if (!hCompWnd) {
return;
}
lpIMC = (LPINPUTCONTEXT)ImmLockIMC(hIMC);
if (!lpIMC) {
return;
}
SetCompPosition(hCompWnd, lpIMC);
ImmUnlockIMC(hIMC);
return;
}
/**********************************************************************/
/* MoveDefaultCompPosition() */
/**********************************************************************/
void PASCAL MoveDefaultCompPosition( // the default comp position
// need to near the caret
HWND hUIWnd)
{
HIMC hIMC;
LPINPUTCONTEXT lpIMC;
HWND hCompWnd;
if (lpImeL->wImeStyle == IME_APRS_FIX ) return ;
hIMC = (HIMC)GetWindowLongPtr(hUIWnd, IMMGWLP_IMC);
if (!hIMC) {
return;
}
hCompWnd = GetCompWnd(hUIWnd);
if (!hCompWnd) {
return;
}
lpIMC = (LPINPUTCONTEXT)ImmLockIMC(hIMC);
if (!lpIMC) {
return;
}
if (lpIMC->cfCompForm.dwStyle & CFS_FORCE_POSITION) {
} else if (!lpIMC->hPrivate) {
} else {
LPPRIVCONTEXT lpImcP;
lpImcP = (LPPRIVCONTEXT)ImmLockIMCC(lpIMC->hPrivate);
if (!lpImcP) {
} else if (lpImcP->fdwImeMsg & MSG_IMN_COMPOSITIONPOS) {
} else {
lpImcP->fdwImeMsg |= MSG_IMN_COMPOSITIONPOS;
// lpImcP->fdwGcsFlag =lpImcP->fdwGcsFlag &~( GCS_RESULTREAD|GCS_RESULTSTR);
// if(sImeG.InbxProc){
/* sImeG.InbxProc = 0;*///}
// else{
// GenerateMessage(hIMC, lpIMC, lpImcP);//} //CHG4
}
ImmUnlockIMCC(lpIMC->hPrivate);
}
ImmUnlockIMC(hIMC);
return;
}
/**********************************************************************/
/* ShowComp() */
/**********************************************************************/
void PASCAL ShowComp( // Show the composition window
HWND hUIWnd,
int nShowCompCmd)
{
HGLOBAL hUIPrivate;
LPUIPRIV lpUIPrivate;
// show or hid the UI window
hUIPrivate = (HGLOBAL)GetWindowLongPtr(hUIWnd, IMMGWLP_PRIVATE);
if (!hUIPrivate) {
return;
}
lpUIPrivate = (LPUIPRIV)GlobalLock(hUIPrivate);
if (!lpUIPrivate) {
return;
}
if (!lpUIPrivate->hCompWnd) {
// not in show candidate window mode
} else if (lpUIPrivate->nShowCompCmd != nShowCompCmd) {
ShowWindow(lpUIPrivate->hCompWnd, nShowCompCmd);
lpUIPrivate->nShowCompCmd = nShowCompCmd;
} else {
}
GlobalUnlock(hUIPrivate);
return;
}
/**********************************************************************/
/* StartComp() */
/**********************************************************************/
void PASCAL StartComp(
HWND hUIWnd)
{
HIMC hIMC;
HGLOBAL hUIPrivate;
LPINPUTCONTEXT lpIMC;
LPUIPRIV lpUIPrivate;
hIMC = (HIMC)GetWindowLongPtr(hUIWnd, IMMGWLP_IMC);
if (!hIMC) { // Oh! Oh!
return;
}
hUIPrivate = (HGLOBAL)GetWindowLongPtr(hUIWnd, IMMGWLP_PRIVATE);
if (!hUIPrivate) { // Oh! Oh!
return;
}
lpIMC = (LPINPUTCONTEXT)ImmLockIMC(hIMC);
if (!lpIMC) { // Oh! Oh!
return;
}
lpUIPrivate = (LPUIPRIV)GlobalLock(hUIPrivate);
if (!lpUIPrivate) { // can not draw composition window
ImmUnlockIMC(hIMC);
return;
}
lpUIPrivate->fdwSetContext |= ISC_SHOWUICOMPOSITIONWINDOW;//zl 95.9.14
if (!lpUIPrivate->hCompWnd) {
lpUIPrivate->hCompWnd = CreateWindowEx(
/* WS_EX_CLIENTEDGE|WS_EX_WINDOWEDGE|WS_EX_DLGMODALFRAME|WS_EX_TOPMOST,*/
0,
szCompClassName, NULL, WS_POPUP|WS_DISABLED,//|WS_BORDER,
0, 0, lpImeL->xCompWi, lpImeL->yCompHi,
hUIWnd, (HMENU)NULL, hInst, NULL);
if ( lpUIPrivate->hCompWnd != NULL )
{
SetWindowLong(lpUIPrivate->hCompWnd, UI_MOVE_OFFSET,
WINDOW_NOT_DRAG);
SetWindowLong(lpUIPrivate->hCompWnd, UI_MOVE_XY, 0L);
}
}
// try to set the position of composition UI window near the caret
SetCompPosition(lpUIPrivate->hCompWnd, lpIMC);
ImmUnlockIMC(hIMC);
ShowComp(hUIWnd, SW_SHOWNOACTIVATE);
GlobalUnlock(hUIPrivate);
return;
}
/**********************************************************************/
/* EndComp() */
/**********************************************************************/
void PASCAL EndComp(
HWND hUIWnd)
{
HGLOBAL hUIPrivate;
LPUIPRIV lpUIPrivate;
hUIPrivate = (HGLOBAL)GetWindowLongPtr(hUIWnd, IMMGWLP_PRIVATE);
if (!hUIPrivate) { // Oh! Oh!
return;
}
lpUIPrivate = (LPUIPRIV)GlobalLock(hUIPrivate);
if (!lpUIPrivate) { // Oh! Oh!
return;
}
// hide the composition window
ShowWindow(lpUIPrivate->hCompWnd, SW_HIDE);
lpUIPrivate->nShowCompCmd = SW_HIDE;
GlobalUnlock(hUIPrivate);
return;
}
/**********************************************************************/
/* DestroyCompWindow() */
/**********************************************************************/
void PASCAL DestroyCompWindow( // destroy composition window
HWND hCompWnd)
{
HGLOBAL hUIPrivate;
LPUIPRIV lpUIPrivate;
hUIPrivate = (HGLOBAL)GetWindowLongPtr(GetWindow(hCompWnd, GW_OWNER),
IMMGWLP_PRIVATE);
if (!hUIPrivate) { // Oh! Oh!
return;
}
lpUIPrivate = (LPUIPRIV)GlobalLock(hUIPrivate);
if (!lpUIPrivate) { // Oh! Oh!
return;
}
lpUIPrivate->nShowCompCmd = SW_HIDE;
lpUIPrivate->hCompWnd = (HWND)NULL;
GlobalUnlock(hUIPrivate);
return;
}
/**********************************************************************/
/* CompSetCursor() */
/**********************************************************************/
void PASCAL CompSetCursor(
HWND hCompWnd,
LPARAM lParam)
{
POINT ptCursor;
RECT rcWnd;
if (GetWindowLong(hCompWnd, UI_MOVE_OFFSET) != WINDOW_NOT_DRAG) {
SetCursor(LoadCursor(NULL, IDC_SIZEALL));
return;
}
GetCursorPos(&ptCursor);
ScreenToClient(hCompWnd, &ptCursor);
SetCursor(LoadCursor(NULL, IDC_SIZEALL));
if (HIWORD(lParam) == WM_RBUTTONDOWN) {
SystemParametersInfo(SPI_GETWORKAREA, 0, &sImeG.rcWorkArea, 0);
return;
} else if (HIWORD(lParam) == WM_LBUTTONDOWN) {
// start dragging
SystemParametersInfo(SPI_GETWORKAREA, 0, &sImeG.rcWorkArea, 0);
} else {
return;
}
SetCapture(hCompWnd);
GetCursorPos(&ptCursor);
SetWindowLong(hCompWnd, UI_MOVE_XY,
MAKELONG(ptCursor.x, ptCursor.y));
GetWindowRect(hCompWnd, &rcWnd);
SetWindowLong(hCompWnd, UI_MOVE_OFFSET,
MAKELONG(ptCursor.x - rcWnd.left, ptCursor.y - rcWnd.top));
DrawDragBorder(hCompWnd, MAKELONG(ptCursor.x, ptCursor.y),
GetWindowLong(hCompWnd, UI_MOVE_OFFSET));
return;
}
/**********************************************************************/
/* CompButtonUp() */
/**********************************************************************/
BOOL PASCAL CompButtonUp( // finish drag, set comp window to this
// position
HWND hCompWnd)
{
LONG lTmpCursor, lTmpOffset;
POINT pt;
HWND hUIWnd;
HIMC hIMC;
LPINPUTCONTEXT lpIMC;
HWND hFocusWnd;
COMPOSITIONFORM cfCompForm;
if (GetWindowLong(hCompWnd, UI_MOVE_OFFSET) == WINDOW_NOT_DRAG) {
return (FALSE);
}
lTmpCursor = GetWindowLong(hCompWnd, UI_MOVE_XY);
pt.x = (*(LPPOINTS)&lTmpCursor).x;
pt.y = (*(LPPOINTS)&lTmpCursor).y;
// calculate the org by the offset
lTmpOffset = GetWindowLong(hCompWnd, UI_MOVE_OFFSET);
pt.x -= (*(LPPOINTS)&lTmpOffset).x;
pt.y -= (*(LPPOINTS)&lTmpOffset).y;
DrawDragBorder(hCompWnd, lTmpCursor, lTmpOffset);
SetWindowLong(hCompWnd, UI_MOVE_OFFSET, WINDOW_NOT_DRAG);
ReleaseCapture();
hUIWnd = GetWindow(hCompWnd, GW_OWNER);
hIMC = (HIMC)GetWindowLongPtr(hUIWnd, IMMGWLP_IMC);
if (!hIMC) {
return (FALSE);
}
lpIMC = (LPINPUTCONTEXT)ImmLockIMC(hIMC);
if (!lpIMC) {
return (FALSE);
}
hFocusWnd = (HWND)lpIMC->hWnd;
ImmUnlockIMC(hIMC);
if (pt.x < sImeG.rcWorkArea.left) {
pt.x = sImeG.rcWorkArea.left;
} else if (pt.x + lpImeL->xCompWi > sImeG.rcWorkArea.right) {
pt.x = sImeG.rcWorkArea.right - lpImeL->xCompWi;
}
if (pt.y < sImeG.rcWorkArea.top) {
pt.y = sImeG.rcWorkArea.top;
} else if (pt.y + lpImeL->yCompHi > sImeG.rcWorkArea.bottom) {
pt.y = sImeG.rcWorkArea.bottom - lpImeL->yCompHi;
}
ScreenToClient(hFocusWnd, &pt);
cfCompForm.dwStyle = CFS_POINT|CFS_FORCE_POSITION;
cfCompForm.ptCurrentPos.x = pt.x + lpImeL->cxCompBorder;
cfCompForm.ptCurrentPos.y = pt.y + lpImeL->cyCompBorder;
// set composition window to the new poosition
SendMessage(hUIWnd, WM_IME_CONTROL, IMC_SETCOMPOSITIONWINDOW,
(LPARAM)&cfCompForm);
return (TRUE);
}
#define SHENHUI RGB(0x80,0x80,0x80)
#define QIANHUI RGB(0xe0,0xe0,0x80)
/**********************************************************************/
/* CurMovePaint() */
/* Function: While the string is longer than the Comp Window.... */
/* keep the cursor inside the Comp Window */
/* Called: By UpdateCompWindow2 */
/**********************************************************************/
void WINAPI CurMovePaint(
HDC hDC,
LPSTR srBuffer, // the source sting that to be showed...
int StrLen) // the length of that...
{
int i,xx,yy;
//SetBkColor(hDC, QIANHUI);
if(!StrLen)
return;
for (i=0; i<StrLen; i++)
InputBuffer[i] = srBuffer[i];
xx= 0;
if (InputBuffer[0]>0xa0){
for (i =0; i<StrLen; i++){
if(InputBuffer[i]<0xa0) break;
}
yy = i;
for (i=yy; i>0; i=i-2) {
//xx =sImeG.xChiCharWi*i/2;
xx=GetText32(hDC,&InputBuffer[0],i);
if ( xx <= lpImeL->rcCompText.right-4)
break;
}
i=0;
cur_start_ps=0;
cur_start_count=0;
}else {
for (i =now_cs; i>0; i--){
yy=GetText32(hDC, &InputBuffer[i-1], 1);
if ( (xx+yy) >= (lpImeL->rcCompText.right-4))
break;
else
xx+=yy;
}
cur_start_count=(WORD)i;
cur_start_ps=(WORD)GetText32(hDC, &InputBuffer[0], i);
// true_len = StrLen-cur_start_count ;
}
for(i=StrLen-cur_start_count; i>0; i--){
yy=GetText32(hDC,&InputBuffer[cur_start_count],i);
if (yy <= lpImeL->rcCompText.right-4)
break;
}
{
LOGFONT lfFont;
HGDIOBJ hOldFont;
int Top = 2;
if (sImeG.yChiCharHi > 0x10)
Top = 0;
hOldFont = GetCurrentObject(hDC, OBJ_FONT);
GetObject(hOldFont, sizeof(lfFont), &lfFont);
lfFont.lfWeight = FW_DONTCARE;
SelectObject(hDC, CreateFontIndirect(&lfFont));
ExtTextOut(hDC,
lpImeL->rcCompText.left, lpImeL->rcCompText.top + Top,
ETO_OPAQUE, &lpImeL->rcCompText,
&InputBuffer[cur_start_count],
i, NULL);
DeleteObject(SelectObject(hDC, hOldFont));
}
// TextOut(hDC,0,0,&InputBuffer[cur_start_count],
// (sizeof InputBuffer)-cur_start_count);
now_cs_dot = xx;
cur_hibit=0,cur_flag=0;
return;
}
/**********************************************************************/
/* UpdateCompWindow2() */
/**********************************************************************/
void PASCAL UpdateCompWindow2(
HWND hUIWnd,
HDC hDC)
{
HIMC hIMC;
LPINPUTCONTEXT lpIMC;
LPCOMPOSITIONSTRING lpCompStr;
LPGUIDELINE lpGuideLine;
BOOL fShowString;
LOGFONT lfFont;
HGDIOBJ hOldFont;
hIMC = (HIMC)GetWindowLongPtr(hUIWnd, IMMGWLP_IMC);
if (!hIMC) {
return;
}
lpIMC = (LPINPUTCONTEXT)ImmLockIMC(hIMC);
if (!lpIMC) {
return;
}
lpCompStr = (LPCOMPOSITIONSTRING)ImmLockIMCC(lpIMC->hCompStr);
lpGuideLine = (LPGUIDELINE)ImmLockIMCC(lpIMC->hGuideLine);
hOldFont = GetCurrentObject(hDC, OBJ_FONT);
GetObject(hOldFont, sizeof(lfFont), &lfFont);
lfFont.lfWeight = FW_DONTCARE;
SelectObject(hDC, CreateFontIndirect(&lfFont));
SetBkColor(hDC, RGB(0xC0, 0xC0, 0xC0));
fShowString = (BOOL)0;
if (lpImeL->wImeStyle == IME_APRS_FIX){
RECT rcSunken;
DrawConvexRect(hDC,
0,
0,
lpImeL->xCompWi-1,
lpImeL->yCompHi-1);
rcSunken.left =0;
rcSunken.top =0;
rcSunken.right =lpImeL->xCompWi-1;
rcSunken.bottom = lpImeL->yCompHi-1;
// DrawEdge(hDC, &rcSunken, EDGE_RAISED,/*EDGE_SUNKEN,*/ BF_RECT);
}else
DrawConvexRect(hDC,
0,
0,
lpImeL->xCompWi-1,
lpImeL->yCompHi-1);
/* DrawConvexRect(hDC,
lpImeL->rcCompText.left-4,
lpImeL->rcCompText.top-4,
lpImeL->rcCompText.right+4,
lpImeL->rcCompText.bottom+4); */
/* DrawConcaveRect(hDC,
lpImeL->rcCompText.left-1,
lpImeL->rcCompText.top-1,
lpImeL->rcCompText.right+1,
lpImeL->rcCompText.bottom+1); */
if (!lpGuideLine) {
} else if (lpGuideLine->dwLevel == GL_LEVEL_NOGUIDELINE) {
} else if (!lpGuideLine->dwStrLen) {
if (lpGuideLine->dwLevel == GL_LEVEL_ERROR) {
fShowString |= IME_STR_ERROR;
}
} else {
// if there is information string, we will show the information
// string
if (lpGuideLine->dwLevel == GL_LEVEL_ERROR) {
// red text for error
SetTextColor(hDC, RGB(0xFF, 0, 0));
// light gray background for error
SetBkColor(hDC, QIANHUI);
}
ExtTextOut(hDC, lpImeL->rcCompText.left, lpImeL->rcCompText.top,
ETO_OPAQUE, &lpImeL->rcCompText,
(LPBYTE)lpGuideLine + lpGuideLine->dwStrOffset,
(UINT)lpGuideLine->dwStrLen, NULL);
fShowString |= IME_STR_SHOWED;
}
if (fShowString & IME_STR_SHOWED) {
// already show it, don't need to show
} else if (lpCompStr) {
// ExtTextOut(hDC, lpImeL->rcCompText.left, lpImeL->rcCompText.top,
// ETO_OPAQUE, &lpImeL->rcCompText,
// (LPSTR)lpCompStr + lpCompStr->dwCompStrOffset,
// (UINT)lpCompStr->dwCompStrLen, NULL);
CurMovePaint(hDC,
(LPSTR)lpCompStr + lpCompStr->dwCompStrOffset,
(UINT)lpCompStr->dwCompStrLen);
if (fShowString & IME_STR_ERROR) {
// red text for error
SetTextColor(hDC, RGB(0xFF, 0, 0));
// light gray background for error
SetBkColor(hDC, QIANHUI);
ExtTextOut(hDC, lpImeL->rcCompText.left +
lpCompStr->dwCursorPos * sImeG.xChiCharWi/ 2,
lpImeL->rcCompText.top,
ETO_CLIPPED, &lpImeL->rcCompText,
(LPSTR)lpCompStr + lpCompStr->dwCompStrOffset +
lpCompStr->dwCursorPos,
(UINT)lpCompStr->dwCompStrLen - lpCompStr->dwCursorPos, NULL);
} else if (lpCompStr->dwCursorPos < lpCompStr->dwCompStrLen) {
// light gray background for cursor start
SetBkColor(hDC, QIANHUI);
ExtTextOut(hDC, lpImeL->rcCompText.left +
lpCompStr->dwCursorPos * sImeG.xChiCharWi/ 2,
lpImeL->rcCompText.top,
ETO_CLIPPED, &lpImeL->rcCompText,
(LPSTR)lpCompStr + lpCompStr->dwCompStrOffset +
lpCompStr->dwCursorPos,
(UINT)lpCompStr->dwCompStrLen - lpCompStr->dwCursorPos, NULL);
} else {
}
} else {
ExtTextOut(hDC, lpImeL->rcCompText.left, lpImeL->rcCompText.top,
ETO_OPAQUE, &lpImeL->rcCompText,
(LPSTR)NULL, 0, NULL);
}
DeleteObject(SelectObject(hDC, hOldFont));
ImmUnlockIMCC(lpIMC->hGuideLine);
ImmUnlockIMCC(lpIMC->hCompStr);
ImmUnlockIMC(hIMC);
return;
}
/**********************************************************************/
/* UpdateCompWindow() */
/**********************************************************************/
void PASCAL UpdateCompWindow(
HWND hUIWnd)
{
HWND hCompWnd;
HDC hDC;
hCompWnd = GetCompWnd(hUIWnd);
if (!hCompWnd) return ; //Modify 95/7.1
hDC = GetDC(hCompWnd);
UpdateCompWindow2(hUIWnd, hDC);
ReleaseDC(hCompWnd, hDC);
}
/**********************************************************************/
/* UpdateCompCur() */
/**********************************************************************/
void PASCAL UpdateCompCur(
HWND hCompWnd)
{
HDC hDC;
int yy,i;
HGDIOBJ hOldFont;
LOGFONT lfFont;
cur_hibit=1;
if (!hCompWnd) return ; //Modify 95/7.1
hDC = GetDC(hCompWnd);
hOldFont = GetCurrentObject(hDC, OBJ_FONT);
GetObject(hOldFont, sizeof(lfFont), &lfFont);
lfFont.lfWeight = FW_DONTCARE;
SelectObject(hDC, CreateFontIndirect(&lfFont));
SetBkColor(hDC, RGB(0xC0, 0xC0, 0xC0));
for (i =43-cur_start_count; i>0; i--){
yy=GetText32(hDC, &InputBuffer[cur_start_count], i);
if ( yy < lpImeL->rcCompText.right-4)
break;
}
ExtTextOut(hDC,
lpImeL->rcCompText.left, lpImeL->rcCompText.top,
ETO_OPAQUE, &lpImeL->rcCompText,
&InputBuffer[cur_start_count],
i,
NULL);
DeleteObject(SelectObject(hDC, hOldFont));
ReleaseDC(hCompWnd, hDC);
cur_hibit=0,cur_flag=0;
return ;
}
/**********************************************************************/
/* PaintCompWindow() */
/**********************************************************************/
void PASCAL PaintCompWindow( // get WM_PAINT message
HWND hCompWnd)
{
HDC hDC;
PAINTSTRUCT ps;
RECT pt;
if(CompWndChange){
CompWndChange = 0;
SetCompWindow(GetWindow(hCompWnd,GW_OWNER));
};
cur_hibit=1;
hDC = BeginPaint(hCompWnd, &ps);
UpdateCompWindow2(GetWindow(hCompWnd, GW_OWNER), hDC);
EndPaint(hCompWnd, &ps);
cur_hibit=0,cur_flag=0;
return;
}
/**********************************************************************/
/* CompWndProc() */
/**********************************************************************/
LRESULT CALLBACK CompWndProc( // composition window proc
HWND hCompWnd,
UINT uMsg,
WPARAM wParam,
LPARAM lParam)
{
HDC hDC;
switch (uMsg) {
case WM_CREATE:
hDC=GetDC(hCompWnd);
hMemoryDC=CreateCompatibleDC(hDC);
cur_h=LoadBitmap(hInst,CUR_HB);
ReleaseDC(hCompWnd,hDC);
SetTimer(hCompWnd ,1,400,(TIMERPROC)NULL);
ShowCandTimerCount=0;
break;
case WM_TIMER:
hInputWnd = hCompWnd;
TimerCounter++;
ShowCandTimerCount++;
if (TimerCounter==3){
TimerCounter=0;
}
if (!kb_flag) return(0);
if (cur_hibit||(cap_mode&&(!cur_flag))) return(0);
DrawInputCur();
break;
case WM_DESTROY:
KillTimer(hCompWnd,1);
DeleteObject(cur_h);
DeleteObject(hMemoryDC);
DestroyCompWindow(hCompWnd);
break;
case WM_SETCURSOR:
CompSetCursor(hCompWnd, lParam);
break;
case WM_MOUSEMOVE:
if (GetWindowLong(hCompWnd, UI_MOVE_OFFSET) != WINDOW_NOT_DRAG) {
if(lpImeL->wImeStyle == IME_APRS_AUTO){
POINT ptCursor;
DrawDragBorder(hCompWnd,
GetWindowLong(hCompWnd, UI_MOVE_XY),
GetWindowLong(hCompWnd, UI_MOVE_OFFSET));
GetCursorPos(&ptCursor);
SetWindowLong(hCompWnd, UI_MOVE_XY,
MAKELONG(ptCursor.x, ptCursor.y));
DrawDragBorder(hCompWnd, MAKELONG(ptCursor.x, ptCursor.y),
GetWindowLong(hCompWnd, UI_MOVE_OFFSET));
}else MessageBeep(0);
} else {
return DefWindowProc(hCompWnd, uMsg, wParam, lParam);
}
break;
case WM_LBUTTONUP:
if (!CompButtonUp(hCompWnd)) {
return DefWindowProc(hCompWnd, uMsg, wParam, lParam);
}
break;
case WM_SHOWWINDOW:
if (wParam) cur_hibit = 0;
else cur_hibit = 1;
break;
case WM_PAINT:
if (wParam == 0xa )
UpdateCompCur(hCompWnd);
else
PaintCompWindow(hCompWnd);
break;
case WM_MOUSEACTIVATE:
return (MA_NOACTIVATE);
default:
return DefWindowProc(hCompWnd, uMsg, wParam, lParam);
}
return (0L);
}
/**********************************************************************/
/* GetCandWnd */
/* Return Value : */
/* window handle of candidatte */
/**********************************************************************/
HWND PASCAL GetCandWnd(
HWND hUIWnd) // UI window
{
HGLOBAL hUIPrivate;
LPUIPRIV lpUIPrivate;
HWND hCandWnd;
hUIPrivate = (HGLOBAL)GetWindowLongPtr(hUIWnd, IMMGWLP_PRIVATE);
if (!hUIPrivate) { // can not darw candidate window
return (HWND)NULL;
}
lpUIPrivate = (LPUIPRIV)GlobalLock(hUIPrivate);
if (!lpUIPrivate) { // can not draw candidate window
return (HWND)NULL;
}
hCandWnd = lpUIPrivate->hCandWnd;
GlobalUnlock(hUIPrivate);
return (hCandWnd);
}
/**********************************************************************/
/* CalcCandPos */
/**********************************************************************/
void PASCAL CalcCandPos2(
LPPOINT lpptWnd) // the composition window position
{
POINT ptNew;
ptNew.x = lpptWnd->x + UI_MARGIN * 2;
if (ptNew.x + sImeG.xCandWi > sImeG.rcWorkArea.right) {
// exceed screen width
ptNew.x = lpptWnd->x - sImeG.xCandWi - UI_MARGIN * 2;
}
ptNew.y = lpptWnd->y;// + lpImeL->cyCompBorder - sImeG.cyCandBorder;
if (ptNew.y + sImeG.yCandHi > sImeG.rcWorkArea.bottom) {
// exceed screen high
ptNew.y = sImeG.rcWorkArea.bottom - sImeG.yCandHi;
}
lpptWnd->x = ptNew.x;
lpptWnd->y = ptNew.y;
return;
}
/**********************************************************************/
/* CalcCandPos */
/**********************************************************************/
BOOL PASCAL CalcCandPos(
LPPOINT lpptWnd) // the composition window position
{
POINT ptNew;
ptNew.x = lpptWnd->x + lpImeL->xCompWi + UI_MARGIN * 2;
if (ptNew.x + sImeG.xCandWi > sImeG.rcWorkArea.right) {
// exceed screen width
ptNew.x = lpptWnd->x - sImeG.xCandWi - UI_MARGIN * 2;
}
ptNew.y = lpptWnd->y;// + lpImeL->cyCompBorder - sImeG.cyCandBorder;
if (ptNew.y + sImeG.yCandHi > sImeG.rcWorkArea.bottom) {
// exceed screen high
ptNew.y = sImeG.rcWorkArea.bottom - sImeG.yCandHi;
}
lpptWnd->x = ptNew.x;
lpptWnd->y = ptNew.y;
return 0;
}
/**********************************************************************/
/* AdjustCandBoundry */
/**********************************************************************/
void PASCAL AdjustCandBoundry(
LPPOINT lpptCandWnd) // the position
{
if (lpptCandWnd->x < sImeG.rcWorkArea.left) {
lpptCandWnd->x = sImeG.rcWorkArea.left;
} else if (lpptCandWnd->x + sImeG.xCandWi > sImeG.rcWorkArea.right) {
lpptCandWnd->x = sImeG.rcWorkArea.right - sImeG.xCandWi;
}
if (lpptCandWnd->y < sImeG.rcWorkArea.top) {
lpptCandWnd->y = sImeG.rcWorkArea.top;
} else if (lpptCandWnd->y + sImeG.yCandHi > sImeG.rcWorkArea.bottom) {
lpptCandWnd->y = sImeG.rcWorkArea.bottom - sImeG.yCandHi;
}
return;
}
/**********************************************************************/
/* GetCandPos() */
/**********************************************************************/
LRESULT PASCAL GetCandPos(
HWND hUIWnd,
LPCANDIDATEFORM lpCandForm)
{
HWND hCandWnd;
HIMC hIMC;
LPINPUTCONTEXT lpIMC;
POINT ptNew;
//DebugShow("GetCand...%x",hUIWnd);
hIMC = (HIMC)GetWindowLongPtr(hUIWnd, IMMGWLP_IMC);
if (!hIMC) {
return (1L);
}
lpIMC = (LPINPUTCONTEXT)ImmLockIMC(hIMC);
if (!lpIMC) {
return (1L);
}
if (!(hCandWnd = GetCandWnd(hUIWnd))) {
return (1L);
}
if (lpCandForm->dwStyle & CFS_FORCE_POSITION) {
ptNew.x = (int)lpCandForm->ptCurrentPos.x;
ptNew.y = (int)lpCandForm->ptCurrentPos.y;
} else if (lpCandForm->dwStyle & CFS_CANDIDATEPOS) {
ptNew.x = (int)lpCandForm->ptCurrentPos.x;
ptNew.y = (int)lpCandForm->ptCurrentPos.y;
} else if (lpCandForm->dwStyle & CFS_EXCLUDE) {
ptNew.x = (int)lpCandForm->ptCurrentPos.x;
ptNew.y = (int)lpCandForm->ptCurrentPos.y;
}
ImmUnlockIMC(hIMC);
return (0L);
}
/**********************************************************************/
/* SetCandPosition() */
/**********************************************************************/
LRESULT PASCAL SetCandPosition(
HWND hUIWnd,
LPCANDIDATEFORM lpCandForm)
{
HWND hCandWnd;
HIMC hIMC;
LPINPUTCONTEXT lpIMC;
POINT ptNew;
// DebugShow("SetCand...%x",hUIWnd);
hIMC = (HIMC)GetWindowLongPtr(hUIWnd, IMMGWLP_IMC);
if (!hIMC) {
return (1L);
}
lpIMC = (LPINPUTCONTEXT)ImmLockIMC(hIMC);
if (!lpIMC) {
return (1L);
}
if (!(hCandWnd = GetCandWnd(hUIWnd))) {
return (1L);
}
if (lpCandForm->dwStyle & CFS_FORCE_POSITION) {
ptNew.x = (int)lpCandForm->ptCurrentPos.x;
ptNew.y = (int)lpCandForm->ptCurrentPos.y;
ClientToScreen((HWND)lpIMC->hWnd, &ptNew);
//##4
SetWindowPos(hCandWnd, NULL,
ptNew.x, ptNew.y,
sImeG.xCandWi,sImeG.yCandHi, SWP_NOACTIVATE|/*SWP_NOSIZE|*/SWP_NOZORDER);
} else if (lpCandForm->dwStyle & CFS_CANDIDATEPOS) {
ptNew.x = (int)lpCandForm->ptCurrentPos.x;
ptNew.y = (int)lpCandForm->ptCurrentPos.y;
ClientToScreen((HWND)lpIMC->hWnd, &ptNew);
AdjustCandBoundry(&ptNew);
// ##5
SetWindowPos(hCandWnd, NULL,
ptNew.x, ptNew.y,
sImeG.xCandWi,sImeG.yCandHi, SWP_NOACTIVATE/*|SWP_NOSIZE*/|SWP_NOZORDER);
} else if (lpCandForm->dwStyle & CFS_EXCLUDE) {
ptNew.x = (int)lpCandForm->ptCurrentPos.x;
ptNew.y = (int)lpCandForm->ptCurrentPos.y;
ClientToScreen((HWND)lpIMC->hWnd, &ptNew);
AdjustCandBoundry(&ptNew);
// ##6
SetWindowPos(hCandWnd, NULL,
ptNew.x, ptNew.y,
sImeG.xCandWi,sImeG.yCandHi, SWP_NOACTIVATE|/*SWP_NOSIZE|*/SWP_NOZORDER);
} else if (lpIMC->cfCandForm[0].dwStyle == CFS_DEFAULT) {
HWND hCompWnd;
if (hCompWnd = GetCompWnd(hUIWnd)) {
ptNew.x = 0;
ptNew.y = 0;
ClientToScreen(hCompWnd, &ptNew);
CalcCandPos(&ptNew);
} else {
AdjustCandBoundry(&ptNew);
}
SetWindowPos(hCandWnd, NULL,
ptNew.x, ptNew.y,
sImeG.xCandWi,sImeG.yCandHi, SWP_NOACTIVATE|/*SWP_NOSIZE|*/SWP_NOZORDER);
}
ImmUnlockIMC(hIMC);
return (0L);
}
/**********************************************************************/
/* ShowCand() */
/**********************************************************************/
void PASCAL ShowCand( // Show the candidate window
HWND hUIWnd,
int nShowCandCmd)
{
HGLOBAL hUIPrivate;
LPUIPRIV lpUIPrivate;
// if (ShowCandTimerCount<5) {ShowCandTimerCount = 0; return 0;}
// ShowCandTimerCount = 0 ;
hUIPrivate = (HGLOBAL)GetWindowLongPtr(hUIWnd, IMMGWLP_PRIVATE);
if (!hUIPrivate) { // can not darw candidate window
return;
}
lpUIPrivate = (LPUIPRIV)GlobalLock(hUIPrivate);
if (!lpUIPrivate) { // can not draw candidate window
return;
}
if (!lpUIPrivate->hCandWnd) {
// not in show candidate window mode
} else if (lpUIPrivate->nShowCandCmd != nShowCandCmd) {
ShowWindow(lpUIPrivate->hCandWnd, nShowCandCmd);
lpUIPrivate->nShowCandCmd = nShowCandCmd;
} else {
}
GlobalUnlock(hUIPrivate);
return;
}
/**********************************************************************/
/* OpenCand */
/**********************************************************************/
void PASCAL OpenCand(
HWND hUIWnd)
{
HGLOBAL hUIPrivate;
LPUIPRIV lpUIPrivate;
POINT ptWnd;
int value;
// DebugShow("In Open Cand",0);
hUIPrivate = (HGLOBAL)GetWindowLongPtr(hUIWnd, IMMGWLP_PRIVATE);
if (!hUIPrivate) { // can not darw candidate window
return;
}
lpUIPrivate = (LPUIPRIV)GlobalLock(hUIPrivate);
if (!lpUIPrivate) { // can not draw candidate window
return;
}
lpUIPrivate->fdwSetContext |= ISC_SHOWUICANDIDATEWINDOW;
ptWnd.x = 0;
ptWnd.y = 0;
// DebugShow("OpenCand ..->hCompWnd=%X",lpUIPrivate);
value = ClientToScreen(lpUIPrivate->hCompWnd, &ptWnd);
// DebugShow("OpenCand ..value", value);
if (!value){ // if there no Comp wndows
GetCaretPos(&ptWnd);
ClientToScreen(GetFocus(),&ptWnd);
CalcCandPos2(&ptWnd);
} else {
ptWnd.x -= lpImeL->cxCompBorder;
// ptWnd.y -= lpImeL->cyCompBorder;
CalcCandPos(&ptWnd);
}
if (lpImeL->wImeStyle == IME_APRS_FIX) {
ptWnd.x = lpImeL->ptDefCand.x;
ptWnd.y = lpImeL->ptDefCand.y;
}
// ##7
if (lpUIPrivate->hCandWnd) {
SetWindowPos(lpUIPrivate->hCandWnd, NULL,
ptWnd.x, ptWnd.y,
sImeG.xCandWi, sImeG.yCandHi,
SWP_NOACTIVATE/*|SWP_NOSIZE*/|SWP_NOZORDER);
} else {
lpUIPrivate->hCandWnd = CreateWindowEx(
/* WS_EX_TOPMOST*/ /*|*/ /* WS_EX_CLIENTEDGE|WS_EX_WINDOWEDGE/*|WS_EX_DLGMODALFRAME*/
0,
szCandClassName, NULL, WS_POPUP|WS_DISABLED, //|WS_BORDER,
ptWnd.x,
ptWnd.y,
sImeG.xCandWi, sImeG.yCandHi,
hUIWnd, (HMENU)NULL, hInst, NULL);
if ( lpUIPrivate->hCandWnd )
{
SetWindowLong(lpUIPrivate->hCandWnd, UI_MOVE_OFFSET,
WINDOW_NOT_DRAG);
SetWindowLong(lpUIPrivate->hCandWnd, UI_MOVE_XY, 0L);
}
}
ShowCand(hUIWnd, SW_SHOWNOACTIVATE);
GlobalUnlock(hUIPrivate);
return;
}
/**********************************************************************/
/* CloseCand */
/**********************************************************************/
void PASCAL CloseCand(
HWND hUIWnd)
{
HGLOBAL hUIPrivate;
LPUIPRIV lpUIPrivate;
hUIPrivate = (HGLOBAL)GetWindowLongPtr(hUIWnd, IMMGWLP_PRIVATE);
if (!hUIPrivate) { // can not darw candidate window
return;
}
lpUIPrivate = (LPUIPRIV)GlobalLock(hUIPrivate);
if (!lpUIPrivate) { // can not draw candidate window
return;
}
ShowWindow(lpUIPrivate->hCandWnd, SW_HIDE);
lpUIPrivate->nShowCandCmd = SW_HIDE;
GlobalUnlock(hUIPrivate);
return;
}
/**********************************************************************/
/* DestroyCandWindow */
/**********************************************************************/
void PASCAL DestroyCandWindow(
HWND hCandWnd)
{
HGLOBAL hUIPrivate;
LPUIPRIV lpUIPrivate;
hUIPrivate = (HGLOBAL)GetWindowLongPtr(GetWindow(hCandWnd, GW_OWNER),
IMMGWLP_PRIVATE);
if (!hUIPrivate) { // can not darw candidate window
return;
}
lpUIPrivate = (LPUIPRIV)GlobalLock(hUIPrivate);
if (!lpUIPrivate) { // can not draw candidate window
return;
}
lpUIPrivate->nShowCandCmd = SW_HIDE;
lpUIPrivate->hCandWnd = (HWND)NULL;
GlobalUnlock(hUIPrivate);
return;
}
/**********************************************************************/
/* MouseSelectCandStr() */
/**********************************************************************/
void PASCAL MouseSelectCandStr(
HWND hCandWnd,
LPPOINT lpCursor)
{
HIMC hIMC;
LPINPUTCONTEXT lpIMC;
LPCANDIDATEINFO lpCandInfo;
LPCANDIDATELIST lpCandList;
DWORD dwValue, value = 0 ;
hIMC = (HIMC)GetWindowLongPtr(GetWindow(hCandWnd, GW_OWNER), IMMGWLP_IMC);
if (!hIMC) {
return;
}
lpIMC = (LPINPUTCONTEXT)ImmLockIMC(hIMC);
if (!lpIMC) {
return;
}
if (!lpIMC->hCandInfo) {
ImmUnlockIMC(hIMC);
return;
}
lpCandInfo = (LPCANDIDATEINFO)ImmLockIMCC(lpIMC->hCandInfo);
if (!lpCandInfo) {
ImmUnlockIMC(hIMC);
return;
}
if (PtInRect(&sImeG.rcHome, *lpCursor))
value = VK_HOME*0x100;
if (PtInRect(&sImeG.rcEnd, *lpCursor))
value = VK_END*0x100;
if (PtInRect(&sImeG.rcPageUp, *lpCursor))
value = VK_PRIOR*0x100;
if (PtInRect(&sImeG.rcPageDown, *lpCursor))
value = VK_NEXT*0x100;
if (PtInRect(&sImeG.rcCandText, *lpCursor)){
if (lpImeL->wImeStyle == IME_APRS_AUTO )
value = 0x8030 + 1 + (lpCursor->y - sImeG.rcCandText.top) / sImeG.yChiCharHi;
else
value = 0x8030+1+ (lpCursor->x - sImeG.rcCandText.left)/
(sImeG.xChiCharWi*unit_length/2+ sImeG.Ajust);
}
if(value) {
LPPRIVCONTEXT lpImcP;
lpImcP = (LPPRIVCONTEXT)ImmLockIMCC(lpIMC->hPrivate);
lpImcP->fdwImeMsg =lpImcP->fdwImeMsg & ~MSG_IN_IMETOASCIIEX;
ImmUnlockIMCC(lpIMC->hPrivate);
NotifyIME(hIMC, NI_SELECTCANDIDATESTR, 0, value);
}
ImmUnlockIMCC(lpIMC->hCandInfo);
ImmUnlockIMC(hIMC);
return;
}
/**********************************************************************/
/* CandSetCursor() */
/**********************************************************************/
void PASCAL CandSetCursor(
HWND hCandWnd,
LPARAM lParam)
{
POINT ptCursor;
RECT rcWnd;
if (GetWindowLong(hCandWnd, UI_MOVE_OFFSET) != WINDOW_NOT_DRAG) {
SetCursor(LoadCursor(NULL, IDC_SIZEALL));
return;
}
if (HIWORD(lParam) == WM_LBUTTONDOWN) {
SystemParametersInfo(SPI_GETWORKAREA, 0, &sImeG.rcWorkArea, 0);
GetCursorPos(&ptCursor);
ScreenToClient(hCandWnd, &ptCursor);
if (PtInRect(&sImeG.rcCandText, ptCursor)||
PtInRect(&sImeG.rcHome, ptCursor)||
PtInRect(&sImeG.rcEnd, ptCursor)||
PtInRect(&sImeG.rcPageUp, ptCursor)||
PtInRect(&sImeG.rcPageDown, ptCursor)) {
SetCursor(LoadCursor(hInst, szHandCursor));
MouseSelectCandStr(hCandWnd, &ptCursor);
return;
} else {
SetCursor(LoadCursor(NULL, IDC_SIZEALL));
}
} else {
GetCursorPos(&ptCursor);
ScreenToClient(hCandWnd, &ptCursor);
if (PtInRect(&sImeG.rcCandText, ptCursor)||
PtInRect(&sImeG.rcHome, ptCursor)||
PtInRect(&sImeG.rcEnd, ptCursor)||
PtInRect(&sImeG.rcPageUp, ptCursor)||
PtInRect(&sImeG.rcPageDown, ptCursor)) {
SetCursor(LoadCursor(hInst, szHandCursor));
} else {
SetCursor(LoadCursor(NULL, IDC_SIZEALL));
}
return;
}
SetCapture(hCandWnd);
GetCursorPos(&ptCursor);
SetWindowLong(hCandWnd, UI_MOVE_XY,
MAKELONG(ptCursor.x, ptCursor.y));
GetWindowRect(hCandWnd, &rcWnd);
SetWindowLong(hCandWnd, UI_MOVE_OFFSET,
MAKELONG(ptCursor.x - rcWnd.left, ptCursor.y - rcWnd.top));
DrawDragBorder(hCandWnd, MAKELONG(ptCursor.x, ptCursor.y),
GetWindowLong(hCandWnd, UI_MOVE_OFFSET));
return;
}
/**********************************************************************/
/* CandButtonUp() */
/**********************************************************************/
BOOL PASCAL CandButtonUp(
HWND hCandWnd)
{
LONG lTmpCursor, lTmpOffset;
POINT pt;
HWND hUIWnd;
HIMC hIMC;
LPINPUTCONTEXT lpIMC;
HWND hFocusWnd;
CANDIDATEFORM cfCandForm;
if (GetWindowLong(hCandWnd, UI_MOVE_OFFSET) == WINDOW_NOT_DRAG) {
return (FALSE);
}
lTmpCursor = GetWindowLong(hCandWnd, UI_MOVE_XY);
pt.x = (*(LPPOINTS)&lTmpCursor).x;
pt.y = (*(LPPOINTS)&lTmpCursor).y;
// calculate the org by the offset
lTmpOffset = GetWindowLong(hCandWnd, UI_MOVE_OFFSET);
pt.x -= (*(LPPOINTS)&lTmpOffset).x;
pt.y -= (*(LPPOINTS)&lTmpOffset).y;
DrawDragBorder(hCandWnd, lTmpCursor, lTmpOffset);
SetWindowLong(hCandWnd, UI_MOVE_OFFSET, WINDOW_NOT_DRAG);
ReleaseCapture();
hUIWnd = GetWindow(hCandWnd, GW_OWNER);
hIMC = (HIMC)GetWindowLongPtr(hUIWnd, IMMGWLP_IMC);
if (!hIMC) {
return (FALSE);
}
lpIMC = (LPINPUTCONTEXT)ImmLockIMC(hIMC);
if (!lpIMC) {
return (FALSE);
}
hFocusWnd = lpIMC->hWnd;
ImmUnlockIMC(hIMC);
AdjustCandBoundry(&pt);
ScreenToClient(hFocusWnd, &pt);
cfCandForm.dwStyle = CFS_CANDIDATEPOS;
cfCandForm.ptCurrentPos.x = pt.x;
cfCandForm.ptCurrentPos.y = pt.y;
SendMessage(hUIWnd, WM_IME_CONTROL, IMC_SETCANDIDATEPOS,
(LPARAM)&cfCandForm);
return (TRUE);
}
/**********************************************************************/
/* PaintOP() */
/**********************************************************************/
void PASCAL PaintOP(
HDC hDC,
HWND hWnd)
{
RECT rcSunken;
int x1,y1,x2,y2;
rcSunken = sImeG.rcCandText;
x1=rcSunken.left-2;
y1=rcSunken.top-1;//2;
x2=rcSunken.right+7;
y2=rcSunken.bottom+5;
rcSunken.left =x1;
rcSunken.top =y1;
rcSunken.right =x2;
rcSunken.bottom = y2;
// ShowBitmap(hDC,x2-50,y2,49,20, szUpDown);
if(lpImeL->wImeStyle == IME_APRS_AUTO ){
DrawConvexRect(hDC,0,0,sImeG.xCandWi-1, sImeG.yCandHi-1);
// DrawConcaveRect(hDC ,x1,y1,x2,y2);
if(bx_inpt_on){
ShowBitmap2(hDC,
sImeG.xCandWi/2-25,
sImeG.rcHome.top,
50,
15,
sImeG.SnumbBmp);
}else {
ShowBitmap2(hDC,
sImeG.xCandWi/2-25,
sImeG.rcHome.top,
50,
15,
sImeG.NumbBmp);
}
ShowBitmap2(hDC,
sImeG.rcHome.left,
sImeG.rcHome.top,
14,
14,
sImeG.HomeBmp);
ShowBitmap2(hDC,
sImeG.rcEnd.left,
sImeG.rcEnd.top,
14,
14,
sImeG.EndBmp);
ShowBitmap2(hDC,
sImeG.rcPageUp.left,
sImeG.rcPageUp.top,
14,
14,
sImeG.PageUpBmp);
ShowBitmap2(hDC,
sImeG.rcPageDown.left,
sImeG.rcPageDown.top,
14,
14,
sImeG.PageDownBmp);
}else{
ShowBitmap2(hDC,
sImeG.rcHome.left,
sImeG.rcHome.top,
14,
14,
sImeG.Home2Bmp);
ShowBitmap2(hDC,
sImeG.rcEnd.left,
sImeG.rcEnd.top,
14,
14,
sImeG.End2Bmp);
ShowBitmap2(hDC,
sImeG.rcPageUp.left,
sImeG.rcPageUp.top,
14,
14,
sImeG.PageUp2Bmp);
ShowBitmap2(hDC,
sImeG.rcPageDown.left,
sImeG.rcPageDown.top,
14,
14,
sImeG.PgDown2Bmp);
}
return ;
}
int keep =9;
/**********************************************************************/
/* UpdateCandWindow() */
/**********************************************************************/
void PASCAL UpdateCandWindow2(
HWND hCandWnd,
HDC hDC)
{
HIMC hIMC;
LPINPUTCONTEXT lpIMC;
LPCANDIDATEINFO lpCandInfo;
LPCANDIDATELIST lpCandList;
LPPRIVCONTEXT lpImcP;
DWORD dwStart, dwEnd;
TCHAR szStrBuf[30* sizeof(WCHAR) / sizeof(TCHAR)];
int i , LenOfAll;
HGDIOBJ hOldFont;
LOGFONT lfFont;
hIMC = (HIMC)GetWindowLongPtr(GetWindow(hCandWnd, GW_OWNER), IMMGWLP_IMC);
if (!hIMC) {
return;
}
lpIMC = (LPINPUTCONTEXT)ImmLockIMC(hIMC);
if (!lpIMC) {
return;
}
if (!lpIMC->hCandInfo) {
ImmUnlockIMC(hIMC);
return ;
}
lpCandInfo = (LPCANDIDATEINFO)ImmLockIMCC(lpIMC->hCandInfo);
if (!lpCandInfo) {
ImmUnlockIMC(hIMC);
return ;
}
if (!lpIMC->hPrivate) {
ImmUnlockIMCC(lpIMC->hCandInfo);
ImmUnlockIMC(hIMC);
return;
}
lpImcP = (LPPRIVCONTEXT)ImmLockIMCC(lpIMC->hPrivate);
if (!lpImcP) {
ImmUnlockIMCC(lpIMC->hCandInfo);
ImmUnlockIMC(hIMC);
return;
}
lpCandList = (LPCANDIDATELIST)((LPBYTE)lpCandInfo +
lpCandInfo->dwOffset[0]);
if(lpImeL->wImeStyle == IME_APRS_FIX)
lpCandList->dwPageSize = now.fmt_group;
else
lpCandList->dwPageSize = CANDPERPAGE ;
if (!lpCandList->dwPageSize)
lpCandList->dwPageSize = keep;
keep = lpCandList->dwPageSize;
dwStart = lpCandList->dwSelection /
lpCandList->dwPageSize * lpCandList->dwPageSize;
dwEnd = dwStart + lpCandList->dwPageSize;
if (dwEnd > lpCandList->dwCount) {
dwEnd = lpCandList->dwCount;
}
hOldFont = GetCurrentObject(hDC, OBJ_FONT);
GetObject(hOldFont, sizeof(lfFont), &lfFont);
lfFont.lfWeight = FW_DONTCARE;
SelectObject(hDC, CreateFontIndirect(&lfFont));
if(lpImeL->wImeStyle != IME_APRS_FIX){
PaintOP(hDC,hCandWnd);
if (lpImcP->iImeState == CST_INIT) {
// phrase prediction
SetTextColor(hDC, RGB(0x00, 0x80, 0x00));
} else if (lpImcP->iImeState != CST_CHOOSE) {
// quick key
SetTextColor(hDC, RGB(0x80, 0x00, 0x80));
} else {
}
SetBkColor(hDC, RGB(0xc0, 0xc0, 0xc0));
sImeG.rcCandText.bottom+=3;
ExtTextOut(hDC, sImeG.rcCandText.left, sImeG.rcCandText.top,
ETO_OPAQUE, &sImeG.rcCandText, NULL, 0, NULL);
sImeG.rcCandText.bottom-=3;
szStrBuf[0] = '1';
szStrBuf[1] = ':';
for (i = 0; dwStart < dwEnd; dwStart++, i++) {
int iLen;
szStrBuf[0] = szDigit[i + CAND_START];
iLen = lstrlen((LPTSTR)((LPBYTE)lpCandList +
lpCandList->dwOffset[dwStart]));
// according to init.c, 7 DBCS char
if (iLen > 6 * sizeof(WCHAR) / sizeof(TCHAR)) {
iLen = 6 * sizeof(WCHAR) / sizeof(TCHAR);
CopyMemory(&szStrBuf[2],
((LPBYTE)lpCandList+lpCandList->dwOffset[dwStart]),
iLen * sizeof(TCHAR) - sizeof(TCHAR) * 2);
// maybe not good for UNICODE
szStrBuf[iLen] = '.';
szStrBuf[iLen + 1] = '.';
} else {
CopyMemory(&szStrBuf[2],
((LPBYTE)lpCandList+lpCandList->dwOffset[dwStart]),
iLen);
}
ExtTextOut(hDC, sImeG.rcCandText.left,
sImeG.rcCandText.top + i * sImeG.yChiCharHi,
(UINT)0, NULL,
szStrBuf,
iLen + 2, NULL);
}
} else {
PaintOP(hDC,hCandWnd);
SetTextColor(hDC, RGB(0xa0, 0x00, 0x80));
SetBkColor(hDC, RGB(0xc0, 0xc0, 0xc0));
ExtTextOut(hDC, sImeG.rcCandText.left, sImeG.rcCandText.top,
ETO_OPAQUE, &sImeG.rcCandText, NULL, 0, NULL);
szStrBuf[0] = '1';
szStrBuf[1] = ':';
LenOfAll = 0;
for (i = 0; dwStart < dwEnd; dwStart++, i++) {
int iLen;
szStrBuf[LenOfAll++] = szDigit[i + CAND_START];
szStrBuf[LenOfAll++] = '.' ;
iLen = lstrlen((LPTSTR)((LPBYTE)lpCandList +
lpCandList->dwOffset[dwStart]));
CopyMemory(&szStrBuf[LenOfAll],
((LPBYTE)lpCandList + lpCandList->dwOffset[dwStart]),
iLen);
LenOfAll += iLen;
szStrBuf[LenOfAll] = '.';
szStrBuf[LenOfAll] = '.';
}
DrawConvexRect(hDC,0,0,sImeG.xCandWi-1,sImeG.yCandHi-1); //zl
PaintOP(hDC,hCandWnd);
{
int TopOfText = 2;
if (sImeG.yChiCharHi >0x10)
TopOfText = 0;
ExtTextOut(hDC, sImeG.rcCandText.left,
sImeG.rcCandText.top + TopOfText,
(UINT)0, NULL,
szStrBuf,
LenOfAll, NULL);
}
}
DeleteObject(SelectObject(hDC, hOldFont));
ImmUnlockIMCC(lpIMC->hPrivate);
ImmUnlockIMCC(lpIMC->hCandInfo);
ImmUnlockIMC(hIMC);
return;
}
/**********************************************************************/
/* PaintCandWindow() */
/**********************************************************************/
void PASCAL PaintCandWindow( // handle WM_PAINT message
HWND hCandWnd)
{
HDC hDC;
PAINTSTRUCT ps;
hDC = BeginPaint(hCandWnd, &ps);
UpdateCandWindow2(hCandWnd, hDC);
EndPaint(hCandWnd, &ps);
return;
}
/**********************************************************************/
/* CandWndProc() */
/**********************************************************************/
LRESULT CALLBACK CandWndProc(
HWND hCandWnd,
UINT uMsg,
WPARAM wParam,
LPARAM lParam)
{
switch (uMsg) {
case WM_CREATE:
sImeG.HomeBmp = LoadBitmap(hInst, szHome); //zl
sImeG.EndBmp = LoadBitmap(hInst, szEnd);
sImeG.PageUpBmp = LoadBitmap(hInst, szPageUp);
sImeG.PageDownBmp = LoadBitmap(hInst, szPageDown);
sImeG.NumbBmp = LoadBitmap(hInst, szNumb);
sImeG.SnumbBmp = LoadBitmap(hInst, szSnumb);
sImeG.Home2Bmp = LoadBitmap(hInst, szHome2);
sImeG.End2Bmp = LoadBitmap(hInst, szEnd2);
sImeG.PageUp2Bmp = LoadBitmap(hInst, szPageUp2);
sImeG.PgDown2Bmp = LoadBitmap(hInst, szPgDown2);
break;
case WM_DESTROY:
DeleteObject(sImeG.HomeBmp);
DeleteObject(sImeG.EndBmp);
DeleteObject(sImeG.PageUpBmp);
DeleteObject(sImeG.PageDownBmp);
DeleteObject(sImeG.NumbBmp );
DeleteObject(sImeG.SnumbBmp );
DeleteObject(sImeG.Home2Bmp);
DeleteObject(sImeG.End2Bmp);
DeleteObject(sImeG.PageUp2Bmp);
DeleteObject(sImeG.PgDown2Bmp);
DestroyCandWindow(hCandWnd);
break;
case WM_SETCURSOR:
CandSetCursor(hCandWnd, lParam);
break;
case WM_MOUSEMOVE:
if (GetWindowLong(hCandWnd, UI_MOVE_OFFSET) != WINDOW_NOT_DRAG) {
POINT ptCursor;
if (lpImeL->wImeStyle == IME_APRS_AUTO){
DrawDragBorder(hCandWnd,
GetWindowLong(hCandWnd, UI_MOVE_XY),
GetWindowLong(hCandWnd, UI_MOVE_OFFSET));
GetCursorPos(&ptCursor);
SetWindowLong(hCandWnd, UI_MOVE_XY,
MAKELONG(ptCursor.x, ptCursor.y));
DrawDragBorder(hCandWnd, MAKELONG(ptCursor.x, ptCursor.y),
GetWindowLong(hCandWnd, UI_MOVE_OFFSET));
}else MessageBeep(0);
} else {
return DefWindowProc(hCandWnd, uMsg, wParam, lParam);
}
break;
case WM_LBUTTONUP:
if (!CandButtonUp(hCandWnd)) {
return DefWindowProc(hCandWnd, uMsg, wParam, lParam);
}
break;
case WM_PAINT:
InvalidateRect(hCandWnd,0,1);
PaintCandWindow(hCandWnd);
break;
case WM_MOUSEACTIVATE:
return (MA_NOACTIVATE);
/* case WM_IME_NOTIFY:
if (wParam != IMN_SETCANDIDATEPOS) {
} else if (lpImeL->fdwModeConfig & MODE_CONFIG_OFF_CARET_UI) {
} else if (lParam & 0x0001) {
return SetCandPosition(hCandWnd);
} else {
}
break;*/
default:
return DefWindowProc(hCandWnd, uMsg, wParam, lParam);
}
return (0L);
}
/**********************************************************************/
/* 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|IME_PROP_IGNORE_UPKEYS|IME_PROP_CANDLIST_START_FROM_1;
lpImeInfo->fdwConversionCaps = IME_CMODE_NATIVE|IME_CMODE_FULLSHAPE|
/* IME_CMODE_CHARCODE|*/IME_CMODE_SOFTKBD|IME_CMODE_NOCONVERSION/*|
IME_CMODE_EUDC*/;
lpImeInfo->fdwSentenceCaps = TRUE;
// 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, (LPSTR)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);
}
BOOL FAR PASCAL ConfigDlgProc( // dialog procedure of configuration
HWND hDlg,
UINT uMessage,
WORD wParam,
LONG lParam)
{
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,
LPVOID lpData) // mode of dialog
{
switch (dwMode) {
case IME_CONFIG_GENERAL:
DoPropertySheet(hAppWnd,NULL);
ReInitIme(hAppWnd,lpImeL->wImeStyle); //#@1
break;
default:
return (FALSE);
break;
}
return (TRUE);
}
/**********************************************************************/
/* ImeConversionList() */
/**********************************************************************/
DWORD WINAPI ImeConversionList(
HIMC hIMC,
LPCTSTR lpszSrc,
LPCANDIDATELIST lpCandList,
DWORD uBufLen,
UINT uFlag)
{
return (UINT)0;
}
/**********************************************************************/
/* ImeDestroy() */
/* Return Value: */
/* TRUE - successful, FALSE - failure */
/**********************************************************************/
BOOL WINAPI ImeDestroy( // this dll is unloaded
UINT uReserved)
{
if (uReserved) {
return (FALSE);
}
// free the IME table or data base
// FreeTable();
return (TRUE);
}
/**********************************************************************/
/* SetPrivateSetting() */
/**********************************************************************/
void PASCAL SetPrivateFileSetting(
LPBYTE szBuf,
int cbBuf,
DWORD dwOffset,
LPCTSTR szSettingFile) // file for IME private related settings
{
TCHAR szSettingPath[MAX_PATH];
UINT uLen;
HANDLE hSettingFile;
DWORD dwWriteByte;
return;
}
/**********************************************************************/
/* Input2Sequence */
/* Return Value: */
/* LOWORD - Internal Code, HIWORD - sequence code */
/**********************************************************************/
LRESULT PASCAL Input2Sequence(
DWORD uVirtKey,
LPBYTE lpSeqCode)
{
return 0;
}
/**********************************************************************/
/* 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_SEQUENCE_TO_INTERNAL:
case IME_ESC_GET_EUDC_DICTIONARY:
case IME_ESC_SET_EUDC_DICTIONARY:
case IME_INPUTKEYTOSEQUENCE:
// will not supported in next version
// and not support 32 bit applications 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:
lRet = 0;
return (lRet);
case IME_ESC_GET_EUDC_DICTIONARY:
return (FALSE);
case IME_ESC_SET_EUDC_DICTIONARY:
return (FALSE);
case IME_INPUTKEYTOSEQUENCE:
return 0;
case IME_ESC_MAX_KEY:
return (lpImeL->nMaxKey);
case IME_ESC_IME_NAME:
{
TCHAR szIMEName[MAX_PATH];
if ( lpData == NULL )
return FALSE;
LoadString(hInst, IDS_IMENAME, szIMEName, sizeof(szIMEName) );
lstrcpy(lpData, szIMEName);
return (TRUE);
}
case IME_ESC_GETHELPFILENAME:
if ( lpData == NULL )
return FALSE;
lstrcpy(lpData, TEXT("winabc.hlp") );
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 =
// 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) {
return (FALSE);
}
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(BYTE) + sizeof(BYTE);
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) + 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,
LPPRIVCONTEXT lpImcP)
{
//if (lpIMC->fdwInit & INIT_STATUSWNDPOS) {
//} else if (!lpIMC->hWnd) {
//} else if (lpImcP->fdwInit & INIT_STATUSWNDPOS) {
//} else {
if (lpIMC->fdwInit & INIT_STATUSWNDPOS) {
} else if (!lpIMC->hWnd) {
} 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;
}
// DebugShow2 ("ptst.y,", lpIMC->ptStatusWndPos.y, "bottom" , sImeG.rcWorkArea.bottom);
if(!lpIMC->ptStatusWndPos.y) // == sImeG.rcWorkArea.bottom)
lpIMC->ptStatusWndPos.y = sImeG.rcWorkArea.bottom -
sImeG.yStatusHi;// - 2 * UI_MARGIN;// - 20;
else
lpIMC->ptStatusWndPos.y = sImeG.rcWorkArea.bottom -
sImeG.yStatusHi;// - 2 * UI_MARGIN;
//lpImcP->fdwInit |= INIT_STATUSWNDPOS;
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 if (lpImcP->fdwInit & INIT_COMPFORM) {
} else {
if (0/*lpImeL->fdwModeConfig & MODE_CONFIG_OFF_CARET_UI*/) {
// lpIMC->cfCompForm.ptCurrentPos.x = lpIMC->ptStatusWndPos.x +
// lpImeL->rcStatusText.right + lpImeL->cxCompBorder * 2 +
// UI_MARGIN;
// if (lpIMC->cfCompForm.ptCurrentPos.x + (lpImeL->nRevMaxKey *
// sImeG.xChiCharWi) > sImeG.rcWorkArea.right) {
// lpIMC->cfCompForm.ptCurrentPos.x = lpIMC->ptStatusWndPos.x -
// lpImeL->nRevMaxKey * sImeG.xChiCharWi -
// lpImeL->cxCompBorder * 3;
// }
} else {
lpIMC->cfCompForm.ptCurrentPos.x = lpIMC->ptStatusWndPos.x +
sImeG.xStatusWi + UI_MARGIN;
if (lpIMC->cfCompForm.ptCurrentPos.x + lpImeL->xCompWi >
sImeG.rcWorkArea.right) {
lpIMC->cfCompForm.ptCurrentPos.x = lpIMC->ptStatusWndPos.x -
lpImeL->xCompWi - lpImeL->cxCompBorder * 2 -
UI_MARGIN;
}
}
lpIMC->cfCompForm.ptCurrentPos.y = sImeG.rcWorkArea.bottom -
lpImeL->yCompHi;// - 2 * UI_MARGIN;
ScreenToClient(lpIMC->hWnd, &lpIMC->cfCompForm.ptCurrentPos);
lpImcP->fdwInit |= INIT_COMPFORM;
}
return;
}
/**********************************************************************/
/* Select() */
/* Return Value: */
/* TRUE - successful, FALSE - failure */
/**********************************************************************/
BOOL PASCAL Select(
HIMC hIMC,
LPINPUTCONTEXT lpIMC,
BOOL fSelect)
{
LPPRIVCONTEXT lpImcP;
sImeG.First = 0;
if (fSelect) { // init "every" fields of hPrivate, please!!!
if (lpIMC->cfCompForm.dwStyle == CFS_DEFAULT) {
} else {
}
if (!ClearCompStr(lpIMC)) {
return (FALSE);
}
if (!ClearCand(lpIMC)) {
return (FALSE);
}
ClearGuideLine(lpIMC);
}
if (!lpIMC->hPrivate) {
return (FALSE);
}
lpImcP = (LPPRIVCONTEXT)ImmLockIMCC(lpIMC->hPrivate);
if (!lpImcP) {
return (FALSE);
}
if (fSelect) { // init "every" fields of hPrivate, please!!!
static bFirstTimeCallHere = TRUE;
InterlockedIncrement( &lLock );
if ( bFirstTimeCallHere == TRUE ) {
// we move the following code here from the DLL_ATTACH_PROCESS to
// avoid application hang.
// With static variable bFirstTimeCallHere, we ensure the following
// code will be called only when the ImeSelect( ) is first called.
GetCurrentUserEMBPath( );
data_init( );
bFirstTimeCallHere = FALSE;
}
InterlockedDecrement( &lLock );
lpImcP->iImeState = CST_INIT; // init the IME state machine
lpImcP->fdwImeMsg = (DWORD)0; // no UI windpws show
lpImcP->dwCompChar = (DWORD)0;
lpImcP->fdwGcsFlag = (DWORD)0;
lpImcP->hSoftKbdWnd = NULL; // soft keyboard window
lpImcP->nShowSoftKbdCmd = 0;
lpIMC->fOpen = TRUE;
if (!(lpIMC->fdwInit & INIT_CONVERSION)) {
if(GetKeyState(VK_CAPITAL)&1)
lpIMC->fdwConversion = IME_CMODE_NOCONVERSION;
else
lpIMC->fdwConversion = IME_CMODE_NATIVE;
kb_mode = CIN_STD;
DispMode(hIMC);
lpIMC->fdwConversion |= IME_CMODE_SYMBOL;
lpIMC->fdwInit |= INIT_CONVERSION;
}else {
if (lpIMC->fdwConversion & IME_CMODE_SOFTKBD)
{
sImeG.First = 1;
}
}
if (lpIMC->fdwInit & INIT_SENTENCE) {
} else if (lpImeL->fModeConfig & MODE_CONFIG_PREDICT) {
lpIMC->fdwSentence = IME_SMODE_PHRASEPREDICT;
lpIMC->fdwInit |= INIT_SENTENCE;
} else {
}
if (!(lpIMC->fdwInit & INIT_LOGFONT)) {
HDC hDC;
HGDIOBJ hSysFont;
hDC = GetDC(NULL);
hSysFont = GetStockObject(SYSTEM_FONT);
GetObject(hSysFont, sizeof(LOGFONT), &lpIMC->lfFont.A);
ReleaseDC(NULL, hDC);
lpIMC->fdwInit |= INIT_LOGFONT;
}
// Get Current User's specific phrase table path
InitContext(lpIMC,lpImcP);
}
else
{
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;
// to load/free IME table
if (fSelect) {
InitCvtPara();
if (!lpImeL->cRefCount++) {
/* zst LoadTable() */ ;
}
} else {
if (!lpImeL->cRefCount) {
/* zst FreeTable() */ ;
}
}
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; //zl
lpIMC = (LPINPUTCONTEXT)ImmLockIMC(hIMC);
if (!lpIMC) {
return (FALSE);
}
if(lpIMC->hPrivate){
lpImcP = (LPPRIVCONTEXT)ImmLockIMCC(lpIMC->hPrivate); //zl
if (!lpImcP){ //zl
return (FALSE); //zl
} //zl
}else return(FALSE);
InitContext(lpIMC,lpImcP); //zl
// DispModeEx(0);
ImmUnlockIMCC(lpIMC->hPrivate); //zl
ImmUnlockIMC(hIMC);
}
return (TRUE);
}
/**********************************************************************/
/* ReInitIme() */
/**********************************************************************/
void PASCAL ReInitIme(
HWND hWnd ,
WORD WhatStyle)
{
HWND hStatusWnd,MainWnd;
POINT ptPos;
RECT rcStatusWnd,TempRect;
int cxBorder, cyBorder;
if (sImeG.unchanged)
return ;
// border + raising edge + sunken edge
cxBorder = GetSystemMetrics(SM_CXBORDER) +
GetSystemMetrics(SM_CXEDGE) * 2;
cyBorder = GetSystemMetrics(SM_CYBORDER) +
GetSystemMetrics(SM_CYEDGE) * 2;
//if (!WhatStyle){
if (WhatStyle==IME_APRS_AUTO){
lpImeL->rcCompText.left = 4;
lpImeL->rcCompText.top =4;
lpImeL->rcCompText.right = sImeG.TextLen+5;
lpImeL->rcCompText.bottom = sImeG.yStatusHi-4;//6;
lpImeL->cxCompBorder = cxBorder;
lpImeL->cyCompBorder = cyBorder;
// set the width & height for composition window
lpImeL->xCompWi = lpImeL->rcCompText.right + /*lpImeL->cxCompBorder*/3 * 2;
//lpImeL->yCompHi = lpImeL->rcCompText.bottom +/* lpImeL->cyCompBorder*/3 * 2+1;//zl
lpImeL->yCompHi = sImeG.yStatusHi;//lpImeL->rcCompText.bottom +/* lpImeL->cyCompBorder*/3 * 2+1;//zl
} else {
// text position relative to the composition window
lpImeL->rcCompText.left = 4;
lpImeL->rcCompText.top = 4;
lpImeL->rcCompText.right = sImeG.TextLen+5;
lpImeL->rcCompText.bottom = sImeG.yStatusHi-4;//6;/*cyBorder;*/
lpImeL->cxCompBorder = cxBorder;
lpImeL->cyCompBorder = cyBorder;
// set the width & height for composition window
lpImeL->xCompWi = lpImeL->rcCompText.right + /*lpImeL->cxCompBorder*/3 * 2;
lpImeL->yCompHi = sImeG.yStatusHi; //zl
}
// border + raising edge + sunken edge
cxBorder = GetSystemMetrics(SM_CXBORDER) +
GetSystemMetrics(SM_CXEDGE) /* 2*/;
cyBorder = GetSystemMetrics(SM_CYBORDER) +
GetSystemMetrics(SM_CYEDGE) /* 2*/;
//if (!WhatStyle){
if (WhatStyle==IME_APRS_AUTO){
sImeG.rcCandText.left = 4;
sImeG.rcCandText.top = 4;
sImeG.rcCandText.right = sImeG.xChiCharWi * 7;
sImeG.rcCandText.bottom = sImeG.yChiCharHi * CANDPERPAGE+1;//zl
sImeG.cxCandBorder = cxBorder+3;
sImeG.cyCandBorder = cyBorder+3;
sImeG.xCandWi = sImeG.rcCandText.right + sImeG.cxCandBorder * 2+3;//zl
sImeG.yCandHi = sImeG.rcCandText.bottom + sImeG.cyCandBorder *2+12;
sImeG.rcHome.left = 4 ;
sImeG.rcHome.top = sImeG.rcCandText.bottom+6 ;
sImeG.rcHome.right = sImeG.rcHome.left + 14 ;
sImeG.rcHome.bottom = sImeG.rcHome.top +14 ;
sImeG.rcEnd.left = sImeG.rcHome.right ;
sImeG.rcEnd.top = sImeG.rcHome.top ;
sImeG.rcEnd.right = sImeG.rcEnd.left + 14 ;
sImeG.rcEnd.bottom = sImeG.rcHome.bottom ;
sImeG.rcPageDown.top = sImeG.rcHome.top ;
sImeG.rcPageDown.right = sImeG.xCandWi-4;
sImeG.rcPageDown.left = sImeG.rcPageDown.right - 14 ;
sImeG.rcPageDown.bottom = sImeG.rcHome.bottom ;
sImeG.rcPageUp.top = sImeG.rcHome.top ;
sImeG.rcPageUp.right = sImeG.rcPageDown.left ;
sImeG.rcPageUp.left = sImeG.rcPageUp.right -14 ;
sImeG.rcPageUp.bottom = sImeG.rcHome.bottom ;
}else{
sImeG.cxCandBorder = cxBorder;
sImeG.cyCandBorder = cyBorder;
sImeG.xCandWi = lpImeL->xCompWi + sImeG.xStatusWi - cxBorder+1;
sImeG.yCandHi = sImeG.yStatusHi; //sImeG.yChiCharHi+3 + sImeG.cyCandBorder *2;
sImeG.rcHome.left = 3; //2;
sImeG.rcHome.top = 4;//7;
sImeG.rcHome.right = sImeG.rcHome.left + 10; //14;
sImeG.rcHome.bottom = sImeG.rcHome.top +8; //14 ;
sImeG.rcEnd.left =sImeG.rcHome.left; //sImeG.rcHome.right ;
sImeG.rcEnd.top = sImeG.rcHome.top+9; //14 ;
sImeG.rcEnd.right =sImeG.rcHome.right; //sImeG.rcEnd.left + 14 ;
sImeG.rcEnd.bottom = sImeG.rcHome.bottom+10; //14 ;
sImeG.rcPageDown.top = sImeG.rcEnd.top;//sImeG.rcHome.top ;
sImeG.rcPageDown.right = sImeG.xCandWi-1;//2;
sImeG.rcPageDown.left = sImeG.rcPageDown.right - 14 ;
sImeG.rcPageDown.bottom = sImeG.rcEnd.bottom ;//sImeG.rcHome.bottom ;
sImeG.rcPageUp.top = sImeG.rcHome.top -1; //zl
sImeG.rcPageUp.right = sImeG.rcPageDown.right+1;//zl;sImeG.rcPageDown.left ;
sImeG.rcPageUp.left = sImeG.rcPageDown.left;//sImeG.rcPageUp.right -14 ;
sImeG.rcPageUp.bottom = sImeG.rcHome.bottom ;
sImeG.rcCandText.left = sImeG.rcEnd.right+2;//1;//4;//sImeG.rcEnd.right;
sImeG.rcCandText.top = 4;
sImeG.rcCandText.right = sImeG.rcPageUp.left-4;//2;//sImeG.rcPageUp.left-2;
sImeG.rcCandText.bottom = sImeG.yChiCharHi+7;//6;//3;
}
/* ptPos.x = 0 ;
ptPos.y = 0 ;
ClientToScreen(hWnd, &ptPos);
lpImeL->ptDefComp.x = ptPos.x + sImeG.xStatusWi - cxBorder*2;
lpImeL->ptDefComp.y = ptPos.y - cyBorder;
lpImeL->ptDefCand.x = ptPos.x - cxBorder;
lpImeL->ptDefCand.y = ptPos.y - sImeG.yCandHi-2;
if ((sImeG.rcWorkArea.right-lpImeL->ptDefComp.x -lpImeL->xCompWi)<10)
{lpImeL->ptDefComp.x = ptPos.x - lpImeL->xCompWi;
lpImeL->ptDefCand.x = lpImeL->ptDefComp.x ;}
if ((ptPos.y - sImeG.yCandHi)< (sImeG.rcWorkArea.top+5))
lpImeL->ptDefCand.y = ptPos.y + sImeG.yStatusHi; //sImeG.yCandHi+2;
*/
if (hWnd){
ptPos.x = 0 ;
ptPos.y = 0 ;
ClientToScreen(hWnd, &ptPos);
CountDefaultComp(ptPos.x,ptPos.y,sImeG.rcWorkArea);
lpImeL->ptDefComp.x = ptPos.x + sImeG.xStatusWi - cxBorder*2+4;//zl
lpImeL->ptDefComp.y = ptPos.y - cyBorder+3;//2;//3; //zl
lpImeL->ptDefCand.x = ptPos.x - cxBorder+3; //zl
lpImeL->ptDefCand.y = ptPos.y - sImeG.yCandHi-2+2;//zl
if ((sImeG.rcWorkArea.right-lpImeL->ptDefComp.x -lpImeL->xCompWi)<10){
lpImeL->ptDefComp.x = ptPos.x - lpImeL->xCompWi;
lpImeL->ptDefCand.x = lpImeL->ptDefComp.x ;
}
if ((ptPos.y - sImeG.yCandHi)< (sImeG.rcWorkArea.top+5))
lpImeL->ptDefCand.y = ptPos.y + sImeG.yStatusHi-4; //sImeG.yCandHi+2;
}else{
ptPos.x = lpImeL->Ox ;
ptPos.y = lpImeL->Oy ;
lpImeL->ptDefComp.x = sImeG.xStatusWi - cxBorder*2;
lpImeL->ptDefComp.y = sImeG.rcWorkArea.bottom - sImeG.yStatusHi;
lpImeL->ptDefCand.x = lpImeL->ptDefComp.x + lpImeL->xCompWi;
lpImeL->ptDefCand.y = lpImeL->ptDefComp.y ;
/*
if ((sImeG.rcWorkArea.right-lpImeL->ptDefComp.x -lpImeL->xCompWi)<10)
{lpImeL->ptDefComp.x = ptPos.x - lpImeL->xCompWi;
lpImeL->ptDefCand.x = lpImeL->ptDefComp.x ;}
if ((ptPos.y - sImeG.yCandHi)< (sImeG.rcWorkArea.top+5))
lpImeL->ptDefCand.y = ptPos.y + sImeG.yCandHi+2;
*/
}
fmt_transfer();
CandWndChange = 1;
CompWndChange = 1;
return ;
}
void PASCAL ReInitIme2(
HWND hWnd ,
WORD WhatStyle)
{
HWND hStatusWnd,MainWnd;
POINT ptPos;
RECT rcStatusWnd,TempRect;
int cxBorder, cyBorder;
if (sImeG.unchanged)
return ;
// border + raising edge + sunken edge
cxBorder = GetSystemMetrics(SM_CXBORDER) +
GetSystemMetrics(SM_CXEDGE) * 2;
cyBorder = GetSystemMetrics(SM_CYBORDER) +
GetSystemMetrics(SM_CYEDGE) * 2;
if (!WhatStyle){
lpImeL->rcCompText.left = 4;
lpImeL->rcCompText.top =4;
lpImeL->rcCompText.right = sImeG.TextLen+5;
lpImeL->rcCompText.bottom = sImeG.yStatusHi-4;//6;
lpImeL->cxCompBorder = cxBorder;
lpImeL->cyCompBorder = cyBorder;
// set the width & height for composition window
lpImeL->xCompWi = lpImeL->rcCompText.right + /*lpImeL->cxCompBorder*/3 * 2;
//lpImeL->yCompHi = lpImeL->rcCompText.bottom +/* lpImeL->cyCompBorder*/3 * 2+1;//zl
lpImeL->yCompHi = sImeG.yStatusHi;//lpImeL->rcCompText.bottom +/* lpImeL->cyCompBorder*/3 * 2+1;//zl
} else {
// text position relative to the composition window
lpImeL->rcCompText.left = 4;
lpImeL->rcCompText.top = 4;
lpImeL->rcCompText.right = sImeG.TextLen+5;
lpImeL->rcCompText.bottom = sImeG.yStatusHi-4;//6;/*cyBorder;*/
lpImeL->cxCompBorder = cxBorder;
lpImeL->cyCompBorder = cyBorder;
// set the width & height for composition window
lpImeL->xCompWi = lpImeL->rcCompText.right + /*lpImeL->cxCompBorder*/3 * 2;
lpImeL->yCompHi = sImeG.yStatusHi; //zl
}
// border + raising edge + sunken edge
cxBorder = GetSystemMetrics(SM_CXBORDER) +
GetSystemMetrics(SM_CXEDGE) /* 2*/;
cyBorder = GetSystemMetrics(SM_CYBORDER) +
GetSystemMetrics(SM_CYEDGE) /* 2*/;
if (!WhatStyle){
sImeG.rcCandText.left = 4;
sImeG.rcCandText.top = 4;
sImeG.rcCandText.right = sImeG.xChiCharWi * 7;
sImeG.rcCandText.bottom = sImeG.yChiCharHi * CANDPERPAGE+1;//zl
sImeG.cxCandBorder = cxBorder+3;
sImeG.cyCandBorder = cyBorder+3;
sImeG.xCandWi = sImeG.rcCandText.right + sImeG.cxCandBorder * 2+3;//zl
sImeG.yCandHi = sImeG.rcCandText.bottom + sImeG.cyCandBorder *2+12;
sImeG.rcHome.left = 4 ;
sImeG.rcHome.top = sImeG.rcCandText.bottom+6 ;
sImeG.rcHome.right = sImeG.rcHome.left + 14 ;
sImeG.rcHome.bottom = sImeG.rcHome.top +14 ;
sImeG.rcEnd.left = sImeG.rcHome.right ;
sImeG.rcEnd.top = sImeG.rcHome.top ;
sImeG.rcEnd.right = sImeG.rcEnd.left + 14 ;
sImeG.rcEnd.bottom = sImeG.rcHome.bottom ;
sImeG.rcPageDown.top = sImeG.rcHome.top ;
sImeG.rcPageDown.right = sImeG.xCandWi-4;
sImeG.rcPageDown.left = sImeG.rcPageDown.right - 14 ;
sImeG.rcPageDown.bottom = sImeG.rcHome.bottom ;
sImeG.rcPageUp.top = sImeG.rcHome.top ;
sImeG.rcPageUp.right = sImeG.rcPageDown.left ;
sImeG.rcPageUp.left = sImeG.rcPageUp.right -14 ;
sImeG.rcPageUp.bottom = sImeG.rcHome.bottom ;
}else{
sImeG.cxCandBorder = cxBorder;
sImeG.cyCandBorder = cyBorder;
sImeG.xCandWi = lpImeL->xCompWi + sImeG.xStatusWi - cxBorder+1;
sImeG.yCandHi = sImeG.yStatusHi; //sImeG.yChiCharHi+3 + sImeG.cyCandBorder *2;
sImeG.rcHome.left = 3; //2;
sImeG.rcHome.top = 4;//7;
sImeG.rcHome.right = sImeG.rcHome.left + 10; //14;
sImeG.rcHome.bottom = sImeG.rcHome.top +8; //14 ;
sImeG.rcEnd.left =sImeG.rcHome.left; //sImeG.rcHome.right ;
sImeG.rcEnd.top = sImeG.rcHome.top+9; //14 ;
sImeG.rcEnd.right =sImeG.rcHome.right; //sImeG.rcEnd.left + 14 ;
sImeG.rcEnd.bottom = sImeG.rcHome.bottom+10; //14 ;
sImeG.rcPageDown.top = sImeG.rcEnd.top;//sImeG.rcHome.top ;
sImeG.rcPageDown.right = sImeG.xCandWi-1;//2;
sImeG.rcPageDown.left = sImeG.rcPageDown.right - 14 ;
sImeG.rcPageDown.bottom = sImeG.rcEnd.bottom ;//sImeG.rcHome.bottom ;
sImeG.rcPageUp.top = sImeG.rcHome.top -1; //zl
sImeG.rcPageUp.right = sImeG.rcPageDown.right+1;//zl;sImeG.rcPageDown.left ;
sImeG.rcPageUp.left = sImeG.rcPageDown.left;//sImeG.rcPageUp.right -14 ;
sImeG.rcPageUp.bottom = sImeG.rcHome.bottom ;
sImeG.rcCandText.left = sImeG.rcEnd.right+2;//1;//4;//sImeG.rcEnd.right;
sImeG.rcCandText.top = 4;
sImeG.rcCandText.right = sImeG.rcPageUp.left-4;//2;//sImeG.rcPageUp.left-2;
sImeG.rcCandText.bottom = sImeG.yChiCharHi+7;//6;//3;
}
if (hWnd){
ptPos.x = 0 ;
ptPos.y = 0 ;
ClientToScreen(hWnd, &ptPos);
lpImeL->ptDefComp.x = ptPos.x + sImeG.xStatusWi - cxBorder*2+4;//zl
lpImeL->ptDefComp.y = ptPos.y - cyBorder+3;//2;//3; //zl
lpImeL->ptDefCand.x = ptPos.x - cxBorder+3; //zl
lpImeL->ptDefCand.y = ptPos.y - sImeG.yCandHi-2+2;//zl
if ((sImeG.rcWorkArea.right-lpImeL->ptDefComp.x -lpImeL->xCompWi)<10){
lpImeL->ptDefComp.x = ptPos.x - lpImeL->xCompWi;
lpImeL->ptDefCand.x = lpImeL->ptDefComp.x ;
}
if ((ptPos.y - sImeG.yCandHi)< (sImeG.rcWorkArea.top+5))
lpImeL->ptDefCand.y = ptPos.y + sImeG.yStatusHi-4; //sImeG.yCandHi+2;
}else{
ptPos.x = lpImeL->Ox ;
ptPos.y = lpImeL->Oy ;
lpImeL->ptDefComp.x = sImeG.xStatusWi - cxBorder*2;
lpImeL->ptDefComp.y = sImeG.rcWorkArea.bottom - sImeG.yStatusHi;
lpImeL->ptDefCand.x = lpImeL->ptDefComp.x + lpImeL->xCompWi;
lpImeL->ptDefCand.y = lpImeL->ptDefComp.y ;
}
return ;
}
/**********************************************************************/
/* InitUserSetting() */
/**********************************************************************/
int InitUserSetting(void)
{
HKEY hKey,hFirstKey;
DWORD dwSize, dx;
int lRet;
RegCreateKey(HKEY_CURRENT_USER, szRegNearCaret, &hFirstKey);
RegCreateKey(hFirstKey, szAIABC, &hKey);
RegCloseKey(hFirstKey);
//1 KeyType
dwSize = sizeof(dwSize);
lRet = RegQueryValueEx(hKey, szKeyType, NULL, NULL,
(LPBYTE)&dx, &dwSize);
if (lRet != ERROR_SUCCESS) {
dx = 0;
RegSetValueEx(hKey,szKeyType , 0, REG_DWORD,
(LPBYTE)&dx, sizeof(int));
}else {
sImeG.KbType =(BYTE)dx ;
}
// 2 ImeStyle
dwSize = sizeof(dwSize);
lRet = RegQueryValueEx(hKey,szImeStyle , NULL, NULL,
(LPBYTE)&dx, &dwSize);
if (lRet != ERROR_SUCCESS) {
dx = 0;
RegSetValueEx(hKey,szImeStyle, 0, REG_DWORD,
(LPBYTE)&dx, sizeof(int));
}else {
lpImeL->wImeStyle = (WORD)dx ;
}
// 3 AutoCp
dwSize = sizeof(dwSize);
lRet = RegQueryValueEx(hKey, szCpAuto, NULL, NULL,
(LPBYTE)&dx, &dwSize);
if (lRet != ERROR_SUCCESS) {
dx = 0;
RegSetValueEx(hKey,szCpAuto, 0, REG_DWORD,
(LPBYTE)&dx, sizeof(int));
}else {
sImeG.auto_mode =(BYTE)dx ;
}
// 4 BxFlag
dwSize = sizeof(dwSize);
lRet = RegQueryValueEx(hKey, szBxFlag , NULL, NULL,
(LPBYTE)&dx, &dwSize);
if (lRet != ERROR_SUCCESS) {
dx = 0;
RegSetValueEx(hKey, szBxFlag , 0, REG_DWORD,
(LPBYTE)&dx, sizeof(int));
}else {
sImeG.cbx_flag =(BYTE)dx ;
}
// 5 TuneFlag
dwSize = sizeof(dwSize);
lRet = RegQueryValueEx(hKey, szTuneFlag , NULL, NULL,
(LPBYTE)&dx, &dwSize);
if (lRet != ERROR_SUCCESS) {
dx = 0;
RegSetValueEx(hKey, szTuneFlag , 0, REG_DWORD,
(LPBYTE)&dx, sizeof(int));
}else {
sImeG.tune_flag=(BYTE)dx ;
}
// 6 AutoCvt
dwSize = sizeof(dwSize);
lRet = RegQueryValueEx(hKey, szAutoCvt , NULL, NULL,
(LPBYTE)&dx, &dwSize);
if (lRet != ERROR_SUCCESS) {
dx = 0;
RegSetValueEx(hKey, szAutoCvt, 0, REG_DWORD,
(LPBYTE)&dx, sizeof(int));
}else {
sImeG.auto_cvt_flag=(BYTE)dx ;
}
// 7 SdaHelp
dwSize = sizeof(dwSize);
lRet = RegQueryValueEx(hKey, szSdaHelp , NULL, NULL,
(LPBYTE)&dx, &dwSize);
if (lRet != ERROR_SUCCESS) {
dx = 0;
RegSetValueEx(hKey, szSdaHelp, 0, REG_DWORD,
(LPBYTE)&dx, sizeof(int));
}else {
sImeG.SdOpenFlag=(BYTE)dx ;
}
RegCloseKey(hKey);
//ReInitIme2(NULL, lpImeL->wImeStyle);
return 0;
}
/**********************************************************************/
/* ChangeUserSetting() */
/**********************************************************************/
ChangeUserSetting()
{
HKEY hKey,hFirstKey;
DWORD dwSize, dx;
int lRet;
RegCreateKey(HKEY_CURRENT_USER, szRegNearCaret, &hFirstKey);
RegCreateKey(hFirstKey, szAIABC, &hKey);
RegCloseKey(hFirstKey);
RegSetValueEx(hKey, szKeyType, 0, REG_DWORD,
(LPBYTE)&sImeG.KbType, sizeof(int));
RegSetValueEx(hKey, szImeStyle, 0, REG_DWORD,
(LPBYTE)&lpImeL->wImeStyle, sizeof(int));
RegSetValueEx(hKey, szCpAuto, 0, REG_DWORD,
(LPBYTE)&sImeG.auto_mode, sizeof(int));
RegSetValueEx(hKey, szBxFlag, 0, REG_DWORD,
(LPBYTE)&sImeG.cbx_flag, sizeof(int));
RegSetValueEx(hKey, szTuneFlag, 0, REG_DWORD,
(LPBYTE)&sImeG.tune_flag, sizeof(int));
RegSetValueEx(hKey, szAutoCvt, 0, REG_DWORD,
(LPBYTE)&sImeG.auto_cvt_flag, sizeof(int));
RegSetValueEx(hKey, szSdaHelp, 0, REG_DWORD,
(LPBYTE)&sImeG.SdOpenFlag, sizeof(int));
RegCloseKey(hKey);
return 0;
}
/**********************************************************************/
/* InitImeGlobalData() */
/**********************************************************************/
void PASCAL InitImeGlobalData(
HINSTANCE hInstance)
{
int cxBorder, cyBorder;
HDC hDC;
BYTE szChiChar[4];
SIZE lTextSize;
HGLOBAL hResData;
int i;
DWORD dwSize;
HKEY hKeyIMESetting;
LONG lRet;
BYTE NumChar[]="1.2.3.4.5.6.7.8.9.";
BYTE CNumChar[]="<EFBFBD><EFBFBD><EFBFBD><EFBFBD>ԭ<EFBFBD>ϲ<EFBFBD>һ<EFBFBD><EFBFBD>һ<EFBFBD><EFBFBD><EFBFBD><EFBFBD>";
SIZE hSize;
sImeG.WhitePen = GetStockObject(WHITE_PEN);
sImeG.BlackPen = GetStockObject(BLACK_PEN);
sImeG.GrayPen = CreatePen(PS_SOLID, 1, 0x00808080);
sImeG.LightGrayPen = CreatePen(PS_SOLID, 1, 0x00c0c0c0);
hInst = hInstance;
// get the UI class name
LoadString(hInst, IDS_IMEUICLASS, szUIClassName, sizeof(szUIClassName));
// get the composition class name
LoadString(hInst, IDS_IMECOMPCLASS, szCompClassName, sizeof(szCompClassName));
// get the candidate class name
LoadString(hInst, IDS_IMECANDCLASS, szCandClassName, sizeof(szCandClassName));
// get the status class name
LoadString(hInst, IDS_IMESTATUSCLASS, szStatusClassName, sizeof(szStatusClassName));
// work area
SystemParametersInfo(SPI_GETWORKAREA, 0, &sImeG.rcWorkArea, 0);
// border + raising edge + sunken edge
cxBorder = GetSystemMetrics(SM_CXBORDER) + GetSystemMetrics(SM_CXEDGE) /* 2*/;
cyBorder = GetSystemMetrics(SM_CYBORDER) + GetSystemMetrics(SM_CYEDGE) /* 2*/;
// get the Chinese char
LoadString(hInst, IDS_CHICHAR, szChiChar, sizeof(szChiChar));
// get size of Chinese char
hDC = GetDC(NULL);
GetTextExtentPoint32(hDC, "<EFBFBD><EFBFBD>", 2, &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);
}
GetTextExtentPoint32(hDC,(LPCTSTR)"2.", 2, &hSize);
sImeG.Ajust = hSize.cx;
// get text metrics to decide the width & height of composition window
// these IMEs always use system font to show
GetTextExtentPoint32(hDC,(LPCTSTR)&CNumChar, 20, &hSize);
sImeG.TextLen = hSize.cx +2;//zl
sImeG.xChiCharWi = lTextSize.cx;
sImeG.yChiCharHi = lTextSize.cy;
// the width/high and status position relative to status window
sImeG.rcStatusText.left = 0;
sImeG.rcStatusText.top = 0;
sImeG.rcStatusText.right = STATUS_DIM_X * 5+6+20;//4; // chg
sImeG.rcStatusText.bottom = STATUS_DIM_Y;
sImeG.xStatusWi = STATUS_DIM_X * 5 + cxBorder * 2+3+18 ; //chg
if(sImeG.yChiCharHi==0x10)
sImeG.yStatusHi = STATUS_DIM_Y + cyBorder * 2-1; //zl
else
sImeG.yStatusHi = STATUS_DIM_Y + cyBorder * 2-1+2;
// left bottom of status
sImeG.rcInputText.left = sImeG.rcStatusText.left+3;//2; //zl
sImeG.rcInputText.top = sImeG.rcStatusText.top ; //zl
sImeG.rcInputText.right = sImeG.rcInputText.left + STATUS_DIM_X; //z
sImeG.rcInputText.bottom = sImeG.rcStatusText.bottom;
// no. 2 bottom of status
sImeG.rcCmdText.left = sImeG.rcInputText.right+1;//95.9.23+1;
sImeG.rcCmdText.top = sImeG.rcStatusText.top -1; //zl
sImeG.rcCmdText.right = sImeG.rcCmdText.left + STATUS_DIM_X+20; //zl
sImeG.rcCmdText.bottom = sImeG.rcStatusText.bottom;
// no. 3 bottom of status
sImeG.rcShapeText.left =sImeG.rcCmdText.right;//+1;
sImeG.rcShapeText.top = sImeG.rcStatusText.top - 1; //zl
sImeG.rcShapeText.right = sImeG.rcShapeText.left + STATUS_DIM_X; //zl
sImeG.rcShapeText.bottom = sImeG.rcStatusText.bottom;
// no 4 bottom of status
sImeG.rcPctText.left =sImeG.rcShapeText.right;
sImeG.rcPctText.top = sImeG.rcStatusText.top -1; //zl
sImeG.rcPctText.right = sImeG.rcPctText.left + STATUS_DIM_X; //zl
sImeG.rcPctText.bottom = sImeG.rcStatusText.bottom;
// 5
// right bottom of status
sImeG.rcSKText.left = sImeG.rcPctText.right;
sImeG.rcSKText.top = sImeG.rcStatusText.top - 1;
sImeG.rcSKText.right = sImeG.rcSKText.left + STATUS_DIM_X; //zl
sImeG.rcSKText.bottom = sImeG.rcStatusText.bottom;
// full shape space
sImeG.wFullSpace = sImeG.wFullABC[0];
// reverse internal code to internal code, NT don't need it
for (i = 0; i < (sizeof(sImeG.wFullABC) / 2); i++) {
sImeG.wFullABC[i] = (sImeG.wFullABC[i] << 8) |
(sImeG.wFullABC[i] >> 8);
}
LoadString(hInst, IDS_STATUSERR, sImeG.szStatusErr,
sizeof(sImeG.szStatusErr));
sImeG.cbStatusErr = lstrlen(sImeG.szStatusErr);
sImeG.iCandStart = CAND_START;
sImeG.Prop = 0;
// get the UI offset for near caret operation
RegCreateKey(HKEY_CURRENT_USER, szRegIMESetting, &hKeyIMESetting);
dwSize = sizeof(dwSize);
lRet = RegQueryValueEx(hKeyIMESetting, szPara, NULL, NULL,
(LPBYTE)&sImeG.iPara, &dwSize);
if (lRet != ERROR_SUCCESS) {
sImeG.iPara = 0;
RegSetValueEx(hKeyIMESetting, szPara, (DWORD)0, REG_BINARY,
(LPBYTE)&sImeG.iPara, sizeof(int));
}
dwSize = sizeof(dwSize);
lRet = RegQueryValueEx(hKeyIMESetting, szPerp, NULL, NULL,
(LPBYTE)&sImeG.iPerp, &dwSize);
if (lRet != ERROR_SUCCESS) {
sImeG.iPerp = sImeG.yChiCharHi;
RegSetValueEx(hKeyIMESetting, szPerp, (DWORD)0, REG_BINARY,
(LPBYTE)&sImeG.iPerp, sizeof(int));
}
dwSize = sizeof(dwSize);
lRet = RegQueryValueEx(hKeyIMESetting, szParaTol, NULL, NULL,
(LPBYTE)&sImeG.iParaTol, &dwSize);
if (lRet != ERROR_SUCCESS) {
sImeG.iParaTol = sImeG.xChiCharWi * 4;
RegSetValueEx(hKeyIMESetting, szParaTol, (DWORD)0, REG_BINARY,
(LPBYTE)&sImeG.iParaTol, sizeof(int));
}
dwSize = sizeof(dwSize);
lRet = RegQueryValueEx(hKeyIMESetting, szPerpTol, NULL, NULL,
(LPBYTE)&sImeG.iPerpTol, &dwSize);
if (lRet != ERROR_SUCCESS) {
sImeG.iPerpTol = lTextSize.cy;
RegSetValueEx(hKeyIMESetting,
szPerpTol,
(DWORD)0,
REG_BINARY,
(LPBYTE)&sImeG.iPerpTol,
sizeof(int));
}
RegCloseKey(hKeyIMESetting);
ReleaseDC(NULL, hDC);
return;
}
/**********************************************************************/
/* InitImeLocalData() */
/**********************************************************************/
BOOL PASCAL InitImeLocalData(
HINSTANCE hInstL)
{
HGLOBAL hResData;
int cxBorder, cyBorder;
register int i;
register WORD nSeqCode;
lpImeL->hInst = hInstL;
// load valid char in choose/input state
lpImeL->nMaxKey = 20 ;
// border + raising edge + sunken edge
cxBorder = GetSystemMetrics(SM_CXBORDER) +
GetSystemMetrics(SM_CXEDGE) * 2;
cyBorder = GetSystemMetrics(SM_CYBORDER) +
GetSystemMetrics(SM_CYEDGE) * 2;
// text position relative to the composition window
lpImeL->rcCompText.left = 3;
lpImeL->rcCompText.top = 3;
lpImeL->rcCompText.right = sImeG.xChiCharWi * lpImeL->nMaxKey/2+3;
lpImeL->rcCompText.bottom = sImeG.yChiCharHi+3;
lpImeL->cxCompBorder = cxBorder;
lpImeL->cyCompBorder = cyBorder;
// set the width & height for composition window
lpImeL->xCompWi = lpImeL->rcCompText.right + /*lpImeL->cxCompBorder*/3 * 2;
lpImeL->yCompHi = lpImeL->rcCompText.bottom +/* lpImeL->cyCompBorder*/3 * 2;
// default position of composition window
lpImeL->ptDefComp.x = sImeG.rcWorkArea.right -
lpImeL->yCompHi - cxBorder;
lpImeL->ptDefComp.y = sImeG.rcWorkArea.bottom -
lpImeL->xCompWi - cyBorder;
lpImeL->Ox = lpImeL->ptDefComp.x;
lpImeL->Oy = lpImeL->ptDefComp.y;
return (TRUE);
}
/**********************************************************************/
/* RegisterImeClass() */
/**********************************************************************/
void PASCAL RegisterImeClass(
HINSTANCE hInstance,
HINSTANCE hInstL)
{
WNDCLASSEX wcWndCls;
// IME UI class
wcWndCls.cbSize = sizeof(WNDCLASSEX);
wcWndCls.cbClsExtra = 0;
wcWndCls.cbWndExtra = sizeof(LONG) * 2;
wcWndCls.hIcon = LoadImage(hInstL, MAKEINTRESOURCE(IDI_IME),
IMAGE_ICON, 32, 32, LR_DEFAULTCOLOR);
wcWndCls.hInstance = hInstance;
wcWndCls.hCursor = LoadCursor(NULL, IDC_ARROW);
wcWndCls.hbrBackground = GetStockObject(LTGRAY_BRUSH/*NULL_BRUSH*/);
wcWndCls.lpszMenuName = (LPSTR)NULL;
wcWndCls.hIconSm = LoadImage(hInstL, MAKEINTRESOURCE(IDI_IME),
IMAGE_ICON, 16, 16, LR_DEFAULTCOLOR);
// IME UI class
if (!GetClassInfoEx(hInstance, szUIClassName, &wcWndCls)) {
wcWndCls.style = CS_IME;
wcWndCls.lpfnWndProc = UIWndProc;
wcWndCls.lpszClassName = (LPSTR)szUIClassName;
RegisterClassEx(&wcWndCls);
}
wcWndCls.style = CS_IME|CS_HREDRAW|CS_VREDRAW;
// IME composition class
if (!GetClassInfoEx(hInstance, szCompClassName, &wcWndCls)) {
wcWndCls.lpfnWndProc = CompWndProc;
wcWndCls.lpszClassName = (LPSTR)szCompClassName;
RegisterClassEx(&wcWndCls);
}
// IME candidate class
if (!GetClassInfoEx(hInstance, szCandClassName, &wcWndCls)) {
wcWndCls.lpfnWndProc = CandWndProc;
wcWndCls.hbrBackground = GetStockObject(LTGRAY_BRUSH);
wcWndCls.lpszClassName = (LPSTR)szCandClassName;
RegisterClassEx(&wcWndCls);
}
// IME status class
if (!GetClassInfoEx(hInstance, szStatusClassName, &wcWndCls)) {
wcWndCls.lpfnWndProc = StatusWndProc;
wcWndCls.lpszClassName = (LPSTR)szStatusClassName;
RegisterClassEx(&wcWndCls);
}
if (!GetClassInfoEx(hInstance, "Abc95Menu", &wcWndCls)) {
wcWndCls.style = 0;
wcWndCls.cbWndExtra = WND_EXTRA_SIZE;
wcWndCls.hbrBackground = GetStockObject(NULL_BRUSH);
wcWndCls.lpfnWndProc = ContextMenuWndProc;
wcWndCls.lpszClassName = "Abc95Menu";
RegisterClassEx(&wcWndCls);
}
return;
}
/**********************************************************************/
/* QuitBefore() */
/* Return Value: */
/* TRUE - successful */
/* FALSE - failure */
/**********************************************************************/
int WINAPI QuitBefore()
{
GlobalUnlock(cisu_hd);
if(cisu_hd)
GlobalFree(cisu_hd);
return 0;
}
/**********************************************************************/
/* ImeDllInit() */
/* Return Value: */
/* TRUE - successful */
/* FALSE - failure */
/**********************************************************************/
BOOL CALLBACK ImeDllInit(
HINSTANCE hInstance, // instance handle of this library
DWORD fdwReason, // reason called
LPVOID lpvReserve) // reserve pointer
{
// DebugShow("Init Stat",NULL);
switch (fdwReason) {
case DLL_PROCESS_ATTACH:
if (!hInst) {
InitImeGlobalData(hInstance);
// data_init(); /* move to the Select( ) to avoid app hang */
}
if (!lpImeL) {
lpImeL = &sImeL;
InitImeLocalData(hInstance);
}
InitUserSetting();
RegisterImeClass(hInstance, hInstance);
break;
case DLL_PROCESS_DETACH:
{
WNDCLASSEX wcWndCls;
DeleteObject (sImeG.WhitePen);
DeleteObject (sImeG.BlackPen);
DeleteObject (sImeG.GrayPen);
DeleteObject (sImeG.LightGrayPen);
QuitBefore();
if (GetClassInfoEx(hInstance, szStatusClassName, &wcWndCls)) {
UnregisterClass(szStatusClassName, hInstance);
}
if (GetClassInfoEx(hInstance, szCandClassName, &wcWndCls)) {
UnregisterClass(szCandClassName, hInstance);
}
if (GetClassInfoEx(hInstance, szCompClassName, &wcWndCls)) {
UnregisterClass(szCompClassName, hInstance);
}
if (!GetClassInfoEx(hInstance, szUIClassName, &wcWndCls)) {
} else if (!UnregisterClass(szUIClassName, hInstance)) {
} else {
DestroyIcon(wcWndCls.hIcon);
DestroyIcon(wcWndCls.hIconSm);
}
break;
}
default:
break;
}
return (TRUE);
}
/**********************************************************************/
/* GenerateMessage2() */
/**********************************************************************/
void PASCAL GenerateMessage2(
HIMC hIMC,
LPINPUTCONTEXT lpIMC,
LPPRIVCONTEXT lpImcP)
{
LPTRANSMSG lpMsgBuf;
HIMCC hMem;
BOOL bCantReSize;
if (!hIMC) {
return;
} else if (!lpIMC) {
return;
} else if (!lpImcP) {
return;
} else if (lpImcP->fdwImeMsg & MSG_IN_IMETOASCIIEX) {
return;
} else {
}
bCantReSize = FALSE;
if (!lpIMC->hMsgBuf) {
// it maybe free by IME, up to GEN_MSG_MAX messages for max case
lpIMC->hMsgBuf = ImmCreateIMCC(GEN_MSG_MAX * sizeof(TRANSMSG));
} else if (hMem = ImmReSizeIMCC(lpIMC->hMsgBuf, (lpIMC->dwNumMsgBuf
+ GEN_MSG_MAX) * sizeof(TRANSMSG))) {
lpIMC->hMsgBuf = hMem;
} else {
bCantReSize = TRUE;
}
if (!lpIMC->hMsgBuf) {
lpIMC->dwNumMsgBuf = 0;
return;
}
lpMsgBuf = (LPTRANSMSG)ImmLockIMCC(lpIMC->hMsgBuf);
if (!lpMsgBuf) {
return;
}
if (bCantReSize) {
LPTRANSMSG lpNewBuf;
hMem = ImmCreateIMCC((lpIMC->dwNumMsgBuf + GEN_MSG_MAX) *
sizeof(TRANSMSG));
if (!hMem) {
ImmUnlockIMCC(lpIMC->hMsgBuf);
return;
}
lpNewBuf = (LPTRANSMSG)ImmLockIMCC(hMem);
if (!lpMsgBuf) {
ImmUnlockIMCC(lpIMC->hMsgBuf);
return;
}
CopyMemory(lpNewBuf, lpMsgBuf, lpIMC->dwNumMsgBuf *
sizeof(TRANSMSG));
ImmUnlockIMCC(lpIMC->hMsgBuf);
ImmDestroyIMCC(lpIMC->hMsgBuf);
lpIMC->hMsgBuf = hMem;
lpMsgBuf = lpNewBuf;
}
if(TypeOfOutMsg){
lpIMC->dwNumMsgBuf += TransAbcMsg2(lpMsgBuf, lpImcP);
}else{
lpIMC->dwNumMsgBuf += TranslateImeMessage(NULL, lpIMC, lpImcP);
}
// lpIMC->dwNumMsgBuf += TransAbcMsg(lpMsgBuf, lpImcP,lpIMC,0,0,0);
ImmUnlockIMCC(lpIMC->hMsgBuf);
lpImcP->fdwImeMsg &= (MSG_ALREADY_OPEN|MSG_ALREADY_START);
lpImcP->fdwGcsFlag &= (GCS_RESULTREAD|GCS_RESULT); // ?
ImmGenerateMessage(hIMC);
return;
}
/**********************************************************************/
/* GenerateMessage() */
/**********************************************************************/
void PASCAL GenerateMessage(
HIMC hIMC,
LPINPUTCONTEXT lpIMC,
LPPRIVCONTEXT lpImcP)
{
LPTRANSMSG lpMsgBuf;
HIMCC hMem;
BOOL bCantReSize;
if (!hIMC) {
return;
} else if (!lpIMC) {
return;
} else if (!lpImcP) {
return;
} else if (lpImcP->fdwImeMsg & MSG_IN_IMETOASCIIEX) {
return;
} else {
}
bCantReSize = FALSE;
if (!lpIMC->hMsgBuf) {
// it maybe free by IME, up to GEN_MSG_MAX messages for max case
lpIMC->hMsgBuf = ImmCreateIMCC(GEN_MSG_MAX * sizeof(TRANSMSG));
} else if (hMem = ImmReSizeIMCC(lpIMC->hMsgBuf, (lpIMC->dwNumMsgBuf
+ GEN_MSG_MAX) * sizeof(TRANSMSG))) {
lpIMC->hMsgBuf = hMem;
} else {
bCantReSize = TRUE;
}
if (!lpIMC->hMsgBuf) {
lpIMC->dwNumMsgBuf = 0;
return;
}
lpMsgBuf = (LPTRANSMSG)ImmLockIMCC(lpIMC->hMsgBuf);
if (!lpMsgBuf) {
return;
}
if (bCantReSize) {
LPTRANSMSG lpNewBuf;
hMem = ImmCreateIMCC((lpIMC->dwNumMsgBuf + GEN_MSG_MAX) *
sizeof(TRANSMSG));
if (!hMem) {
ImmUnlockIMCC(lpIMC->hMsgBuf);
return;
}
lpNewBuf = (LPTRANSMSG)ImmLockIMCC(hMem);
if (!lpMsgBuf) {
ImmUnlockIMCC(lpIMC->hMsgBuf);
return;
}
CopyMemory(lpNewBuf, lpMsgBuf, lpIMC->dwNumMsgBuf *
sizeof(TRANSMSG));
ImmUnlockIMCC(lpIMC->hMsgBuf);
ImmDestroyIMCC(lpIMC->hMsgBuf);
lpIMC->hMsgBuf = hMem;
lpMsgBuf = lpNewBuf;
}
lpIMC->dwNumMsgBuf += TranslateImeMessage(NULL, lpIMC, lpImcP);
ImmUnlockIMCC(lpIMC->hMsgBuf);
lpImcP->fdwImeMsg &= (MSG_ALREADY_OPEN|MSG_ALREADY_START);
lpImcP->fdwGcsFlag &= (GCS_RESULTREAD|GCS_RESULT); // ?
ImmGenerateMessage(hIMC);
return;
}
/**********************************************************************/
/* SetString() */
/* Return Value: */
/* TRUE - successful, FALSE - failure */
/**********************************************************************/
BOOL PASCAL SetString(
HIMC hIMC,
LPINPUTCONTEXT lpIMC,
LPCOMPOSITIONSTRING lpCompStr,
LPPRIVCONTEXT lpImcP,
LPSTR lpszRead,
DWORD dwReadLen)
{
DWORD dwPattern;
DWORD i;
if (dwReadLen > (lpImeL->nMaxKey * sizeof(WORD)+20)) {
return (FALSE);
}
// compoition/reading attribute
lpCompStr->dwCompReadAttrLen = dwReadLen;
lpCompStr->dwCompAttrLen = lpCompStr->dwCompReadAttrLen;
for (i = 0; i < dwReadLen; i++) { // The IME has converted these chars
*((LPBYTE)lpCompStr + lpCompStr->dwCompReadAttrOffset + i) =
ATTR_TARGET_CONVERTED;
}
// composition/reading clause, 1 clause only
lpCompStr->dwCompReadClauseLen = 2 * sizeof(DWORD);
lpCompStr->dwCompClauseLen = lpCompStr->dwCompReadClauseLen;
*(LPUNADWORD)((LPBYTE)lpCompStr + lpCompStr->dwCompReadClauseOffset +
sizeof(DWORD)) = dwReadLen;
lpCompStr->dwCompReadStrLen = dwReadLen;
lpCompStr->dwCompStrLen = lpCompStr->dwCompReadStrLen;
CopyMemory((LPBYTE)lpCompStr + lpCompStr->dwCompReadStrOffset, lpszRead,
dwReadLen);
// dlta start from 0;
lpCompStr->dwDeltaStart = 0;
// cursor is next to composition string
lpCompStr->dwCursorPos = lpCompStr->dwCompStrLen;
lpCompStr->dwResultReadClauseLen = 0;
lpCompStr->dwResultReadStrLen = 0;
lpCompStr->dwResultClauseLen = 0;
lpCompStr->dwResultStrLen = 0;
// set private input context
lpImcP->iImeState = CST_INPUT;
if (lpImcP->fdwImeMsg & MSG_ALREADY_OPEN) {
lpImcP->fdwImeMsg = (lpImcP->fdwImeMsg | MSG_CLOSE_CANDIDATE) &
~(MSG_OPEN_CANDIDATE);
}
if (!(lpImcP->fdwImeMsg & MSG_ALREADY_START)) {
lpImcP->fdwImeMsg = (lpImcP->fdwImeMsg | MSG_START_COMPOSITION) &
~(MSG_END_COMPOSITION);
}
lpImcP->fdwImeMsg |= MSG_COMPOSITION;
//zst lpImcP->dwCompChar = (DWORD)lpImeL->wSeq2CompTbl[
//zst lpImcP->bSeq[lpCompStr->dwCompReadStrLen / 2 - 1]];
lpImcP->dwCompChar = HIBYTE(lpImcP->dwCompChar) |
(LOBYTE(lpImcP->dwCompChar) << 8);
lpImcP->fdwGcsFlag = GCS_COMPREAD|GCS_COMP|
GCS_DELTASTART|GCS_CURSORPOS;
if (lpIMC->fdwConversion & IME_CMODE_EUDC) {
if (lpCompStr->dwCompReadStrLen >= sizeof(WORD) * lpImeL->nMaxKey) {
lpImcP->fdwImeMsg |= MSG_COMPOSITION;
lpImcP->fdwGcsFlag |= GCS_RESULTREAD|GCS_RESULTSTR;
}
} else {
if (dwReadLen < sizeof(WORD) * lpImeL->nMaxKey) {
// quick key
if (lpImeL->fModeConfig & MODE_CONFIG_QUICK_KEY) {
//zst Finalize(lpIMC, lpCompStr, lpImcP, FALSE);
}
} else {
UINT nCand;
LPGUIDELINE lpGuideLine;
//zst nCand = Finalize(lpIMC, lpCompStr, lpImcP, TRUE);
if (!lpIMC->hGuideLine) {
goto SeStGenMsg;
}
lpGuideLine = (LPGUIDELINE)ImmLockIMCC(lpIMC->hGuideLine);
if (!lpGuideLine) {
goto SeStGenMsg;
/*
} else if (nCand == 1) {
} else if (nCand > 1) {
*/
} else {
// nothing found, end user, you have an error now
lpGuideLine->dwLevel = GL_LEVEL_ERROR;
lpGuideLine->dwIndex = GL_ID_TYPINGERROR;
lpImcP->fdwImeMsg |= MSG_GUIDELINE;
}
ImmUnlockIMCC(lpIMC->hGuideLine);
}
}
SeStGenMsg:
GenerateMessage(hIMC, lpIMC, lpImcP);
return (TRUE);
}
/**********************************************************************/
/* CompEscapeKey() */
/**********************************************************************/
void PASCAL CompEscapeKey(
LPINPUTCONTEXT lpIMC,
LPCOMPOSITIONSTRING lpCompStr,
LPGUIDELINE lpGuideLine,
LPPRIVCONTEXT lpImcP)
{
if (!lpGuideLine) {
MessageBeep((UINT)-1);
} else if (lpGuideLine->dwLevel == GL_LEVEL_NOGUIDELINE) {
} else {
lpGuideLine->dwLevel = GL_LEVEL_NOGUIDELINE;
lpGuideLine->dwIndex = GL_ID_UNKNOWN;
lpGuideLine->dwStrLen = 0;
lpImcP->fdwImeMsg |= MSG_GUIDELINE;
}
if (lpImcP->iImeState != CST_INIT) {
} else if (lpCompStr->dwCompStrLen) {
// clean the compose string
} else if (lpImcP->fdwImeMsg & MSG_ALREADY_START) {
lpImcP->fdwImeMsg = (lpImcP->fdwImeMsg | MSG_END_COMPOSITION) &
~(MSG_START_COMPOSITION);
} else {
}
lpImcP->iImeState = CST_INIT;
// *(LPDWORD)lpImcP->bSeq = 0;
// lpImcP->wPhraseNextOffset = lpImcP->wWordNextOffset = 0;
InitCvtPara();
if (lpCompStr) {
InitCompStr(lpCompStr);
lpImcP->fdwImeMsg |= MSG_END_COMPOSITION;
lpImcP->dwCompChar = VK_ESCAPE;
lpImcP->fdwGcsFlag |= (GCS_COMPREAD|GCS_COMP|GCS_CURSORPOS|
GCS_DELTASTART);
}
return;
}
/**********************************************************************/
/* CandEscapeKey() */
/**********************************************************************/
void PASCAL CandEscapeKey(
LPINPUTCONTEXT lpIMC,
LPPRIVCONTEXT lpImcP)
{
LPCOMPOSITIONSTRING lpCompStr;
LPGUIDELINE lpGuideLine;
// clean all candidate information
if (lpImcP->fdwImeMsg & MSG_ALREADY_OPEN) {
ClearCand(lpIMC);
lpImcP->fdwImeMsg = (lpImcP->fdwImeMsg | MSG_CLOSE_CANDIDATE) &
~(MSG_OPEN_CANDIDATE);
}
lpImcP->iImeState = CST_INPUT;
// if it start composition, we need to clean composition
if (!(lpImcP->fdwImeMsg & MSG_ALREADY_START)) {
return;
}
lpCompStr = (LPCOMPOSITIONSTRING)ImmLockIMCC(lpIMC->hCompStr);
lpGuideLine = (LPGUIDELINE)ImmLockIMCC(lpIMC->hGuideLine);
CompEscapeKey(lpIMC, lpCompStr, lpGuideLine, lpImcP);
ImmUnlockIMCC(lpIMC->hGuideLine);
ImmUnlockIMCC(lpIMC->hCompStr);
return;
}
/**********************************************************************/
/* CompCancel() */
/**********************************************************************/
void PASCAL CompCancel(
HIMC hIMC,
LPINPUTCONTEXT lpIMC)
{
LPPRIVCONTEXT lpImcP;
if (!lpIMC->hPrivate) {
return;
}
lpImcP = (LPPRIVCONTEXT)ImmLockIMCC(lpIMC->hPrivate);
if (!lpImcP) {
return;
}
lpImcP->fdwGcsFlag = (DWORD)0;
if (lpImcP->fdwImeMsg & MSG_ALREADY_OPEN) {
CandEscapeKey(lpIMC, lpImcP);
} else if (lpImcP->fdwImeMsg & MSG_ALREADY_START) {
LPCOMPOSITIONSTRING lpCompStr;
LPGUIDELINE lpGuideLine;
lpCompStr = (LPCOMPOSITIONSTRING)ImmLockIMCC(lpIMC->hCompStr);
lpGuideLine = (LPGUIDELINE)ImmLockIMCC(lpIMC->hGuideLine);
if ( lpCompStr && lpGuideLine )
CompEscapeKey(lpIMC, lpCompStr, lpGuideLine, lpImcP);
ImmUnlockIMCC(lpIMC->hGuideLine);
ImmUnlockIMCC(lpIMC->hCompStr);
} else {
ImmUnlockIMCC(lpIMC->hPrivate);
return;
}
lpImcP->fdwImeMsg |= MSG_COMPOSITION; //#52224
GenerateMessage(hIMC, lpIMC, lpImcP);
ImmUnlockIMCC(lpIMC->hPrivate);
InitCvtPara();
return;
}
/**********************************************************************/
/* ImeSetCompositionString() */
/* Return Value: */
/* TRUE - successful, FALSE - failure */
/**********************************************************************/
BOOL WINAPI ImeSetCompositionString(
HIMC hIMC,
DWORD dwIndex,
LPVOID lpComp,
DWORD dwCompLen,
LPVOID lpRead,
DWORD dwReadLen)
{
LPINPUTCONTEXT lpIMC;
LPCOMPOSITIONSTRING lpCompStr;
LPPRIVCONTEXT lpImcP;
BOOL fRet;
if (!hIMC) {
return (FALSE);
}
// composition string must == reading string
// reading is more important
if (!dwReadLen) {
dwReadLen = dwCompLen;
}
// composition string must == reading string
// reading is more important
if (!lpRead) {
lpRead = lpComp;
}
if (!dwReadLen) {
lpIMC = (LPINPUTCONTEXT)ImmLockIMC(hIMC);
if (!lpIMC) {
return (FALSE);
}
CompCancel(hIMC, lpIMC);
ImmUnlockIMC(hIMC);
return (TRUE);
} else if (!lpRead) {
return (FALSE);
} else if (!dwCompLen) {
} else if (!lpComp) {
} else if (dwReadLen != dwCompLen) {
return (FALSE);
} else if (lpRead == lpComp) {
} else if (!lstrcmp(lpRead, lpComp)) {
// composition string must == reading string
} else {
// composition string != reading string
return (FALSE);
}
if (dwIndex != SCS_SETSTR) {
return (FALSE);
}
lpIMC = (LPINPUTCONTEXT)ImmLockIMC(hIMC);
if (!lpIMC) {
return (FALSE);
}
if (!lpIMC->hCompStr) {
ImmUnlockIMC(hIMC);
return (FALSE);
}
lpCompStr = (LPCOMPOSITIONSTRING)ImmLockIMCC(lpIMC->hCompStr);
if (!lpCompStr) {
ImmUnlockIMC(hIMC);
return (FALSE);
}
lpImcP = (LPPRIVCONTEXT)ImmLockIMCC(lpIMC->hPrivate);
fRet = SetString(hIMC, lpIMC, lpCompStr, lpImcP, lpRead, dwReadLen);
ImmUnlockIMCC(lpIMC->hPrivate);
ImmUnlockIMCC(lpIMC->hCompStr);
ImmUnlockIMC(hIMC);
return (fRet);
}
/**********************************************************************/
/* ToggleSoftKbd() */
/**********************************************************************/
void PASCAL ToggleSoftKbd(
HIMC hIMC,
LPINPUTCONTEXT lpIMC)
{
LPPRIVCONTEXT lpImcP;
lpImcP = (LPPRIVCONTEXT)ImmLockIMCC(lpIMC->hPrivate);
if (!lpImcP) {
return;
}
lpImcP->fdwImeMsg |= MSG_IMN_UPDATE_SOFTKBD;
GenerateMessage(hIMC, lpIMC, lpImcP);
ImmUnlockIMCC(lpIMC->hPrivate);
return;
}
/**********************************************************************/
/* NotifySelectCand() */
/**********************************************************************/
void PASCAL NotifySelectCand( // app tell IME that one candidate string is
// selected (by mouse or non keyboard action
// - for example sound)
HIMC hIMC,
LPINPUTCONTEXT lpIMC,
LPCANDIDATEINFO lpCandInfo,
DWORD dwIndex,
DWORD dwValue)
{
LPPRIVCONTEXT lpImcP;
if (!lpCandInfo) {
return;
}
lpImcP = (LPPRIVCONTEXT)ImmLockIMCC(lpIMC->hPrivate);
CharProc((WORD)dwValue,0,0,hIMC,lpIMC,lpImcP);
GenerateMessage2(hIMC, lpIMC, lpImcP);
ImmUnlockIMCC(lpIMC->hPrivate);
ImmUnlockIMCC(lpIMC->hCompStr);
return;
}
/**********************************************************************/
/* NotifySetMode() */
/**********************************************************************/
void PASCAL NotifySetMode(
HIMC hIMC)
{
LPINPUTCONTEXT lpIMC;
LPPRIVCONTEXT lpImcP;
lpIMC = (LPINPUTCONTEXT)ImmLockIMC(hIMC);
if(!lpIMC) return ;
lpImcP = (LPPRIVCONTEXT)ImmLockIMCC(lpIMC->hPrivate);
if (!lpImcP){
ImmUnlockIMC(hIMC);
return ;
}
GenerateMessage(hIMC, lpIMC, lpImcP);
ImmUnlockIMCC(lpIMC->hPrivate);
ImmUnlockIMC(hIMC);
return;
}
/**********************************************************************/
/* GenerateImeMessage() */
/**********************************************************************/
void PASCAL GenerateImeMessage(
HIMC hIMC,
LPINPUTCONTEXT lpIMC,
DWORD fdwImeMsg)
{
LPPRIVCONTEXT lpImcP;
lpImcP = (LPPRIVCONTEXT)ImmLockIMCC(lpIMC->hPrivate);
if (!lpImcP) {
return;
}
lpImcP->fdwImeMsg |= fdwImeMsg;
if (fdwImeMsg & MSG_CLOSE_CANDIDATE) {
lpImcP->fdwImeMsg &= ~(MSG_OPEN_CANDIDATE|MSG_CHANGE_CANDIDATE);
} else if (fdwImeMsg & (MSG_OPEN_CANDIDATE|MSG_CHANGE_CANDIDATE)) {
lpImcP->fdwImeMsg &= ~(MSG_CLOSE_CANDIDATE);
} else {
}
if (fdwImeMsg & MSG_END_COMPOSITION) {
lpImcP->fdwImeMsg &= ~(MSG_START_COMPOSITION);
} else if (fdwImeMsg & MSG_START_COMPOSITION) {
lpImcP->fdwImeMsg &= ~(MSG_END_COMPOSITION);
} else {
}
GenerateMessage(hIMC, lpIMC, lpImcP);
ImmUnlockIMCC(lpIMC->hPrivate);
return;
}
/**********************************************************************/
/* NotifyIME() */
/* Return Value: */
/* TRUE - successful, FALSE - failure */
/**********************************************************************/
BOOL WINAPI NotifyIME(
HIMC hIMC,
DWORD dwAction,
DWORD dwIndex,
DWORD dwValue)
{
LPINPUTCONTEXT lpIMC;
DWORD fdwImeMsg;
LPPRIVCONTEXT lpImcP;
if (!hIMC) {
return (TRUE);
}
switch (dwAction) {
case NI_OPENCANDIDATE: // after a composition string is determined
// if an IME can open candidate, it will.
// if it can not, app also can not open it.
case NI_CLOSECANDIDATE:
return (FALSE);
case NI_SELECTCANDIDATESTR:
break; // need to handle it
case NI_CHANGECANDIDATELIST:
return (TRUE); // not important to the IME
case NI_CONTEXTUPDATED:
switch (dwValue) {
case IMC_SETCONVERSIONMODE:
case IMC_SETSENTENCEMODE:
case IMC_SETOPENSTATUS:
break; // need to handle it
case IMC_SETCANDIDATEPOS:
case IMC_SETCOMPOSITIONFONT:
case IMC_SETCOMPOSITIONWINDOW:
return (TRUE); // not important to the IME
default:
return (FALSE); // not supported
}
break;
case NI_COMPOSITIONSTR:
switch (dwIndex) {
case CPS_CONVERT: // all composition string can not be convert
case CPS_REVERT: // any more, it maybe work for some
// intelligent phonetic IMEs
return (FALSE);
case CPS_CANCEL:
break; // need to handle it
default:
return (FALSE); // not supported
}
break; // need to handle it
default:
return (FALSE); // not supported
}
lpIMC = (LPINPUTCONTEXT)ImmLockIMC(hIMC);
if (!lpIMC) {
return (FALSE);
}
switch (dwAction) {
case NI_CONTEXTUPDATED:
switch (dwValue) {
case IMC_SETCONVERSIONMODE:
if ((lpIMC->fdwConversion ^ dwIndex) == IME_CMODE_FULLSHAPE) {
break;
}
if ((lpIMC->fdwConversion ^ dwIndex) & IME_CMODE_SOFTKBD) {
ToggleSoftKbd(hIMC, lpIMC);
if ((lpIMC->fdwConversion ^ dwIndex) == IME_CMODE_SOFTKBD) {
break;
}
}
if ((lpIMC->fdwConversion ^ dwIndex) == IME_CMODE_NATIVE) {
lpIMC->fdwConversion &= ~(IME_CMODE_CHARCODE|
IME_CMODE_NOCONVERSION|IME_CMODE_EUDC);
}
// if ((lpIMC->fdwConversion ^ dwIndex) == IME_CMODE_CHARCODE) {
// lpIMC->fdwConversion &= ~(IME_CMODE_EUDC);
// }
CompCancel(hIMC, lpIMC);
break;
/*
if ((lpIMC->fdwConversion ^ dwIndex) & IME_CMODE_CHARCODE) {
// reject CHARCODE
lpIMC->fdwConversion &= ~IME_CMODE_CHARCODE;
MessageBeep((UINT)-1);
break;
}
fdwImeMsg = 0;
if ((lpIMC->fdwConversion ^ dwIndex) & IME_CMODE_NOCONVERSION) {
lpIMC->fdwConversion |= IME_CMODE_NATIVE;
lpIMC->fdwConversion &= ~(IME_CMODE_CHARCODE|
IME_CMODE_EUDC|IME_CMODE_SYMBOL);
}
if ((lpIMC->fdwConversion ^ dwIndex) & IME_CMODE_EUDC) {
lpIMC->fdwConversion |= IME_CMODE_NATIVE;
lpIMC->fdwConversion &= ~(IME_CMODE_CHARCODE|
IME_CMODE_NOCONVERSION|IME_CMODE_SYMBOL);
}
if ((lpIMC->fdwConversion ^ dwIndex) & IME_CMODE_SOFTKBD) {
LPPRIVCONTEXT lpImcP;
if (!(lpIMC->fdwConversion & IME_CMODE_NATIVE)) {
MessageBeep((UINT)-1);
break;
}
fdwImeMsg |= MSG_IMN_UPDATE_SOFTKBD;
if (lpIMC->fdwConversion & IME_CMODE_SOFTKBD) {
} else if (lpIMC->fdwConversion & IME_CMODE_SYMBOL) {
lpIMC->fdwConversion &= ~(IME_CMODE_SYMBOL);
} else {
}
lpImcP = (LPPRIVCONTEXT)ImmLockIMCC(lpIMC->hPrivate);
if (!lpImcP) {
goto NotifySKOvr;
}
if (lpIMC->fdwConversion & IME_CMODE_SOFTKBD) {
// now we already in soft keyboard state by
// this change
// even end user finish the symbol, we should not
// turn off soft keyboard
lpImcP->fdwImeMsg |= MSG_ALREADY_SOFTKBD;
} else {
// now we are not in soft keyboard state by
// this change
// after end user finish the symbol, we should
// turn off soft keyboard
lpImcP->fdwImeMsg &= ~(MSG_ALREADY_SOFTKBD);
}
ImmUnlockIMCC(lpIMC->hPrivate);
NotifySKOvr:
; // NULL statement for goto
}
if ((lpIMC->fdwConversion ^ dwIndex) == IME_CMODE_NATIVE) {
lpIMC->fdwConversion &= ~(IME_CMODE_CHARCODE|
IME_CMODE_NOCONVERSION|IME_CMODE_EUDC|IME_CMODE_SYMBOL);
fdwImeMsg |= MSG_IMN_UPDATE_SOFTKBD;
}
if ((lpIMC->fdwConversion ^ dwIndex) & IME_CMODE_SYMBOL) {
LPCOMPOSITIONSTRING lpCompStr;
LPPRIVCONTEXT lpImcP;
if (lpIMC->fdwConversion & IME_CMODE_EUDC) {
lpIMC->fdwConversion &= ~(IME_CMODE_SYMBOL);
MessageBeep((UINT)-1);
break;
}
if (!(lpIMC->fdwConversion & IME_CMODE_NATIVE)) {
lpIMC->fdwConversion &= ~(IME_CMODE_SYMBOL);
lpIMC->fdwConversion |= (dwIndex & IME_CMODE_SYMBOL);
MessageBeep((UINT)-1);
break;
}
lpCompStr = ImmLockIMCC(lpIMC->hCompStr);
if (lpCompStr) {
if (!lpCompStr->dwCompStrLen) {
} else if (lpIMC->fdwConversion & IME_CMODE_SYMBOL) {
// if there is a string we could not change
// to symbol mode
lpIMC->fdwConversion &= ~(IME_CMODE_SYMBOL);
MessageBeep((UINT)-1);
break;
} else {
}
ImmUnlockIMCC(lpIMC->hCompStr);
}
lpIMC->fdwConversion &= ~(IME_CMODE_CHARCODE|
IME_CMODE_NOCONVERSION|IME_CMODE_EUDC);
if (lpIMC->fdwConversion & IME_CMODE_SYMBOL) {
lpIMC->fdwConversion |= IME_CMODE_SOFTKBD;
} else if (lpImcP = (LPPRIVCONTEXT)ImmLockIMCC(lpIMC->hPrivate)) {
// we borrow the bit for this usage
if (!(lpImcP->fdwImeMsg & MSG_ALREADY_SOFTKBD)) {
lpIMC->fdwConversion &= ~(IME_CMODE_SOFTKBD);
}
ImmUnlockIMCC(lpIMC->hPrivate);
} else {
}
fdwImeMsg |= MSG_IMN_UPDATE_SOFTKBD;
}
if (fdwImeMsg) {
lpIMC = (LPINPUTCONTEXT)ImmLockIMC(hIMC);
lpImcP = (LPPRIVCONTEXT)ImmLockIMCC(lpIMC->hPrivate);
if(!lpImcP){
lpImcP->fdwImeMsg = lpImcP->fdwImeMsg &~(MSG_IN_IMETOASCIIEX);
}
ImmUnlockIMCC(lpIMC->hPrivate);
ImmUnlockIMC(hIMC);
GenerateImeMessage(hIMC, lpIMC, fdwImeMsg);
}
if ((lpIMC->fdwConversion ^ dwIndex) & ~(IME_CMODE_FULLSHAPE|
IME_CMODE_SOFTKBD)) {
} else {
break;
}
CompCancel(hIMC, lpIMC);
break;
*/
case IMC_SETOPENSTATUS:
CompCancel(hIMC, lpIMC);
break;
default:
break;
}
break;
case NI_SELECTCANDIDATESTR:
if (!lpIMC->fOpen) {
break;
} else if (lpIMC->fdwConversion & IME_CMODE_NOCONVERSION) {
break;
} else if (lpIMC->fdwConversion & IME_CMODE_EUDC) {
break;
} else if (!lpIMC->hCandInfo) {
break;
} else {
LPCANDIDATEINFO lpCandInfo;
lpCandInfo = (LPCANDIDATEINFO)ImmLockIMCC(lpIMC->hCandInfo);
NotifySelectCand(hIMC, lpIMC, lpCandInfo, dwIndex, dwValue);
ImmUnlockIMCC(lpIMC->hCandInfo);
}
break;
case NI_COMPOSITIONSTR:
switch (dwIndex) {
case CPS_CANCEL:
CompCancel(hIMC, lpIMC);
break;
default:
break;
}
break;
default:
break;
}
ImmUnlockIMC(hIMC);
return (TRUE);
}
/**********************************************************************/
/* ImeRegsisterWord */
/* Return Value: */
/* TRUE - successful, FALSE - failure */
/**********************************************************************/
BOOL WINAPI ImeRegisterWord(
LPCTSTR lpszReading,
DWORD dwStyle,
LPCTSTR lpszString)
{
return (0);
}
/**********************************************************************/
/* ImeUnregsisterWord */
/* Return Value: */
/* TRUE - successful, FALSE - failure */
/**********************************************************************/
BOOL WINAPI ImeUnregisterWord(
LPCTSTR lpszReading,
DWORD dwStyle,
LPCTSTR lpszString)
{
return (0);
}
/**********************************************************************/
/* ImeGetRegsisterWordStyle */
/* Return Value: */
/* number of styles copied/required */
/**********************************************************************/
UINT WINAPI ImeGetRegisterWordStyle(
UINT nItem,
LPSTYLEBUF lpStyleBuf)
{
return (1);
}
/**********************************************************************/
/* ImeEnumRegisterWord */
/* Return Value: */
/* the last value return by the callback function */
/**********************************************************************/
UINT WINAPI ImeEnumRegisterWord(
REGISTERWORDENUMPROC lpfnRegisterWordEnumProc,
LPCTSTR lpszReading,
DWORD dwStyle,
LPCTSTR lpszString,
LPVOID lpData)
{
return (0);
}
/**********************************************************************/
/* GetStatusWnd */
/* Return Value : */
/* window handle of status window */
/**********************************************************************/
HWND PASCAL GetStatusWnd(
HWND hUIWnd) // UI window
{
HGLOBAL hUIPrivate;
LPUIPRIV lpUIPrivate;
HWND hStatusWnd;
hUIPrivate = (HGLOBAL)GetWindowLongPtr(hUIWnd, IMMGWLP_PRIVATE);
if (!hUIPrivate) { // can not darw status window
return (HWND)NULL;
}
lpUIPrivate = (LPUIPRIV)GlobalLock(hUIPrivate);
if (!lpUIPrivate) { // can not draw status window
return (HWND)NULL;
}
hStatusWnd = lpUIPrivate->hStatusWnd;
GlobalUnlock(hUIPrivate);
return (hStatusWnd);
}
/**********************************************************************/
/* SetStatusWindowPos() */
/**********************************************************************/
LRESULT PASCAL SetStatusWindowPos(
HWND hStatusWnd)
{
HWND hUIWnd;
HIMC hIMC;
LPINPUTCONTEXT lpIMC;
RECT rcStatusWnd;
POINT ptPos;
hUIWnd = GetWindow(hStatusWnd, GW_OWNER);
hIMC = (HIMC)GetWindowLongPtr(hUIWnd, IMMGWLP_IMC);
if (!hIMC) {
return (1L);
}
lpIMC = (LPINPUTCONTEXT)ImmLockIMC(hIMC);
if (!lpIMC) { // Oh! Oh!
return (1L);
}
GetWindowRect(hStatusWnd, &rcStatusWnd);
//DebugShow2( "ptPos=",lpIMC->ptStatusWndPos.x,"ptPos.y", rcStatusWnd.left);
if (lpIMC->ptStatusWndPos.x != rcStatusWnd.left) {
} else if (lpIMC->ptStatusWndPos.y != rcStatusWnd.top) {
} else {
ImmUnlockIMC(hIMC);
return (0L);
}
//DebugShow2( "ptPos111=",NULL,"ptPos.y",NULL);
// ptPos = lpIMC->ptStatusWndPos;
// display boundary adjust
ptPos.x = lpIMC->ptStatusWndPos.x;
ptPos.y = lpIMC->ptStatusWndPos.y;
AdjustStatusBoundary(&ptPos);
SetWindowPos(hStatusWnd, NULL,
ptPos.x, ptPos.y,
0, 0, /*SWP_SHOWWINDOW|*/SWP_NOACTIVATE/*|SWP_NOCOPYBITS*/|SWP_NOSIZE|SWP_NOZORDER);
CountDefaultComp(ptPos.x,ptPos.y,sImeG.rcWorkArea);
ImmUnlockIMC(hIMC);
return (0L);
}
/**********************************************************************/
/* CountDefaultComp() */
/**********************************************************************/
int CountDefaultComp(int x, int y, RECT Area)
{
POINT Comp,Cand;
Comp.x = lpImeL->ptZLComp.x;
Comp.y = lpImeL->ptZLComp.y;
Cand.x = lpImeL->ptZLCand.x;
Cand.y = lpImeL->ptZLCand.y;
lpImeL->ptZLComp.x = x + sImeG.xStatusWi+4;
lpImeL->ptZLComp.y = y;
if ((Area.right-lpImeL->ptZLComp.x -lpImeL->xCompWi)<10){
lpImeL->ptZLComp.x = x - lpImeL->xCompWi-4;
}
// lpImeL->ptZLCand.x = lpImeL->ptZLComp.x - lpImeL->xCandWi -4;}
return 0;
}
/**********************************************************************/
/* ShowStatus() */
/**********************************************************************/
void PASCAL ShowStatus( // Show the status window - shape / soft KBD
// alphanumeric ...
HWND hUIWnd,
int nShowStatusCmd)
{
HGLOBAL hUIPrivate;
LPUIPRIV lpUIPrivate;
hUIPrivate = (HGLOBAL)GetWindowLongPtr(hUIWnd, IMMGWLP_PRIVATE);
if (!hUIPrivate) { // can not darw status window
return;
}
lpUIPrivate = (LPUIPRIV)GlobalLock(hUIPrivate);
if (!lpUIPrivate) { // can not draw status window
return;
}
if (!lpUIPrivate->hStatusWnd) {
// not in show status window mode
} else if (lpUIPrivate->nShowStatusCmd != nShowStatusCmd) {
RECT Area;
SystemParametersInfo(SPI_GETWORKAREA, 0, &Area, 0);
if((sImeG.rcWorkArea.bottom != Area.bottom)
||(sImeG.rcWorkArea.top != Area.top)
||(sImeG.rcWorkArea.left != Area.left)
||(sImeG.rcWorkArea.right != Area.right))
{
HIMC hIMC;
LPINPUTCONTEXT lpIMC;
hIMC = (HIMC)GetWindowLongPtr(hUIWnd, IMMGWLP_IMC);
if(hIMC){
lpIMC = (LPINPUTCONTEXT)ImmLockIMC(hIMC);
if (lpIMC){
if (((lpIMC->ptStatusWndPos.y + sImeG.yStatusHi)==sImeG.rcWorkArea.bottom)
||((lpIMC->ptStatusWndPos.y + sImeG.yStatusHi)>Area.bottom)){
lpIMC->ptStatusWndPos.y = Area.bottom - sImeG.yStatusHi;
} else if ((lpIMC->ptStatusWndPos.y ==sImeG.rcWorkArea.top)
||(lpIMC->ptStatusWndPos.y < Area.top)){
lpIMC->ptStatusWndPos.y = Area.top;
}
if ((lpIMC->ptStatusWndPos.x==sImeG.rcWorkArea.left)
||(lpIMC->ptStatusWndPos.x<Area.left)){
lpIMC->ptStatusWndPos.x = Area.left;
}else if (((lpIMC->ptStatusWndPos.x + sImeG.xStatusWi)==sImeG.rcWorkArea.right)
||((lpIMC->ptStatusWndPos.x + sImeG.xStatusWi)>Area.right)){
lpIMC->ptStatusWndPos.x = Area.right - sImeG.xStatusWi;
}
SetWindowPos(lpUIPrivate->hStatusWnd, NULL,
lpIMC->ptStatusWndPos.x,
lpIMC->ptStatusWndPos.y,
0, 0,
SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOZORDER);
CountDefaultComp(lpIMC->ptStatusWndPos.x,lpIMC->ptStatusWndPos.y,Area);
ImmUnlockIMC(hIMC);
sImeG.rcWorkArea.bottom = Area.bottom;
sImeG.rcWorkArea.top = Area.top;
sImeG.rcWorkArea.left = Area.left;
sImeG.rcWorkArea.right = Area.right;
}
}
}
ShowWindow(lpUIPrivate->hStatusWnd, nShowStatusCmd);
lpUIPrivate->nShowStatusCmd = nShowStatusCmd;
} else {
}
GlobalUnlock(hUIPrivate);
return;
}
/**********************************************************************/
/* OpenStatus() */
/**********************************************************************/
void PASCAL OpenStatus( // open status window
HWND hUIWnd)
{
HGLOBAL hUIPrivate;
LPUIPRIV lpUIPrivate;
HIMC hIMC;
LPINPUTCONTEXT lpIMC;
POINT ptPos;
int nShowStatusCmd;
hUIPrivate = (HGLOBAL)GetWindowLongPtr(hUIWnd, IMMGWLP_PRIVATE);
if (!hUIPrivate) { // can not darw status window
return;
}
lpUIPrivate = (LPUIPRIV)GlobalLock(hUIPrivate);
if (!lpUIPrivate) { // can not draw status window
return;
}
hIMC = (HIMC)GetWindowLongPtr(hUIWnd, IMMGWLP_IMC);
if (!hIMC) {
ptPos.x = sImeG.rcWorkArea.left;
ptPos.y = sImeG.rcWorkArea.bottom - sImeG.yStatusHi;
nShowStatusCmd = SW_HIDE;
} else if (lpIMC = (LPINPUTCONTEXT)ImmLockIMC(hIMC)) {
if (lpIMC->ptStatusWndPos.x < sImeG.rcWorkArea.left) {
lpIMC->ptStatusWndPos.x = sImeG.rcWorkArea.left;
} else if (lpIMC->ptStatusWndPos.x + sImeG.xStatusWi >
sImeG.rcWorkArea.right) {
lpIMC->ptStatusWndPos.x = sImeG.rcWorkArea.right -
sImeG.xStatusWi;
}
if (lpIMC->ptStatusWndPos.y < sImeG.rcWorkArea.top) {
lpIMC->ptStatusWndPos.y = sImeG.rcWorkArea.top;
} else if (lpIMC->ptStatusWndPos.y + sImeG.yStatusHi >
sImeG.rcWorkArea.right) {
lpIMC->ptStatusWndPos.y = sImeG.rcWorkArea.bottom -
sImeG.yStatusHi;
}
ptPos.x = lpIMC->ptStatusWndPos.x;
ptPos.y = lpIMC->ptStatusWndPos.y,
ImmUnlockIMC(hIMC);
nShowStatusCmd = SW_SHOWNOACTIVATE;
} else {
ptPos.x = sImeG.rcWorkArea.left;
ptPos.y = sImeG.rcWorkArea.bottom - sImeG.yStatusHi;
nShowStatusCmd = SW_HIDE;
}
if (lpUIPrivate->hStatusWnd) {
SetWindowPos(lpUIPrivate->hStatusWnd, NULL,
ptPos.x, ptPos.y,
0, 0,
SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOZORDER);
} else { // create status window
lpUIPrivate->hStatusWnd = CreateWindowEx(
0,
szStatusClassName, NULL, WS_POPUP|WS_DISABLED/*|WS_BORDER*/,
ptPos.x, ptPos.y,
sImeG.xStatusWi, sImeG.yStatusHi,
hUIWnd, (HMENU)NULL, hInst, NULL);
if ( lpUIPrivate->hStatusWnd )
{
ReInitIme(lpUIPrivate->hStatusWnd, lpImeL->wImeStyle); //#@2
SetWindowLong(lpUIPrivate->hStatusWnd, UI_MOVE_OFFSET,
WINDOW_NOT_DRAG);
SetWindowLong(lpUIPrivate->hStatusWnd, UI_MOVE_XY, 0L);
}
}
GlobalUnlock(hUIPrivate);
return;
}
/**********************************************************************/
/* DestroyStatusWindow() */
/**********************************************************************/
void PASCAL DestroyStatusWindow(
HWND hStatusWnd)
{
HWND hUIWnd;
HGLOBAL hUIPrivate;
LPUIPRIV lpUIPrivate;
hUIWnd = GetWindow(hStatusWnd, GW_OWNER);
hUIPrivate = (HGLOBAL)GetWindowLongPtr(hUIWnd, IMMGWLP_PRIVATE);
if (!hUIPrivate) { // can not darw status window
return;
}
lpUIPrivate = (LPUIPRIV)GlobalLock(hUIPrivate);
if (!lpUIPrivate) { // can not draw status window
return;
}
lpUIPrivate->nShowStatusCmd = SW_HIDE;
lpUIPrivate->hStatusWnd = (HWND)NULL;
GlobalUnlock(hUIPrivate);
return;
}
/**********************************************************************/
/* SetStatus */
/**********************************************************************/
void PASCAL SetStatus(
HWND hStatusWnd,
LPPOINT lpptCursor)
{
HWND hUIWnd;
HIMC hIMC;
LPINPUTCONTEXT lpIMC;
hUIWnd = GetWindow(hStatusWnd, GW_OWNER);
hIMC = (HIMC)GetWindowLongPtr(hUIWnd, IMMGWLP_IMC);
if (!hIMC) {
return;
}
lpIMC = (LPINPUTCONTEXT)ImmLockIMC(hIMC);
if (!lpIMC) {
return;
}
if (!lpIMC->fOpen) {
ImmSetOpenStatus(hIMC, TRUE);
} else if (PtInRect(&sImeG.rcInputText, *lpptCursor)) {
DWORD fdwConversion;
if (lpIMC->fdwConversion & IME_CMODE_NATIVE) {
// change to alphanumeric mode
fdwConversion = lpIMC->fdwConversion & ~(IME_CMODE_NATIVE );
{
LPPRIVCONTEXT lpImcP;
lpImcP = (LPPRIVCONTEXT)ImmLockIMCC(lpIMC->hPrivate);
ghIMC=hIMC;
glpIMCP=lpImcP;
glpIMC=lpIMC;
lpImcP->fdwImeMsg=lpImcP->fdwImeMsg & ~MSG_IN_IMETOASCIIEX;
cls_prompt();
InitCvtPara();
GenerateMessage(hIMC, lpIMC, lpImcP);
ImmUnlockIMCC(lpIMC->hPrivate);
}
} else {
if(lpIMC->fdwConversion & IME_CMODE_NOCONVERSION){
// Simulate a key press
keybd_event( VK_CAPITAL,
0x3A,
KEYEVENTF_EXTENDEDKEY | 0,
0 );
// Simulate a key release
keybd_event( VK_CAPITAL,
0x3A,
KEYEVENTF_EXTENDEDKEY | KEYEVENTF_KEYUP,
0);
cap_mode = 0;
fdwConversion = (lpIMC->fdwConversion | IME_CMODE_NATIVE) &
~(IME_CMODE_NOCONVERSION);
}else
fdwConversion = lpIMC->fdwConversion |IME_CMODE_NATIVE;
}
ImmSetConversionStatus(hIMC, fdwConversion, lpIMC->fdwSentence);
}
if (PtInRect(&sImeG.rcShapeText, *lpptCursor)) {
DWORD dwConvMode;
dwConvMode = lpIMC->fdwConversion ^ IME_CMODE_FULLSHAPE;
ImmSetConversionStatus(hIMC, dwConvMode, lpIMC->fdwSentence);
}
if (PtInRect(&sImeG.rcSKText, *lpptCursor)) {
DWORD fdwConversion;
KeyBoardState = ~KeyBoardState ;
fdwConversion = lpIMC->fdwConversion ^ IME_CMODE_SOFTKBD;
ImmSetConversionStatus(hIMC, fdwConversion, lpIMC->fdwSentence);
}
if (PtInRect(&sImeG.rcPctText, *lpptCursor)) {
DWORD fdwConversion;
fdwConversion = lpIMC->fdwConversion ^ IME_CMODE_SYMBOL;
ImmSetConversionStatus(hIMC, fdwConversion, lpIMC->fdwSentence);
}
if (PtInRect(&sImeG.rcCmdText, *lpptCursor)) {
if (lpIMC->fdwConversion & IME_CMODE_NATIVE) {
DWORD fdc;
if (kb_mode==CIN_STD){
kb_mode = CIN_SDA;
fdc = lpIMC->fdwConversion|IME_CMODE_SDA;
}else{
kb_mode = CIN_STD;
fdc = lpIMC->fdwConversion&~IME_CMODE_SDA;
}
ImmSetConversionStatus(hIMC, fdc, lpIMC->fdwSentence);
{
LPPRIVCONTEXT lpImcP;
lpImcP = (LPPRIVCONTEXT)ImmLockIMCC(lpIMC->hPrivate);
ghIMC=hIMC;
glpIMCP=lpImcP;
glpIMC=lpIMC;
lpImcP->fdwImeMsg=lpImcP->fdwImeMsg & ~MSG_IN_IMETOASCIIEX;
cls_prompt();
InitCvtPara();
GenerateMessage(hIMC, lpIMC, lpImcP);
ImmUnlockIMCC(lpIMC->hPrivate);
}
DispMode(hIMC);
}else
MessageBeep((UINT)-1);
}
ImmUnlockIMC(hIMC);
return;
}
/**********************************************************************/
/* PaintStatusWindow() */
/**********************************************************************/
void PASCAL PaintStatusWindow(
HDC hDC,
HWND hStatusWnd)
{
HWND hUIWnd;
HIMC hIMC;
LPINPUTCONTEXT lpIMC;
HBITMAP hInputBmp, hShapeBmp, hSKBmp, hCmdBmp, hPctBmp;
HBITMAP hOldBmp;
HDC hMemDC;
int TopOfBmp = 2;
if (sImeG.yChiCharHi > 0x10)
TopOfBmp = 3;
hUIWnd = GetWindow(hStatusWnd, GW_OWNER);
hIMC = (HIMC)GetWindowLongPtr(hUIWnd, IMMGWLP_IMC);
if (!hIMC) {
MessageBeep((UINT)-1);
return;
}
if (!(lpIMC = (LPINPUTCONTEXT)ImmLockIMC(hIMC))) {
MessageBeep((UINT)-1);
return;
}
hInputBmp = (HBITMAP)NULL;
hShapeBmp = (HBITMAP)NULL;
hSKBmp = (HBITMAP)NULL;
hCmdBmp = (HBITMAP)NULL;
hPctBmp = (HBITMAP)NULL;
if (lpIMC->fdwConversion & IME_CMODE_NATIVE) {
hInputBmp = LoadBitmap(hInst, szChinese);
} else {
hInputBmp = LoadBitmap(hInst, szEnglish);
}
if (!lpIMC->fOpen) {
hShapeBmp = LoadBitmap(hInst, szNone);
hPctBmp = LoadBitmap(hInst, szNone);
hSKBmp = LoadBitmap(hInst, szNone);
if (kb_mode == CIN_SDA){
hCmdBmp = LoadBitmap(hInst, szNoSDA);
}else{
hCmdBmp = LoadBitmap(hInst, szNoSTD);
}
}else{
if (lpIMC->fdwConversion & IME_CMODE_FULLSHAPE) {
hShapeBmp = LoadBitmap(hInst, szFullShape);
} else {
hShapeBmp = LoadBitmap(hInst, szHalfShape);
}
if (lpIMC->fdwConversion & IME_CMODE_SOFTKBD) {
hSKBmp = LoadBitmap(hInst, szSoftKBD);
if (sImeG.First){
DWORD fdw;
fdw = lpIMC->fdwConversion;
ImmSetConversionStatus(hIMC,lpIMC->fdwConversion^IME_CMODE_SOFTKBD, lpIMC->fdwSentence);
ImmSetConversionStatus(hIMC, fdw, lpIMC->fdwSentence);
sImeG.First = 0;
}
} else {
hSKBmp = LoadBitmap(hInst, szNoSoftKBD);
}
if (lpIMC->fdwConversion & IME_CMODE_SYMBOL)
hPctBmp = LoadBitmap(hInst, szCPCT);
else
hPctBmp = LoadBitmap(hInst, szEPCT);
if (kb_mode == CIN_SDA){
hCmdBmp = LoadBitmap(hInst, szSDA);
}else{
hCmdBmp = LoadBitmap(hInst, szSTD);
}
}
ImmUnlockIMC(hIMC);
DrawStatusRect(hDC, 0,0,sImeG.xStatusWi-1, sImeG.yStatusHi-1);
hMemDC = CreateCompatibleDC(hDC);
if ( hMemDC )
{
hOldBmp = SelectObject(hMemDC, hInputBmp);
BitBlt(hDC, sImeG.rcInputText.left,TopOfBmp,
sImeG.rcInputText.right,
sImeG.yStatusHi,
hMemDC, 0, 0, SRCCOPY);
SelectObject(hMemDC, hCmdBmp);
BitBlt(hDC, sImeG.rcCmdText.left, TopOfBmp,
sImeG.rcCmdText.right - sImeG.rcCmdText.left,
sImeG.yStatusHi,
hMemDC, 0, 0, SRCCOPY);
SelectObject(hMemDC, hPctBmp);
BitBlt(hDC, sImeG.rcPctText.left, TopOfBmp,
sImeG.rcPctText.right - sImeG.rcPctText.left,
sImeG.yStatusHi,
hMemDC, 0, 0, SRCCOPY);
SelectObject(hMemDC, hShapeBmp);
BitBlt(hDC, sImeG.rcShapeText.left, TopOfBmp,
sImeG.rcShapeText.right - sImeG.rcShapeText.left,
sImeG.yStatusHi,
hMemDC, 0, 0, SRCCOPY);
SelectObject(hMemDC, hSKBmp);
BitBlt(hDC, sImeG.rcSKText.left, TopOfBmp,
sImeG.rcSKText.right - sImeG.rcSKText.left, //zl 95.8.25
sImeG.yStatusHi,
hMemDC, 0, 0, SRCCOPY);
SelectObject(hMemDC, hOldBmp);
DeleteDC(hMemDC);
}
DeleteObject(hInputBmp);
DeleteObject(hShapeBmp);
DeleteObject(hSKBmp);
DeleteObject(hCmdBmp);
DeleteObject(hPctBmp);
return;
}
/**********************************************************************/
/* NeedsKey() */
/* Function: Sub route for Proccesskey proc */
/* Return Value: */
/* The converted key value or 0 for not needs. */
/**********************************************************************/
WORD
NeedsKey(kv)
WORD kv;
{
WORD ascnum;
if((kv>='0')&&(kv<='9'))
return(kv);
if((kv>='A')&&(kv<='Z'))
if (cap_mode)
return(kv);
else
return(kv|0x20);
switch(kv){
case VK_RETURN:
case VK_SPACE:
case VK_ESCAPE:
case VK_BACK:
return(kv);
case VK_NUMPAD0: // 0x60
return('0');
case VK_NUMPAD1: // 0x61
case VK_NUMPAD2: // 0x62
case VK_NUMPAD3: // 0x63
case VK_NUMPAD4: // 0x64
case VK_NUMPAD5: // 0x65
case VK_NUMPAD6: // 0x66
case VK_NUMPAD7: // 0x67
case VK_NUMPAD8: // 0x68
case VK_NUMPAD9: // 0x69
ascnum = kv - VK_NUMPAD1 + '1';
break;
// case VK_MULTIPLY: // 0x6A
// return '*';
// case VK_ADD : // 0x6B
// return '+';
// case VK_SEPARATOR: // 0x6C
// case VK_SUBTRACT: // 0x6D
// case VK_DECIMAL : // 0x6E
// case VK_DIVIDE : // 0x6F
// ascnum = kv - 0x40;
// break;
case VK_DANYINHAO: // 0xc0 // [,] char = // 0x60
ascnum = 0x60;
break;
case VK_JIANHAO : // 0xbd // [-] char = // 0x2d
ascnum = 0x2d;
break;
case VK_DENGHAO : // 0xbb // [=] char = // 0x3d
ascnum = 0x3d;
break;
case VK_ZUOFANG : // 0xdb // "[" char = // 0x5b
ascnum = 0x5b;
break;
case VK_YOUFANG : // 0xdd // "]" char = // 0x5d
ascnum = 0x5d;
break;
case VK_FENHAO : // 0xba // [;] char = // 0x3b
ascnum = 0x3B;
break;
case VK_ZUODAN : // 0xde // ['] char = // 0x27
ascnum = 0x27;
break;
case VK_DOUHAO : // 0xbc // [,] char = // 0x2c
ascnum = 0x2c;
break;
case VK_JUHAO : // 0xbe // [.] char = // 0x2d
ascnum = '.';
break;
case VK_SHANGXIE : // 0xbf // [/] char = // 0x2f
ascnum = 0x2f;
break;
case VK_XIAXIE : // 0xdc // [\] char = // 0x5c
ascnum = 0x5c;
break;
case VK_SHIFT:
return(2);
default:
return(0);
}
return(ascnum);
}
/**********************************************************************/
/* NeedsKeyShift() */
/* Function: Deels with the case of Shift key Down */
/* Return Value: */
/* The converted key value. */
/**********************************************************************/
WORD
NeedsKeyShift(kv)
WORD kv;
{
WORD xx=0;
if((kv>='A')&&(kv<='Z'))
if (cap_mode)
return(kv|0x20);
else
return(kv);
switch(kv){
case '1':
xx='!';
break;
case '2':
xx='@';
break;
case '3':
xx='#';
break;
case '4':
xx='$';
break;
case '5':
xx='%';
break;
case '6':
xx='^';
break;
case '7':
xx='&';
break;
case '8':
xx='*';
break;
case '9':
xx='(';
break;
case '0':
xx=')';
break;
case VK_DANYINHAO: // 0xc0 // [,] char = // 0x60
xx = '~';
break;
case VK_JIANHAO : // 0xbd // [-] char = // 0x2d
xx = '_';
break;
case VK_DENGHAO : // 0xbb // [=] char = // 0x3d
xx = '+';
break;
case VK_ZUOFANG : // 0xdb // "[" char = // 0x5b
xx = '{';
break;
case VK_YOUFANG : // 0xdd // "]" char = // 0x5d
xx = '}';
break;
case VK_FENHAO : // 0xba // [;] char = // 0x3b
xx = ':';
break;
case VK_ZUODAN : // 0xde // ['] char = // 0x27
xx = '"';
break;
case VK_DOUHAO : // 0xbc // [,] char = // 0x2c
xx = '<';
break;
case VK_JUHAO : // 0xbe // [.] char = // 0x2d
xx = '>';
break;
case VK_SHANGXIE : // 0xbf // [/] char = // 0x2f
xx = '?';
break;
case VK_XIAXIE : // 0xdc // [\] char = // 0x5c
xx = '|';
break;
}
return xx;
}
/**********************************************************************/
/* ProcessKey() */
/* Function: Check a key if needs for the current processing */
/* Return Value: */
/* different state which input key will change IME to */
/**********************************************************************/
UINT PASCAL ProcessKey( // this key will cause the IME go to what state
WORD nCode,
UINT wParam, //uVirtKey,
UINT uScanCode,
LPBYTE lpbKeyState,
LPINPUTCONTEXT lpIMC,
LPPRIVCONTEXT lpImcP,
HIMC hIMC)
{
int x;
WORD w,op;
if (!lpIMC) {
return (CST_INVALID);
}
if (!lpImcP) {
return (CST_INVALID);
}
if (wParam == VK_MENU) { // no ALT key
return (CST_INVALID);
} else if (uScanCode & KF_ALTDOWN) { // no ALT-xx key
return (CST_INVALID);
} else if (!lpIMC->fOpen) {
return (CST_INVALID);
}
if (wParam == VK_CAPITAL){
x=cap_mode;
// Change to comply with NT 3.51 VK_CAPITAL check style 6
#ifdef LATER
if (!GetKeyState(VK_CAPITAL)&1){ //if the Caps Lock status
#else
if (GetKeyState(VK_CAPITAL)&1){ //if the Caps Lock status
#endif //LATER
DWORD fdwConversion;
cap_mode=1;
if (lpIMC->fdwConversion & IME_CMODE_NATIVE) {
// change to alphanumeric mode
fdwConversion = (lpIMC->fdwConversion|IME_CMODE_NOCONVERSION)
& ~(IME_CMODE_NATIVE);
ImmSetConversionStatus(hIMC, fdwConversion, lpIMC->fdwSentence);
{
BOOL hbool;
hbool = ImmGetOpenStatus(hIMC);
//ImmSetOpenStatus(hIMC, !hbool);
ImmSetOpenStatus(hIMC, hbool);
ghIMC=hIMC;
glpIMCP=lpImcP;
glpIMC=lpIMC;
lpImcP->fdwImeMsg=lpImcP->fdwImeMsg & ~MSG_IN_IMETOASCIIEX;
cls_prompt();
lpImcP->fdwImeMsg=lpImcP->fdwImeMsg|MSG_END_COMPOSITION;
GenerateMessage(ghIMC, glpIMC,glpIMCP);
V_Flag = 0;
bx_inpt_on = 0;
}
step_mode = 0;
}
}else{
DWORD fdwConversion;
cap_mode=0;
if (lpIMC->fdwConversion & IME_CMODE_NOCONVERSION) {
// change to alphanumeric mode
fdwConversion = (lpIMC->fdwConversion |IME_CMODE_NATIVE)
& ~(IME_CMODE_NOCONVERSION);
ImmSetConversionStatus(hIMC, fdwConversion, lpIMC->fdwSentence);
{
BOOL hbool;
hbool = ImmGetOpenStatus(hIMC);
//ImmSetOpenStatus(hIMC, !hbool);
ImmSetOpenStatus(hIMC, hbool);
ghIMC=hIMC;
glpIMCP=lpImcP;
glpIMC=lpIMC;
lpImcP->fdwImeMsg=lpImcP->fdwImeMsg & ~MSG_IN_IMETOASCIIEX;
cls_prompt();
lpImcP->fdwImeMsg=lpImcP->fdwImeMsg|MSG_END_COMPOSITION;
GenerateMessage(ghIMC, glpIMC,glpIMCP);
}
}
}
return (CST_INVALID);
}
if (lpbKeyState[VK_CONTROL]&0x80) // If CTRL pressed
// if (!((HIBYTE(HIWORD(lParam)))&0x80))
{
// DebugShow("In ProcessKey Keystate %X",*lpbKeyState);
op=0xffff;
if (nCode==VK_F2){
return TRUE;
}
if (!(lpIMC->fdwConversion &IME_CMODE_NOCONVERSION))
switch(nCode){
case '1':
op=SC_METHOD1;
break;
case '2':
op=SC_METHOD2;
break;
case '3':
op=SC_METHOD3;
break;
case '4':
op=SC_METHOD4;
break;
case '5':
op=SC_METHOD5;
break;
case '6':
op=SC_METHOD6;
break;
case '7':
op=SC_METHOD7;
break;
case '8':
op=SC_METHOD8;
break;
case '9':
op=SC_METHOD9;
break;
case '0':
op=SC_METHOD10;
break;
case 0xbd:
op='-'|0x8000;
break;
case 0xbb:
op='='|0x8000;
break;
//case 0xdb:
// op='['|0x8000;
// break;
//case 0xdd:
// op=']'|0x8000;
// break;
default:
op=0xffff;
}//switch
if(op!=0xffff){
return(TRUE);
}
return(CST_INVALID);
}
// if((nCode == VK_TAB)&&SdaPromptOpen) return 0;
if(!step_mode&&!(lpIMC->fdwConversion&IME_CMODE_FULLSHAPE))
if(nCode == ' ') return(CST_INVALID);
switch(wParam){
case VK_END:
case VK_HOME:
case VK_PRIOR:
case VK_NEXT:
if (step_mode == SELECT)
return(TRUE);
// case VK_SHIFT:
case VK_CONTROL:
// case VK_PRIOR:
// case VK_NEXT:
case VK_TAB:
// case VK_DELETE:
case VK_INSERT:
case VK_F1:
case VK_F2:
case VK_F3:
case VK_F4:
case VK_F5:
case VK_F6:
case VK_F7:
case VK_F8:
case VK_F9:
case VK_F10:
case VK_F11:
case VK_F12:
case VK_F13:
case VK_F14:
case VK_F15:
case VK_F16:
case VK_F17:
case VK_F18:
case VK_F19:
case VK_F20:
case VK_F21:
case VK_F22:
case VK_F23:
case VK_F24:
case VK_NUMLOCK:
case VK_SCROLL:
return(CST_INVALID);
}
// if ((cap_mode)&&(lpIMC->fdwConversion & IME_CMODE_FULLSHAPE)) //zl
// return(CST_INVALID);
switch(nCode){
case VK_LEFT:
case VK_UP:
case VK_RIGHT:
case VK_DOWN:
case VK_DELETE:
if (step_mode!=ONINPUT)
return(CST_INVALID);
else
return(TRUE);
}
if((step_mode==START)||(step_mode==RESELECT))
switch(nCode){
case VK_SHIFT:
case VK_RETURN:
case VK_CANCEL:
case VK_BACK:
case VK_ESCAPE:
return(CST_INVALID);
}
if (lpbKeyState[VK_SHIFT]&0x80){
// If candidate windows is already opened, stop further process.
// Keep 'shift' for stroke input mode 4/17
if (sImeG.cbx_flag) {}
else
if (lpImcP->fdwImeMsg & MSG_ALREADY_OPEN)return(CST_INVALID);
if ((w=NeedsKeyShift(nCode))!=0)
return(TRUE);
else
return(CST_INVALID);
} else{
w=NeedsKey(nCode);
if( w != 0)
return(TRUE);
}
return(CST_INVALID);
}
/**********************************************************************/
/* ImeProcessKey() */
/* Return Value: */
/* TRUE - successful, FALSE - failure */
/**********************************************************************/
BOOL WINAPI ImeProcessKey( // if this key is need by IME?
HIMC hIMC,
UINT uVirtKey,
LPARAM lParam,
CONST LPBYTE lpbKeyState)
{
LPINPUTCONTEXT lpIMC;
LPPRIVCONTEXT lpImcP;
BYTE szAscii[4];
int nChars;
BOOL fRet;
// can't compose in NULL hIMC
if (!hIMC) {
return (FALSE);
}
lpIMC = (LPINPUTCONTEXT)ImmLockIMC(hIMC);
if (!lpIMC) {
return (FALSE);
}
lpImcP = (LPPRIVCONTEXT)ImmLockIMCC(lpIMC->hPrivate);
if (!lpImcP) {
ImmUnlockIMC(hIMC);
return (FALSE);
}
nChars = ToAscii(uVirtKey, HIWORD(lParam), lpbKeyState,
(LPVOID)szAscii, 0);
if (!nChars) {
szAscii[0] = 0;
}
if (ProcessKey((WORD)uVirtKey, uVirtKey, HIWORD(lParam), lpbKeyState,
lpIMC, lpImcP, hIMC) == CST_INVALID) {
fRet = FALSE;
} else {
fRet = TRUE;
}
ImmUnlockIMCC(lpIMC->hPrivate);
ImmUnlockIMC(hIMC);
return (fRet);
}
/**********************************************************************/
/* TranslateFullChar() */
/* Return Value: */
/* the number of translated chars */
/**********************************************************************/
UINT PASCAL TranslateFullChar( // convert to Double Byte Char
LPTRANSMSGLIST lpTransBuf,
WORD wCharCode)
{
LPTRANSMSG lpTransMsg;
// if your IME is possible to generate over ? messages,
// you need to take care about it
wCharCode = sImeG.wFullABC[wCharCode - ' '];
lpTransMsg = lpTransBuf->TransMsg;
// NT need to modify this!
lpTransMsg->message = WM_CHAR;
lpTransMsg->wParam = (DWORD)HIBYTE(wCharCode);
lpTransMsg->lParam = 1UL;
lpTransMsg++;
lpTransMsg->message = WM_CHAR;
lpTransMsg->wParam = (DWORD)LOBYTE(wCharCode);
lpTransMsg->lParam = 1UL;
return (2); // generate two messages
}
/**********************************************************************/
/* TranslateTo () */
/* Return Value: */
/* the number of translated chars */
/**********************************************************************/
UINT PASCAL TranslateToAscii( // translate the key to WM_CHAR
// as keyboard driver
UINT uVirtKey,
UINT uScanCode,
LPTRANSMSGLIST lpTransBuf,
WORD wCharCode)
{
LPTRANSMSG lpTransMsg;
lpTransMsg = lpTransBuf->TransMsg;
if (wCharCode) { // one char code
lpTransMsg->message = WM_CHAR;
lpTransMsg->wParam = wCharCode;
lpTransMsg->lParam = (uScanCode << 16) | 1UL;
return (1);
}
// no char code case
return (0);
}
/**********************************************************************/
/* TranslateImeMessage() */
/* Return Value: */
/* the number of translated messages */
/**********************************************************************/
UINT PASCAL TranslateImeMessage(
LPTRANSMSGLIST lpTransBuf,
LPINPUTCONTEXT lpIMC,
LPPRIVCONTEXT lpImcP)
{
UINT uNumMsg;
UINT i;
BOOL bLockMsgBuf;
LPTRANSMSG lpTransMsg;
uNumMsg = 0;
bLockMsgBuf = FALSE;
for (i = 0; i < 2; i++) {
if (lpImcP->fdwImeMsg & MSG_IMN_COMPOSITIONSIZE) {
if (!i) {
uNumMsg++;
} else {
lpTransMsg->message = WM_IME_NOTIFY;
lpTransMsg->wParam = IMN_PRIVATE;
lpTransMsg->lParam = IMN_PRIVATE_COMPOSITION_SIZE;
lpTransMsg++;
}
}
if (lpImcP->fdwImeMsg & MSG_START_COMPOSITION) {
if (!(lpImcP->fdwImeMsg & MSG_ALREADY_START)) {
if (!i) {
uNumMsg++;
} else {
lpTransMsg->message = WM_IME_STARTCOMPOSITION;
lpTransMsg->wParam = 0;
lpTransMsg->lParam = 0;
lpTransMsg++;
lpImcP->fdwImeMsg |= MSG_ALREADY_START;
}
}
}
if (lpImcP->fdwImeMsg & MSG_IMN_COMPOSITIONPOS) {
if (!i) {
uNumMsg++;
} else {
lpTransMsg->message = WM_IME_NOTIFY;
lpTransMsg->wParam = IMN_SETCOMPOSITIONWINDOW;
lpTransMsg->lParam = 0;
lpTransMsg++;
}
}
if (lpImcP->fdwImeMsg & MSG_COMPOSITION) {
if (!i) {
uNumMsg++;
} else {
lpTransMsg->message = WM_IME_COMPOSITION;
lpTransMsg->wParam = (DWORD)lpImcP->dwCompChar;
lpTransMsg->lParam = (DWORD)lpImcP->fdwGcsFlag;
lpTransMsg++;
}
}
if (lpImcP->fdwImeMsg & MSG_GUIDELINE) {
if (!i) {
uNumMsg++;
} else {
lpTransMsg->message = WM_IME_NOTIFY;
lpTransMsg->wParam = IMN_GUIDELINE;
lpTransMsg->lParam = 0;
lpTransMsg++;
}
}
if (lpImcP->fdwImeMsg & MSG_IMN_PAGEUP) {
if (!i) {
uNumMsg++;
} else {
lpTransMsg->message = WM_IME_NOTIFY;
lpTransMsg->wParam = IMN_PRIVATE;
lpTransMsg->lParam = IMN_PRIVATE_PAGEUP;
lpTransMsg++;
}
}
if (lpImcP->fdwImeMsg & MSG_OPEN_CANDIDATE) {
if (!(lpImcP->fdwImeMsg & MSG_ALREADY_OPEN)) {
if (!i) {
uNumMsg++;
} else {
lpTransMsg->message = WM_IME_NOTIFY;
lpTransMsg->wParam = IMN_OPENCANDIDATE;
lpTransMsg->lParam = 0x0001;
lpTransMsg++;
lpImcP->fdwImeMsg |= MSG_ALREADY_OPEN;
}
}
}
if (lpImcP->fdwImeMsg & MSG_CHANGE_CANDIDATE) {
if (!i) {
uNumMsg++;
} else {
lpTransMsg->message = WM_IME_NOTIFY;
lpTransMsg->wParam = IMN_CHANGECANDIDATE;
lpTransMsg->lParam = 0x0001;
lpTransMsg++;
}
}
if (lpImcP->fdwImeMsg & MSG_IMN_UPDATE_PREDICT) {
if (!i) {
uNumMsg++;
} else {
lpTransMsg->message = WM_IME_NOTIFY;
lpTransMsg->wParam = IMN_PRIVATE;
lpTransMsg->lParam = IMN_PRIVATE_UPDATE_PREDICT;
lpTransMsg++;
}
}
if (lpImcP->fdwImeMsg & MSG_IMN_UPDATE_SOFTKBD) {
if (!i) {
uNumMsg++;
} else {
lpTransMsg->message = WM_IME_NOTIFY;
lpTransMsg->wParam = IMN_PRIVATE;
lpTransMsg->lParam = IMN_PRIVATE_UPDATE_SOFTKBD;
lpTransMsg++;
}
}
if (lpImcP->fdwImeMsg & MSG_CLOSE_CANDIDATE) {
if (lpImcP->fdwImeMsg & MSG_ALREADY_OPEN) {
if (!i) {
uNumMsg++;
} else {
lpTransMsg->message = WM_IME_NOTIFY;
lpTransMsg->wParam = IMN_CLOSECANDIDATE;
lpTransMsg->lParam = 0x0001;
lpTransMsg++;
lpImcP->fdwImeMsg &= ~(MSG_ALREADY_OPEN);
}
}
}
if (lpImcP->fdwImeMsg & MSG_END_COMPOSITION) {
if (lpImcP->fdwImeMsg & MSG_ALREADY_START) {
if (!i) {
uNumMsg++;
} else {
lpTransMsg->message = WM_IME_ENDCOMPOSITION;
lpTransMsg->wParam = 0;
lpTransMsg->lParam = 0;
lpTransMsg++;
lpImcP->fdwImeMsg &= ~(MSG_ALREADY_START);
}
}
}
if (lpImcP->fdwImeMsg & MSG_IMN_TOGGLE_UI) {
if (!i) {
uNumMsg++;
} else {
lpTransMsg->message = WM_IME_NOTIFY;
lpTransMsg->wParam = IMN_PRIVATE;
lpTransMsg->lParam = IMN_PRIVATE_TOGGLE_UI;
lpTransMsg++;
}
}
if (!i) {
HIMCC hMem;
if (!uNumMsg) {
return (uNumMsg);
}
if (lpImcP->fdwImeMsg & MSG_IN_IMETOASCIIEX) {
UINT uNumMsgLimit;
// ++ for the start position of buffer to strore the messages
uNumMsgLimit = lpTransBuf->uMsgCount;
if (uNumMsg <= uNumMsgLimit) {
lpTransMsg = lpTransBuf->TransMsg;
continue;
}
}
// we need to use message buffer
if (!lpIMC->hMsgBuf) {
lpIMC->hMsgBuf = ImmCreateIMCC(uNumMsg * sizeof(TRANSMSG));
lpIMC->dwNumMsgBuf = 0;
} else if (hMem = ImmReSizeIMCC(lpIMC->hMsgBuf,
(lpIMC->dwNumMsgBuf + uNumMsg) * sizeof(TRANSMSG))) {
if (hMem != lpIMC->hMsgBuf) {
ImmDestroyIMCC(lpIMC->hMsgBuf);
lpIMC->hMsgBuf = hMem;
}
} else {
return (0);
}
lpTransMsg = (LPTRANSMSG)ImmLockIMCC(lpIMC->hMsgBuf);
if (!lpTransMsg) {
return (0);
}
lpTransMsg += lpIMC->dwNumMsgBuf;
bLockMsgBuf = TRUE;
} else {
if (bLockMsgBuf) {
ImmUnlockIMCC(lpIMC->hMsgBuf);
}
}
}
return (uNumMsg);
}
/**********************************************************************/
/* TransAbcMsg2() */
/* Return Value: */
/* the number of translated messages */
/**********************************************************************/
UINT PASCAL TransAbcMsg2(
LPTRANSMSG lpTransMsg,
LPPRIVCONTEXT lpImcP)
{
UINT uNumMsg;
uNumMsg = 0;
if (lpImcP->fdwImeMsg & MSG_COMPOSITION) {
lpTransMsg->message = WM_IME_COMPOSITION;
lpTransMsg->wParam = (DWORD)lpImcP->dwCompChar;
lpTransMsg->lParam = (DWORD)lpImcP->fdwGcsFlag;
lpTransMsg++;
uNumMsg++;
}
if (lpImcP->fdwImeMsg & MSG_CLOSE_CANDIDATE) {
if (lpImcP->fdwImeMsg & MSG_ALREADY_OPEN) {
lpTransMsg->message = WM_IME_NOTIFY;
lpTransMsg->wParam = IMN_CLOSECANDIDATE;
lpTransMsg->lParam = 0x0001;
lpTransMsg++;
uNumMsg++;
lpImcP->fdwImeMsg &= ~(MSG_ALREADY_OPEN);
}
}
lpTransMsg->message = WM_IME_ENDCOMPOSITION;
lpTransMsg->wParam = 0;
lpTransMsg->lParam = 0;
uNumMsg++;
lpImcP->fdwImeMsg = 0;
return (uNumMsg);
}
/**********************************************************************/
/* TransAbcMsg() */
/* Return Value: */
/* the number of translated messages */
/**********************************************************************/
UINT PASCAL TransAbcMsg(
LPTRANSMSGLIST lpTransBuf,
LPPRIVCONTEXT lpImcP,
LPINPUTCONTEXT lpIMC,
UINT uVirtKey,
UINT uScanCode,
WORD wCharCode)
{
LPCOMPOSITIONSTRING lpCompStr ;
UINT uNumMsg;
int i;
int MsgCount;
LPSTR pp;
LPTRANSMSG lpTransMsg;
lpTransMsg = lpTransBuf->TransMsg;
uNumMsg = 0;
if (TypeOfOutMsg&ABC_OUT_ONE){
uNumMsg = TranslateToAscii(uVirtKey, uScanCode, lpTransBuf,wCharCode);
lpTransMsg++;
return (uNumMsg);
}else{
if (TypeOfOutMsg&ABC_OUT_ASCII){
lpTransMsg = lpTransBuf->TransMsg;
lpCompStr = (LPCOMPOSITIONSTRING)ImmLockIMCC(lpIMC->hCompStr);
if (!lpCompStr)
uNumMsg = 0;
else{
MsgCount = lpCompStr->dwResultStrLen;
pp = (LPSTR)lpCompStr + lpCompStr->dwResultStrOffset;
for (i = 0; i < MsgCount; i++){
if((BYTE)pp[i]<0x80){
WORD x;
x =(WORD)VkKeyScan((TCHAR)(BYTE)pp[i]);
lpTransMsg->message = WM_KEYUP;
lpTransMsg->wParam = (DWORD)(BYTE)x;//(DWORD)(BYTE)pp[i];
lpTransMsg->lParam = 1UL;
lpTransMsg++;
uNumMsg++;
}else{
lpTransMsg->message = WM_CHAR;
lpTransMsg->wParam = (DWORD)(BYTE)pp[i];
lpTransMsg->lParam = 1UL;
lpTransMsg++;
uNumMsg++;
}
}
ImmUnlockIMCC(lpIMC->hCompStr);
}
}else{
lpTransMsg = lpTransBuf->TransMsg;
}
}
if (lpImcP->fdwImeMsg & MSG_COMPOSITION) {
lpTransMsg->message = WM_IME_COMPOSITION;
lpTransMsg->wParam = (DWORD)lpImcP->dwCompChar;
lpTransMsg->lParam = (DWORD)lpImcP->fdwGcsFlag;
lpTransMsg++;
uNumMsg++;
}
if (lpImcP->fdwImeMsg & MSG_CLOSE_CANDIDATE) {
if (lpImcP->fdwImeMsg & MSG_ALREADY_OPEN) {
lpTransMsg->message = WM_IME_NOTIFY;
lpTransMsg->wParam = IMN_CLOSECANDIDATE;
lpTransMsg->lParam = 0x0001;
lpTransMsg++;
uNumMsg++;
lpImcP->fdwImeMsg &= ~(MSG_ALREADY_OPEN);
}
}
lpTransMsg->message = WM_IME_ENDCOMPOSITION;
lpTransMsg->wParam = 0;
lpTransMsg->lParam = 0;
lpTransMsg++;
uNumMsg++;
lpImcP->fdwImeMsg = 0;
TypeOfOutMsg = TypeOfOutMsg | COMP_NEEDS_END;
if (wait_flag||waitzl_flag){ //waitzl 2
lpTransMsg->message = WM_IME_NOTIFY;
lpTransMsg->wParam = IMN_SETCOMPOSITIONWINDOW;
lpTransMsg->lParam = 0;
lpTransMsg++;
uNumMsg++;
lpTransMsg->message = WM_IME_STARTCOMPOSITION;
lpTransMsg->wParam = 0;
lpTransMsg->lParam = 0x6699;
lpTransMsg++;
uNumMsg++;
lpImcP->fdwImeMsg |= MSG_ALREADY_START;
}
return (uNumMsg);
}
/**********************************************************************/
/* KeyFilter() */
/* Return Value: */
/* the number of translated message */
/**********************************************************************/
WORD KeyFilter(nCode,wParam,lParam,lpImcP , lpbKeyState )
WORD nCode;
WORD wParam;
DWORD lParam;
LPPRIVCONTEXT lpImcP;
LPBYTE lpbKeyState;
{
int x;
WORD w,op;
if (lpbKeyState[VK_CONTROL]&0x80) // If CTRL pressed
{
op=0xffff;
if (nCode==VK_F2){
//zst futur PostMessage(hMenuWnd,WM_COMMAND,SC_METHODA,0);
return 0;
}
switch(nCode){
case '1':
op=SC_METHOD1;
break;
case '2':
op=SC_METHOD2;
break;
case '3':
op=SC_METHOD3;
break;
case '4':
op=SC_METHOD4;
break;
case '5':
op=SC_METHOD5;
break;
case '6':
op=SC_METHOD6;
break;
case '7':
op=SC_METHOD7;
break;
case '8':
op=SC_METHOD8;
break;
case '9':
op=SC_METHOD9;
break;
case '0':
op=SC_METHOD10;
break;
case 0xbd:
op='-'|0x8000;
break;
case 0xbb:
op='='|0x8000;
break;
//case 0xdb:
// op='['|0x8000;
// break;
//case 0xdd:
// op=']'|0x8000;
// break;
default:
op=0xffff;
}//switch
if(op!=0xffff){
if(op&(WORD)0x8000)
return op;
else{
//zst future PostMessage(hMenuWnd,WM_COMMAND,op,0);
//zst future EventFrom = 1;
}
return(0);
}
return(0);
}
switch(nCode){
case VK_PRIOR:
case VK_NEXT:
case VK_HOME:
case VK_END:
if(step_mode == SELECT)
return(nCode*0x100);
else return(0);
case VK_LEFT:
case VK_UP:
case VK_RIGHT:
case VK_DOWN:
case VK_DELETE:
if (step_mode!=ONINPUT)
return(0);
else
return(nCode+0x100);
}
if (lpbKeyState/*GetKeyState*/[VK_SHIFT]&0x80){
if ((w=NeedsKeyShift(nCode))!=0)
return (w);
else
return (0);
} else{
if((w=NeedsKey(nCode)) != 0)
return (w);
}
return(0);
}
/**********************************************************************/
/* TranslateSymbolChar() */
/* Return Value: */
/* the number of translated chars */
/**********************************************************************/
UINT PASCAL TranslateSymbolChar(
LPTRANSMSGLIST lpTransBuf,
WORD wSymbolCharCode)
{
UINT uRet;
LPTRANSMSG lpTransMsg;
uRet = 0;
lpTransMsg = lpTransBuf->TransMsg;
// NT need to modify this!
lpTransMsg->message = WM_CHAR;
lpTransMsg->wParam = (DWORD)HIBYTE(wSymbolCharCode);
lpTransMsg->lParam = 1UL;
lpTransMsg++;
uRet++;
lpTransMsg->message = WM_CHAR;
lpTransMsg->wParam = (DWORD)LOBYTE(wSymbolCharCode);
lpTransMsg->lParam = 1UL;
lpTransMsg++;
uRet++;
return (uRet); // generate two messages
}
/**********************************************************************/
/* ImeToAsciiEx() */
/* Return Value: */
/* the number of translated message */
/**********************************************************************/
UINT WINAPI ImeToAsciiEx(
UINT uVirtKey,
UINT uScanCode,
CONST LPBYTE lpbKeyState,
LPTRANSMSGLIST lpTransBuf,
UINT fuState,
HIMC hIMC)
{
WORD wCharCode;
WORD wCharZl;
LPINPUTCONTEXT lpIMC;
LPCOMPOSITIONSTRING lpCompStr;
LPPRIVCONTEXT lpImcP;
UINT uNumMsg;
int iRet;
wCharCode = HIBYTE(uVirtKey);
uVirtKey = LOBYTE(uVirtKey);
if (!hIMC) {
uNumMsg = TranslateToAscii(uVirtKey, uScanCode, lpTransBuf,
wCharCode);
return (uNumMsg);
}
lpIMC = (LPINPUTCONTEXT)ImmLockIMC(hIMC);
if (!lpIMC) {
uNumMsg = TranslateToAscii(uVirtKey, uScanCode, lpTransBuf,
wCharCode);
return (uNumMsg);
}
lpImcP = (LPPRIVCONTEXT)ImmLockIMCC(lpIMC->hPrivate);
if (!lpImcP) {
ImmUnlockIMC(hIMC);
uNumMsg = TranslateToAscii(uVirtKey, uScanCode, lpTransBuf,
wCharCode);
return (uNumMsg);
}
lpImcP->fdwImeMsg = lpImcP->fdwImeMsg & (MSG_ALREADY_OPEN|
MSG_ALREADY_START) | MSG_IN_IMETOASCIIEX;
// deal with softkbd
if ((lpIMC->fdwConversion & IME_CMODE_SOFTKBD)
&& (lpImeL->dwSKWant != 0) &&
(wCharCode >= ' ' && wCharCode <= '~')) {
WORD wSymbolCharCode;
WORD CHIByte, CLOByte;
int SKDataIndex;
// Mapping VK
if(uVirtKey == 0x20) {
SKDataIndex = 0;
} else if(uVirtKey >= 0x30 && uVirtKey <= 0x39) {
SKDataIndex = uVirtKey - 0x30 + 1;
} else if (uVirtKey >= 0x41 && uVirtKey <= 0x5a) {
SKDataIndex = uVirtKey - 0x41 + 0x0b;
} else if (uVirtKey >= 0xba && uVirtKey <= 0xbf) {
SKDataIndex = uVirtKey - 0xba + 0x25;
} else if (uVirtKey >= 0xdb && uVirtKey <= 0xde) {
SKDataIndex = uVirtKey - 0xdb + 0x2c;
} else if (uVirtKey == 0xc0) {
SKDataIndex = 0x2b;
} else {
SKDataIndex = 0;
}
//
if (lpbKeyState[VK_SHIFT] & 0x80) {
CHIByte = SKLayoutS[lpImeL->dwSKWant][SKDataIndex*2] & 0x00ff;
CLOByte = SKLayoutS[lpImeL->dwSKWant][SKDataIndex*2 + 1] & 0x00ff;
} else {
CHIByte = SKLayout[lpImeL->dwSKWant][SKDataIndex*2] & 0x00ff;
CLOByte = SKLayout[lpImeL->dwSKWant][SKDataIndex*2 + 1] & 0x00ff;
}
wSymbolCharCode = (CHIByte << 8) | CLOByte;
if(wSymbolCharCode == 0x2020) {
MessageBeep((UINT) -1);
uNumMsg = 0;
} else {
uNumMsg = TranslateSymbolChar(lpTransBuf, wSymbolCharCode);
}
lpImcP->fdwImeMsg = lpImcP->fdwImeMsg & ~MSG_IN_IMETOASCIIEX;
ImmUnlockIMCC(lpIMC->hPrivate);
ImmUnlockIMC(hIMC);
return (uNumMsg);
}
sImeG.KeepKey = 0;
if(wCharZl=KeyFilter(/*wCharCode*/uVirtKey,uVirtKey,uScanCode,lpImcP , lpbKeyState )){
if(wCharZl<0x100)
wCharZl = wCharCode;
CharProc(wCharZl,/*wCharCode*/uVirtKey,uScanCode,hIMC,lpIMC,lpImcP);
}
if(TypeOfOutMsg){
uNumMsg = TransAbcMsg(lpTransBuf, lpImcP,lpIMC,uVirtKey,uScanCode, wCharCode);
}else {
uNumMsg = TranslateImeMessage(lpTransBuf, lpIMC, lpImcP);
}
lpImcP->fdwImeMsg = lpImcP->fdwImeMsg & ~MSG_IN_IMETOASCIIEX;
ImmUnlockIMCC(lpIMC->hPrivate);
ImmUnlockIMC(hIMC);
return (uNumMsg);
}
/**********************************************************************/
/* CancelCompCandWindow() */
/**********************************************************************/
void PASCAL CancelCompCandWindow( // destroy composition window
HWND hUIWnd)
{
HGLOBAL hUIPrivate;
LPUIPRIV lpUIPrivate;
hUIPrivate = (HGLOBAL)GetWindowLongPtr(hUIWnd, IMMGWLP_PRIVATE);
if (!hUIPrivate) return ;
lpUIPrivate = (LPUIPRIV)GlobalLock(hUIPrivate);
if (!lpUIPrivate) return;
if (lpUIPrivate->hCompWnd) {
// DestroyWindow(lpUIPrivate->hCompWnd);
ShowWindow(lpUIPrivate->hCompWnd,SW_HIDE);
}
if (lpUIPrivate->hCandWnd) {
DestroyWindow(lpUIPrivate->hCandWnd);
// ShowWindow(lpUIPrivate->hCandWnd,SW_HIDE);
}
GlobalUnlock(hUIPrivate);
// SendMessage(hUIWnd,WM_IME_ENDCOMPOSITION,0,0L);
return;
}
int DoPropertySheet(HWND hwndOwner,HWND hWnd)
{
PROPSHEETPAGE psp[3];
PROPSHEETHEADER psh;
BYTE KbType;
BYTE cp_ajust_flag;
BYTE auto_mode ;
BYTE cbx_flag;
BYTE tune_flag;
BYTE auto_cvt_flag;
BYTE SdOpenFlag ;
WORD wImeStyle ;
HIMC hIMC;
HWND hUIWnd;
if (sImeG.Prop) return 0;
//Fill out the PROPSHEETPAGE data structure for the Background Color
//sheet
sImeG.Prop = 1;
if(hWnd){
hUIWnd = GetWindow(hWnd,GW_OWNER);
hIMC = (HIMC)GetWindowLongPtr(hUIWnd, IMMGWLP_IMC);
}else
hIMC = 0;
wImeStyle = lpImeL->wImeStyle;
KbType = sImeG.KbType;
cp_ajust_flag=sImeG.cp_ajust_flag;
auto_mode=sImeG.auto_mode;
cbx_flag=sImeG.cbx_flag;
tune_flag=sImeG.tune_flag;
auto_cvt_flag=sImeG.auto_cvt_flag;
SdOpenFlag=sImeG.SdOpenFlag;
sImeG.unchanged = 0;
if(hIMC)
ImmSetOpenStatus(hIMC,FALSE);
if(hIMC)
{
LPINPUTCONTEXT lpIMC;
lpIMC = (LPINPUTCONTEXT)ImmLockIMC(hIMC);
if (!lpIMC) { // Oh! Oh!
return (0L);
}
DialogBox(hInst,(LPCTSTR)ImeStyleDlg, lpIMC->hWnd, ImeStyleProc);
ImmUnlockIMC(hIMC);
}else{
DialogBox(hInst,(LPCTSTR)ImeStyleDlg, hwndOwner, ImeStyleProc);
}
if(hIMC)
ImmSetOpenStatus(hIMC,TRUE);
if (sImeG.unchanged){
lpImeL->wImeStyle = wImeStyle ;
sImeG.KbType = KbType;
sImeG.cp_ajust_flag = cp_ajust_flag;
sImeG.auto_mode = auto_mode;
sImeG.cbx_flag = cbx_flag;
sImeG.tune_flag = tune_flag;
sImeG.auto_cvt_flag = auto_cvt_flag;
sImeG.SdOpenFlag = SdOpenFlag;
}else{
ChangeUserSetting();
}
sImeG.Prop = 0;
return (!sImeG.unchanged);
}
void WINAPI CenterWindow(HWND hWnd)
{
RECT WorkArea;
RECT rcRect;
int x,y,mx,my;
SystemParametersInfo(SPI_GETWORKAREA, 0, &WorkArea, 0);
GetWindowRect(hWnd,&rcRect);
mx = WorkArea.left + (WorkArea.right - WorkArea.left)/2;
my = WorkArea.top + (WorkArea.bottom - WorkArea.top)/2;
x = mx - (rcRect.right - rcRect.left)/2;
y = my - (rcRect.bottom - rcRect.top)/2;
SetWindowPos (hWnd, NULL, x, y, 0, 0, SWP_NOSIZE | SWP_NOZORDER);
return;
}
INT_PTR CALLBACK ImeStyleProc(HWND hdlg,
UINT uMessage,
WPARAM wparam,
LPARAM lparam)
{
switch (uMessage) {
case WM_INITDIALOG: /* message: initialize dialog box */
hCrtDlg = hdlg;
CenterWindow(hdlg);
if (lpImeL->wImeStyle == IME_APRS_FIX)
SendMessage(GetDlgItem(hdlg, IDC_FIX),
BM_SETCHECK,
TRUE,
0L);
else
SendMessage(GetDlgItem(hdlg, IDC_NEAR),
BM_SETCHECK,
TRUE,
0L);
if(sImeG.auto_mode)
SendMessage(GetDlgItem(hdlg, IDC_CP),
BM_SETCHECK,
TRUE,
0L);
if(sImeG.cbx_flag)
SendMessage(GetDlgItem(hdlg, IDC_CBX),
BM_SETCHECK,
TRUE,
0L);
return (TRUE);
case WM_PAINT:
{
RECT Rect;
HDC hDC;
PAINTSTRUCT ps;
GetClientRect(hdlg, &Rect); //get the whole window area
InvalidateRect(hdlg, &Rect, 1);
hDC=BeginPaint(hdlg, &ps);
Rect.left+=10;//5;
Rect.top+=8;//5;
Rect.right-=10;//5;
Rect.bottom-=52;//5;
DrawEdge(hDC, &Rect, EDGE_RAISED,/*EDGE_SUNKEN,*/ BF_RECT);
EndPaint(hdlg, &ps);
break;
}
case WM_CLOSE:
EndDialog(hdlg, FALSE);
return (TRUE);
case WM_COMMAND:
switch (wparam){
case IDC_BUTTON_OK:
EndDialog(hdlg, TRUE);
return (TRUE);
case IDC_BUTTON_ESC:
sImeG.unchanged = 1;
EndDialog(hdlg, TRUE);
return (TRUE);
case IDC_NEAR:
lpImeL->wImeStyle = IME_APRS_AUTO;
break;
case IDC_FIX:
lpImeL->wImeStyle = IME_APRS_FIX;
break;
case IDC_CP:
if (sImeG.auto_mode ==0){
sImeG.auto_mode = 1;
break;
} else
sImeG.auto_mode = 0;
break;
case IDC_CBX:
if (sImeG.cbx_flag==0)
sImeG.cbx_flag = 1;
else
sImeG.cbx_flag = 0;
break;
}
}
return (FALSE); /* Didn't process a message */
}
INT_PTR CALLBACK KbSelectProc(HWND hdlg,
UINT uMessage,
WPARAM wparam,
LPARAM lparam)
{
HWND hWndApp;
WORD wID;
LPNMHDR lpnmhdr;
return FALSE;
}
INT_PTR CALLBACK CvtCtrlProc(HWND hdlg,
UINT uMessage,
WPARAM wparam,
LPARAM lparam)
{
return FALSE;
}
/**********************************************************************/
/* ContextMenu() */
/**********************************************************************/
void PASCAL ContextMenu(
HWND hStatusWnd,
int x,
int y)
{
HWND hUIWnd;
HGLOBAL hUIPrivate;
LPUIPRIV lpUIPrivate;
HIMC hIMC;
LPINPUTCONTEXT lpIMC;
LPPRIVCONTEXT lpImcP;
HMENU hMenu, hCMenu;
POINT ptCursor; //zl #2
ptCursor.x = x;
ptCursor.y = y;
// DebugShow2("ptCursor.x", x, "ptCursor.y" ,y);
hUIWnd = GetWindow(hStatusWnd, GW_OWNER);
hIMC = (HIMC)GetWindowLongPtr(hUIWnd, IMMGWLP_IMC);
if (!hIMC) {
return;
}
lpIMC = (LPINPUTCONTEXT)ImmLockIMC(hIMC);
if (!lpIMC) {
return;
}
hUIPrivate = (HGLOBAL)GetWindowLongPtr(hUIWnd, IMMGWLP_PRIVATE);
if (!hUIPrivate) {
goto ContextMenuUnlockIMC;
}
lpUIPrivate = (LPUIPRIV)GlobalLock(hUIPrivate);
if (!lpUIPrivate) {
goto ContextMenuUnlockIMC;
}
if (!lpUIPrivate->hCMenuWnd) {
// this is important to assign owner window, otherwise the focus
// will be gone
// When UI terminate, it need to destroy this window
lpUIPrivate->hCMenuWnd = CreateWindowEx(CS_HREDRAW|CS_VREDRAW,
"Abc95Menu",
/*lpImeL->szCMenuClassName,*/ "Context Menu",
WS_POPUP|WS_DISABLED, 0, 0, 0, 0,
lpIMC->hWnd, (HMENU)NULL, lpImeL->hInst, NULL);
if (!lpUIPrivate->hCMenuWnd) {
goto ContextMenuUnlockIMC;
}
}
ScreenToClient(hStatusWnd , &ptCursor);
if (PtInRect(&sImeG.rcSKText, ptCursor)){
hMenu = LoadMenu(hInst,"SKMenu");
lpImcP = (LPPRIVCONTEXT)ImmLockIMCC(lpIMC->hPrivate);
if(lpImcP){
CheckMenuItem(hMenu,lpImeL->dwSKWant+IDM_SKL1,MF_CHECKED);
ImmUnlockIMCC(lpIMC->hPrivate);
}
}
else hMenu = LoadMenu(hInst,"MMenu");
hCMenu = GetSubMenu(hMenu, 0);
if ( lpImeL->fWinLogon == TRUE )
{
// In Logon Mode, we don't want to show help and configuration dialog
EnableMenuItem(hCMenu, 107, MF_BYCOMMAND | MF_GRAYED );
EnableMenuItem(hCMenu, 110, MF_BYCOMMAND | MF_GRAYED );
EnableMenuItem(hCMenu, 109, MF_BYCOMMAND | MF_GRAYED );
}
SetWindowLongPtr(lpUIPrivate->hCMenuWnd, CMENU_HUIWND, (LONG_PTR)hUIWnd);
SetWindowLongPtr(lpUIPrivate->hCMenuWnd, CMENU_MENU, (LONG_PTR)hMenu);
/*
if (!(lpIMC->fdwConversion & IME_CMODE_NATIVE)) {
// EnableMenuItem(hCMenu, IDM_SYMBOL, MF_BYCOMMAND|MF_GRAYED);
// EnableMenuItem(hCMenu, IDM_SOFTKBD, MF_BYCOMMAND|MF_GRAYED);
} else if (lpIMC->fOpen) {
// can not go into symbol mode
if (lpIMC->fdwConversion & IME_CMODE_EUDC) {
// EnableMenuItem(hCMenu, IDM_SYMBOL, MF_BYCOMMAND|MF_GRAYED);
} else {
if (lpIMC->fdwConversion & IME_CMODE_SYMBOL) {
// CheckMenuItem(hCMenu, IDM_SYMBOL, MF_BYCOMMAND|MF_CHECKED);
}
}
if (lpIMC->fdwConversion & IME_CMODE_SOFTKBD) {
// CheckMenuItem(hCMenu, IDM_SOFTKBD, MF_BYCOMMAND|MF_CHECKED);
}
} else {
// EnableMenuItem(hCMenu, IDM_SYMBOL, MF_BYCOMMAND|MF_GRAYED);
// EnableMenuItem(hCMenu, IDM_SOFTKBD, MF_BYCOMMAND|MF_GRAYED);
}
*/
TrackPopupMenu(hCMenu, TPM_LEFTBUTTON,
lpIMC->ptStatusWndPos.x ,
lpIMC->ptStatusWndPos.y ,
0,
lpUIPrivate->hCMenuWnd, NULL);
hMenu = (HMENU)GetWindowLongPtr(lpUIPrivate->hCMenuWnd, CMENU_MENU);
if (hMenu) {
SetWindowLongPtr(lpUIPrivate->hCMenuWnd, CMENU_MENU, (LONG_PTR)NULL);
DestroyMenu(hMenu);
}
GlobalUnlock(hUIPrivate);
ContextMenuUnlockIMC:
ImmUnlockIMC(hIMC);
return;
}
/**********************************************************************/
/* StatusSetCursor() */
/**********************************************************************/
void PASCAL StatusSetCursor(
HWND hStatusWnd,
LPARAM lParam)
{
POINT ptCursor, ptSavCursor;
RECT rcWnd;
RECT rcSt;
rcSt.left = sImeG.rcStatusText.left+3;
rcSt.top = sImeG.rcStatusText.top + 3;
rcSt.right = sImeG.rcStatusText.right-3;
rcSt.bottom = sImeG.rcStatusText.bottom;
if (GetWindowLong(hStatusWnd, UI_MOVE_OFFSET) != WINDOW_NOT_DRAG) {
SetCursor(LoadCursor(NULL, IDC_SIZEALL));
return;
}
GetCursorPos(&ptCursor);
ptSavCursor = ptCursor;
ScreenToClient(hStatusWnd, &ptCursor);
if (PtInRect(&rcSt, ptCursor)) {
SetCursor(LoadCursor(hInst,szHandCursor ));
if (HIWORD(lParam) == WM_LBUTTONDOWN) {
SetStatus(hStatusWnd, &ptCursor);
} else if (HIWORD(lParam) == WM_RBUTTONUP) {
static BOOL fImeConfigure = FALSE;
// prevent recursive
if (fImeConfigure) {
// configuration already bring up
return;
}
fImeConfigure = TRUE;
// PopStMenu(hStatusWnd, lpIMC->ptStatusWndPos.x + sImeG.xStatusWi,
// lpIMC->ptStatusWndPos.y);
ContextMenu(hStatusWnd, ptSavCursor.x, ptSavCursor.y);
fImeConfigure = FALSE;
} else {
}
return;
} else {
SetCursor(LoadCursor(NULL, IDC_SIZEALL));
if (HIWORD(lParam) == WM_LBUTTONDOWN) {
// start drag
SystemParametersInfo(SPI_GETWORKAREA, 0, &sImeG.rcWorkArea, 0);
} else {
return;
}
}
SetCapture(hStatusWnd);
SetWindowLong(hStatusWnd, UI_MOVE_XY,
MAKELONG(ptSavCursor.x, ptSavCursor.y));
GetWindowRect(hStatusWnd, &rcWnd);
SetWindowLong(hStatusWnd, UI_MOVE_OFFSET,
MAKELONG(ptSavCursor.x - rcWnd.left, ptSavCursor.y - rcWnd.top));
DrawDragBorder(hStatusWnd, MAKELONG(ptSavCursor.x, ptSavCursor.y),
GetWindowLong(hStatusWnd, UI_MOVE_OFFSET));
return;
}
/**********************************************************************/
/* StatusWndProc() */
/**********************************************************************/
//#if defined(UNIIME)
//LRESULT CALLBACK UniStatusWndProc(
// LPINSTDATAL lpInstL,
// LPIMEL lpImeL,
//#else
LRESULT CALLBACK StatusWndProc(
//#endif
HWND hStatusWnd,
UINT uMsg,
WPARAM wParam,
LPARAM lParam)
{
switch (uMsg) {
case WM_DESTROY:
if (GetWindowLong(hStatusWnd, UI_MOVE_OFFSET) != WINDOW_NOT_DRAG) {
LONG lTmpCursor, lTmpOffset;
POINT ptCursor;
HWND hUIWnd;
lTmpCursor = GetWindowLong(hStatusWnd, UI_MOVE_XY);
// calculate the org by the offset
lTmpOffset = GetWindowLong(hStatusWnd, UI_MOVE_OFFSET);
DrawDragBorder(hStatusWnd, lTmpCursor, lTmpOffset);
ReleaseCapture();
}
DestroyStatusWindow(hStatusWnd);
break;
case WM_SETCURSOR:
StatusSetCursor(
hStatusWnd, lParam);
break;
case WM_MOUSEMOVE:
if (GetWindowLong(hStatusWnd, UI_MOVE_OFFSET) != WINDOW_NOT_DRAG) {
POINT ptCursor;
DrawDragBorder(hStatusWnd,
GetWindowLong(hStatusWnd, UI_MOVE_XY),
GetWindowLong(hStatusWnd, UI_MOVE_OFFSET));
GetCursorPos(&ptCursor);
SetWindowLong(hStatusWnd, UI_MOVE_XY,
MAKELONG(ptCursor.x, ptCursor.y));
DrawDragBorder(hStatusWnd, MAKELONG(ptCursor.x, ptCursor.y),
GetWindowLong(hStatusWnd, UI_MOVE_OFFSET));
} else {
return DefWindowProc(hStatusWnd, uMsg, wParam, lParam);
}
break;
case WM_LBUTTONUP:
if (GetWindowLong(hStatusWnd, UI_MOVE_OFFSET) != WINDOW_NOT_DRAG) {
LONG lTmpCursor, lTmpOffset;
POINT ptCursor;
HWND hUIWnd;
lTmpCursor = GetWindowLong(hStatusWnd, UI_MOVE_XY);
// calculate the org by the offset
lTmpOffset = GetWindowLong(hStatusWnd, UI_MOVE_OFFSET);
DrawDragBorder(hStatusWnd, lTmpCursor, lTmpOffset);
ptCursor.x = (*(LPPOINTS)&lTmpCursor).x - (*(LPPOINTS)&lTmpOffset).x;
ptCursor.y = (*(LPPOINTS)&lTmpCursor).y - (*(LPPOINTS)&lTmpOffset).y;
SetWindowLong(hStatusWnd, UI_MOVE_OFFSET, WINDOW_NOT_DRAG);
ReleaseCapture();
AdjustStatusBoundary(&ptCursor);
hUIWnd = GetWindow(hStatusWnd, GW_OWNER);
/* SendMessage(GetWindow(hStatusWnd, GW_OWNER), WM_IME_CONTROL,
IMC_SETSTATUSWINDOWPOS, NULL); */
ImmSetStatusWindowPos((HIMC)GetWindowLongPtr(hUIWnd, IMMGWLP_IMC),
&ptCursor);
if (lpImeL->wImeStyle == IME_APRS_FIX){ //003
ReInitIme(hStatusWnd,lpImeL->wImeStyle); //#@3
MoveCompCand(GetWindow(hStatusWnd, GW_OWNER));
}
} else {
return DefWindowProc(hStatusWnd, uMsg, wParam, lParam);
}
break;
case WM_IME_NOTIFY:
if (wParam == IMN_SETSTATUSWINDOWPOS) {
SetStatusWindowPos(hStatusWnd);
}
break;
case WM_PAINT:
{
HDC hDC;
PAINTSTRUCT ps;
hDC = BeginPaint(hStatusWnd, &ps);
PaintStatusWindow(
hDC,hStatusWnd); //zl
EndPaint(hStatusWnd, &ps);
}
break;
case WM_MOUSEACTIVATE:
return (MA_NOACTIVATE);
default:
return DefWindowProc(hStatusWnd, uMsg, wParam, lParam);
}
return (0L);
}
/**********************************************************************/
/* DrawDragBorder() */
/**********************************************************************/
void PASCAL DrawDragBorder(
HWND hWnd, // window of IME is dragged
LONG lCursorPos, // the cursor position
LONG lCursorOffset) // the offset form cursor to window org
{
HDC hDC;
int cxBorder, cyBorder;
int x, y;
RECT rcWnd;
cxBorder = GetSystemMetrics(SM_CXBORDER); // width of border
cyBorder = GetSystemMetrics(SM_CYBORDER); // height of border
// get cursor position
x = (*(LPPOINTS)&lCursorPos).x;
y = (*(LPPOINTS)&lCursorPos).y;
// calculate the org by the offset
x -= (*(LPPOINTS)&lCursorOffset).x;
y -= (*(LPPOINTS)&lCursorOffset).y;
// check for the min boundary of the display
if (x < sImeG.rcWorkArea.left) {
x = sImeG.rcWorkArea.left;
}
if (y < sImeG.rcWorkArea.top) {
y = sImeG.rcWorkArea.top;
}
// check for the max boundary of the display
GetWindowRect(hWnd, &rcWnd);
if (x + rcWnd.right - rcWnd.left > sImeG.rcWorkArea.right) {
x = sImeG.rcWorkArea.right - (rcWnd.right - rcWnd.left);
}
if (y + rcWnd.bottom - rcWnd.top > sImeG.rcWorkArea.bottom) {
y = sImeG.rcWorkArea.bottom - (rcWnd.bottom - rcWnd.top);
}
// draw the moving track
hDC = CreateDC("DISPLAY", NULL, NULL, NULL);
if ( hDC == NULL )
return;
SelectObject(hDC, GetStockObject(GRAY_BRUSH));
// ->
PatBlt(hDC, x, y, rcWnd.right - rcWnd.left - cxBorder, cyBorder,
PATINVERT);
// v
PatBlt(hDC, x, y + cyBorder, cxBorder, rcWnd.bottom - rcWnd.top -
cyBorder, PATINVERT);
// _>
PatBlt(hDC, x + cxBorder, y + rcWnd.bottom - rcWnd.top,
rcWnd.right - rcWnd.left - cxBorder, -cyBorder, PATINVERT);
// v
PatBlt(hDC, x + rcWnd.right - rcWnd.left, y,
- cxBorder, rcWnd.bottom - rcWnd.top - cyBorder, PATINVERT);
DeleteDC(hDC);
return;
}
/**********************************************************************/
/* AdjustStatusBoundary() */
/**********************************************************************/
void PASCAL AdjustStatusBoundary(
LPPOINT lppt)
{
// display boundary check
if (lppt->x < sImeG.rcWorkArea.left) {
lppt->x = sImeG.rcWorkArea.left;
} else if (lppt->x + sImeG.xStatusWi > sImeG.rcWorkArea.right) {
lppt->x = (sImeG.rcWorkArea.right - sImeG.xStatusWi);
}
if (lppt->y < sImeG.rcWorkArea.top) {
lppt->y = sImeG.rcWorkArea.top;
} else if (lppt->y + sImeG.yStatusHi > sImeG.rcWorkArea.bottom) {
lppt->y = (sImeG.rcWorkArea.bottom - sImeG.yStatusHi);
}
return;
}
/**********************************************************************/
/* ContextMenuWndProc() */
/**********************************************************************/
LRESULT CALLBACK ContextMenuWndProc(
HWND hCMenuWnd,
UINT uMsg,
WPARAM wParam,
LPARAM lParam)
{
switch (uMsg) {
case WM_DESTROY:
{
HWND hUIWnd;
hUIWnd = (HWND)GetWindowLongPtr(hCMenuWnd, CMENU_HUIWND);
if (hUIWnd) {
SendMessage(hUIWnd, WM_IME_NOTIFY, IMN_PRIVATE,
IMN_PRIVATE_CMENUDESTROYED);
}
break;
}
case WM_USER_DESTROY:
{
SendMessage(hCMenuWnd, WM_CLOSE, 0, 0);
DestroyWindow(hCMenuWnd);
break;
}
case WM_COMMAND:
{
HWND hUIWnd;
hUIWnd = (HWND)GetWindowLongPtr(hCMenuWnd, CMENU_HUIWND);
CommandProc(wParam , GetStatusWnd(hUIWnd));
break;
}
// switch (wParam) {
/*
case IDM_SOFTKBD:
case IDM_SYMBOL:
{
HWND hUIWnd;
HIMC hIMC;
DWORD fdwConversion;
DWORD fdwSentence;
hUIWnd = (HWND)GetWindowLongPtr(hCMenuWnd, CMENU_HUIWND);
hIMC = (HIMC)GetWindowLongPtr(hUIWnd, IMMGWLP_IMC);
ImmGetConversionStatus(hIMC, &fdwConversion,
&fdwSentence);
if (wParam == IDM_SOFTKBD) {
ImmSetConversionStatus(hIMC, fdwConversion ^
IME_CMODE_SOFTKBD, fdwSentence);
}
if (wParam == IDM_SYMBOL) {
ImmSetConversionStatus(hIMC, fdwConversion ^
IME_CMODE_SYMBOL, fdwSentence);
}
SendMessage(hCMenuWnd, WM_CLOSE, 0, 0);
}
break;
case IDM_PROPERTIES:
ImeConfigure(GetKeyboardLayout(0), hCMenuWnd,
IME_CONFIG_GENERAL, NULL);
SendMessage(hCMenuWnd, WM_CLOSE, 0, 0);
break; */
// default:
// return DefWindowProc(hCMenuWnd, uMsg, wParam, lParam);
// }
// break;
case WM_CLOSE:
{
HMENU hMenu;
GetMenu(hCMenuWnd);
hMenu = (HMENU)GetWindowLongPtr(hCMenuWnd, CMENU_MENU);
if (hMenu) {
SetWindowLongPtr(hCMenuWnd, CMENU_MENU, (LONG_PTR)NULL);
DestroyMenu(hMenu);
}
}
return DefWindowProc(hCMenuWnd, uMsg, wParam, lParam);
default:
return DefWindowProc(hCMenuWnd, uMsg, wParam, lParam);
}
return (0L);
}
/**********************************************************************/
/* DestroyUIWindow() */
/**********************************************************************/
void PASCAL DestroyUIWindow( // destroy composition window
HWND hUIWnd)
{
HGLOBAL hUIPrivate;
LPUIPRIV lpUIPrivate;
hUIPrivate = (HGLOBAL)GetWindowLongPtr(hUIWnd, IMMGWLP_PRIVATE);
if (!hUIPrivate) { // Oh! Oh!
return;
}
lpUIPrivate = (LPUIPRIV)GlobalLock(hUIPrivate);
if (!lpUIPrivate) { // Oh! Oh!
return;
}
if (lpUIPrivate->hCMenuWnd) {
SetWindowLongPtr(lpUIPrivate->hCMenuWnd, CMENU_HUIWND,(LONG_PTR)0);
PostMessage(lpUIPrivate->hCMenuWnd, WM_USER_DESTROY, 0, 0);
}
// composition window need to be destroyed
if (lpUIPrivate->hCompWnd) {
DestroyWindow(lpUIPrivate->hCompWnd);
}
// candidate window need to be destroyed
if (lpUIPrivate->hCandWnd) {
DestroyWindow(lpUIPrivate->hCandWnd);
}
// status window need to be destroyed
if (lpUIPrivate->hStatusWnd) {
DestroyWindow(lpUIPrivate->hStatusWnd);
}
// soft keyboard window need to be destroyed
if (lpUIPrivate->hSoftKbdWnd) {
ImmDestroySoftKeyboard(lpUIPrivate->hSoftKbdWnd);
}
GlobalUnlock(hUIPrivate);
// free storage for UI settings
GlobalFree(hUIPrivate);
return;
}
/**********************************************************************/
/* CMenuDestryed() */
/**********************************************************************/
void PASCAL CMenuDestroyed( // context menu window
// already destroyed
HWND hUIWnd)
{
HGLOBAL hUIPrivate;
LPUIPRIV lpUIPrivate;
hUIPrivate = (HGLOBAL)GetWindowLongPtr(hUIWnd, IMMGWLP_PRIVATE);
if (!hUIPrivate) { // Oh! Oh!
return;
}
lpUIPrivate = (LPUIPRIV)GlobalLock(hUIPrivate);
if (!lpUIPrivate) { // Oh! Oh!
return;
}
lpUIPrivate->hCMenuWnd = NULL;
GlobalUnlock(hUIPrivate);
}
Reference in a new issue View git blame Copy permalink