events.c

windows环境下的一套汉字处理引擎,可以对汉字进行相应的处理

/*********************************************************************
    Name:
	Engine.c
    Module:
	WSENGINE
    Version:
	1.00.0
    Description:
	Windows Key and String Processing
    Date:
	1993 Oct. - 1993 Dec.
    Created By:
	Wang Zhidong
    Imports:
	DispatchHotKey
    Functions:
	KeyBoardHookProc
	SendStringToDOS
	PenCallWndProc
	MouseHookProc
	_InitEvents
	_ExitEvents
    Exports:
	WseEnableCIM
	WseSendOneKey
	WseSendString
	WseSendString2
	WseAppendStringCache
	WseGetStringCache
*********************************************************************/

#include <Windows.h>
#include <mate.h>
#include "engine.h"

extern HINSTANCE    hInst;
extern int  bCWinVer;
extern char szSystem[];
extern char szCWinKey[];
extern char szEdit[];
extern char szTTY[];
extern char szSymbolToCharacter[];
extern char szBeginEnumStrokes[];
extern char szGetPenDataStroke[];

BYTE NEAR *pKbState;
HHOOK	   hKbHook = NULL;
HHOOK	   hhMouse = NULL;

HTASK	hMainTask = NULL;

WORD	wCWinKey = 0xffff;

HHOOK hPenHook = NULL;
FARPROC fpSymbolToCharacter, fpGetPenDataStroke;
HANDLE hPenWin;
BEGINENUMSTROKES    fpBeginEnumStrokes;

UINT   wPenTag = NULL;

UINT	wSendStrTag = NULL;

HGLOBAL hStrCache =NULL;
UINT	wStrCacheSize = 4096;
UINT	pStrCache = 0;
UINT	wStrCacheTag = FALSE;

// void WINAPI keybd_event (void);

BOOL FAR DispatchHotKey (UINT, LPARAM, LPBYTE);

BOOL bEnableCIM = TRUE;

BOOL WINAPI WseEnableCIM (BOOL bEnable)
{
    BOOL bRet = bEnableCIM;
    bEnableCIM = bEnable;
    return bRet;
}

///////////////////////////////////////////////////////////////////
//  Windows Keyboard Hook Proceture
//
LRESULT WINAPI KeyBoardHookProc (int code, WPARAM wVirtKey, LPARAM lParam)
{
    KEYDOWNMSG km;
    BOOL       bc = bEnableCIM;

    if (code >= 0 && code != HC_NOREMOVE && wVirtKey)
	{
	km.lParam    = lParam;
	km.lpKbState = (LPBYTE)pKbState;
	GetKeyboardState ((LPBYTE)pKbState);
	if (DispatchHotKey (wVirtKey, lParam, pKbState) ||
	    (bc && WseSendControlMessage (CMSYS_CIM,
									  (WORD)((lParam & 0x80000000L) ? MC_KEYUP
											 	 	 	     		: MC_KEYDOWN),
									  (WPARAM)wVirtKey,
									  (LPARAM)(LPKEYDOWNMSG)&km)))
	    return TRUE;
	}
    return CallNextHookEx (hKbHook, code, wVirtKey, lParam);
}

/////////////////////////////////////////////////////////////////////////
//  Simulate a key press/release event.
//  Parameters:
//	WORD	vk;	//  Virt Key
//	BOOL	bDown;	//  Key Press Event
//  Return:
//	(none)
//
void WINAPI WseSendOneKey (UINT vk, BOOL bDown)
{
    UINT wScan;

    if (!bDown)
		vk |= 0x8000;
    wScan = MapVirtualKey (vk, 0);
    _asm {
		mov eax,vk
		mov ebx,wScan
		call keybd_event
		}
}

/*
int WINAPI SendStringToDOS (LPSTR lpStr)
{
    UINT    wCnt, i, wPos, wSize;
    WORD    wSeg = 0;
    LPSTR   lpDat = NULL;

    _asm {
	mov ax,ds
	mov wSeg,ax

	mov ah,0EFH
	int 16H
	cmp ax,8407H
	jnz SASA_11
	cmp cx,40651
	jnz SASA_11
	    mov WORD PTR lpDat,dx
	    mov wSize,bx
	SASA_11:
	}
    if (lpDat == NULL)
	return NULL;

    wSeg = AllocSelector (wSeg);
    SetSelectorBase (wSeg,((DWORD)lpDat)<<4);
    SetSelectorLimit (wSeg, 0x300);

    lpDat = MAKELP(wSeg,0);

    i	 = *(LPINT)(lpDat+0x7c);
    wPos = *(LPINT)(lpDat+0x7e);
    wCnt = wPos-i;
    if (i < 0x100 || wCnt > wSize)
	{
	wPos =
	*(LPINT)(lpDat+0x7c) =
	*(LPINT)(lpDat+0x7e) = 0x100;
	}

    if (i != 0x100)
	{
	if (wCnt)
	    WseRepMovsb (lpDat+0x100, lpDat+i, wCnt);
	*(LPINT)(lpDat+0x7c) = 0x100;
	wPos =
	*(LPINT)(lpDat+0x7e) = 0x100+wCnt;
	}

    i = lstrlen (lpStr);
    if (i > wSize - wCnt)
	wCnt = wSize - wCnt;
    else
	wCnt = i;

    for (i = 0; i < wCnt; i++)
	((LPINT)(lpDat+wPos))[i]= MAKEWORD(lpStr[i], 0);

    wPos += 2*wCnt;
    *(LPINT)(lpDat+0x7e) = wPos;

    FreeSelector (wSeg);
    return wCnt;
}
*/

int WINAPI WseSendString (HWND hWnd, LPSTR lpStr)
{
    char szname[6];
//    char cc;
    int cnt;
    NPSTR pNewStr, pStr1;
//    NPSTR pOldStr;
    HANDLE hStrBuff;

    if (wStrCacheTag)
	WseAppendStringCache (lpStr);

    cnt = lstrlen (lpStr);
    hStrBuff = LocalAlloc (LPTR, cnt+2);
    WseTranslateString (HTRANS_SYSTEM_DEFAULT, lpStr, cnt,
			(LPSTR)(NPSTR)hStrBuff, cnt);
    lpStr = (LPSTR)(NPSTR)hStrBuff;

    pNewStr = NULL;
    if (wSendStrTag & SST_ADDSPACE)
	{
	pStr1	=
	pNewStr = (NPSTR)LocalAlloc (LPTR, lstrlen (lpStr) * 2 + 4);
	if (!pNewStr)
	    {
	    LocalFree (hStrBuff);
	    return NULL;
	    }
	while (*lpStr)
	    {
	    if (WseIsLeadingByte (HCODE_DEFAULT, lpStr))
		{
		*(WORD *)pStr1 = *(LPWORD)lpStr;
		pStr1[2] = ' ';
		lpStr += 2;
		pStr1 += 3;
		}
	    else
		{
		*pStr1 = *lpStr;
		pStr1++;
		lpStr++;
		}
	    }
	lpStr = (LPSTR)pNewStr;
	}

    if (!hWnd)
	hWnd = GetFocus ();

    GetClassName (hWnd, szname, 5);

/*
    if (GetCurrentTask () == hMainTask && !bCWinVer &&
	lstrcmpi (szname, szEdit) == NULL)
		{
		wSendStrTag &= ~(SST_SENDINGFIRST | SST_SENDINGLAST);

		while (*lpStr)
		    {
		    wSendStrTag &= ~(SST_SENDINGFIRST | SST_SENDINGLAST);
		    if (WseIsLeadingByte (HCODE_DEFAULT, lpStr) && lpStr[1])
			{
			wSendStrTag |= SST_SENDINGFIRST;
			SendMessage (hWnd, WM_CHAR, (WPARAM)(BYTE)(*lpStr), 0x00390001);
			lpStr++;
			wSendStrTag &= ~(SST_SENDINGFIRST | SST_SENDINGLAST);
			wSendStrTag |= SST_SENDINGLAST;
			SendMessage (hWnd, WM_CHAR, (WPARAM)(BYTE)(*lpStr), 0x00390001);
			}
		    else
			SendMessage (hWnd, WM_CHAR, (WPARAM)(BYTE)(*lpStr), 0x00390001);
		    lpStr++;
		    }

		}
    else if (*(DWORD *)szname == *(DWORD *)szTTY)
	cnt = SendStringToDOS (lpStr);

    else if (GetCurrentTask() == GetWindowTask (hWnd))
	cnt = WseSendControlMessage (CMSYS_CONTROL, MC_SENDSTRING,
				     hWnd, (LPARAM)lpStr);
    else
*/
	cnt = WseSendString2 (hWnd, lpStr);

    if (pNewStr)
		LocalFree ((HANDLE)pNewStr);

    LocalFree (hStrBuff);
    return cnt;
}

int WINAPI WseSendString2 (HWND hWnd, LPSTR lpStr)
{
    int wCnt;
    MSG msg;
    HGLOBAL hStrMem;
    LPSTR lpStrMem;

    if (!hWnd)
	hWnd = GetFocus ();

    wCnt = lstrlen (lpStr);
    hStrMem = GlobalAlloc (GMEM_MOVEABLE | GMEM_SHARE, wCnt+4);
    lpStrMem = GlobalLock (hStrMem);
    lstrcpy (lpStrMem, lpStr);
    GlobalUnlock (hStrMem);

    if (SendMessage (hWnd, WM_IME_REPORT, IR_STRING, (LPARAM)hStrMem))
	{
	GlobalFree (hStrMem);
	return wCnt;
	}

    if (SendMessage (hWnd, WM_IME_REPORT, IR_DBCSCHAR, NULL))
	{
	SendMessage (hWnd, WM_IME_REPORT, IR_STRINGSTART, (LPARAM)hStrMem);
	for (wCnt = 0; *lpStr; wCnt++,lpStr++)
	    {
	    if (WseIsLeadingByte (HCODE_DEFAULT, lpStr) && lpStr[1])
		{
		SendMessage (hWnd, WM_CHAR, MAKEWORD(lpStr[1],lpStr[0]), NULL);
		lpStr++;
		}
	    else
		SendMessage (hWnd, WM_CHAR, (WPARAM)(BYTE)(*lpStr), NULL);
	    }
	SendMessage (hWnd, WM_IME_REPORT, IR_STRINGEND, (LPARAM)hStrMem);
	}
    else
	{
	SendMessage (hWnd, WM_IME_REPORT, IR_STRINGSTART, (LPARAM)hStrMem);
	wSendStrTag &= ~(SST_SENDINGFIRST | SST_SENDINGLAST);
	for (wCnt = 0; *lpStr; wCnt++,lpStr++)
	    {
	    SendMessage (hWnd, WM_KEYUP,   NULL, NULL);
	    PeekMessage (&msg, hWnd, NULL, NULL, NULL);
//////////////////////////////////////////////////////////////////////
//  NOTES:
//	for C-Excel:	    NULL, 1
//	    123W:	    0xFFFF, 1
//
	    PostMessage (hWnd, WM_KEYDOWN, wCWinKey,1);

//	    PostMessage (hWnd, WM_KEYDOWN, 0xffff, 0x00000001);
//	    PostMessage (hWnd, WM_KEYDOWN, NULL,   0x00000001);
//	    PostMessage (hWnd, WM_KEYDOWN, NULL,   NULL);

	    if (WseIsLeadingByte (HCODE_DEFAULT, lpStr) && lpStr[1])
		{
		wSendStrTag &= ~(SST_SENDINGFIRST | SST_SENDINGLAST);
		wSendStrTag |= SST_SENDINGFIRST;
		PostMessage (hWnd, WM_CHAR, (WPARAM)(BYTE)(*lpStr), 0x00390001);
		lpStr++;