events.c

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

/*
		SendMessage (hWnd, WM_KEYUP,   NULL, NULL);
		PeekMessage (&msg, hWnd, NULL, NULL, NULL);

		PostMessage (hWnd, WM_KEYDOWN, 0xffff, 1);

//		PostMessage (hWnd, WM_KEYDOWN, 0xffff, 0x00000001);
//		PostMessage (hWnd, WM_KEYDOWN, NULL,   0x00000001);
//		PostMessage (hWnd, WM_KEYDOWN, NULL,   NULL);
*/
		wSendStrTag &= ~(SST_SENDINGFIRST | SST_SENDINGLAST);
		wSendStrTag |= SST_SENDINGLAST;
		PostMessage (hWnd, WM_CHAR, (WPARAM)(BYTE)(*lpStr), 0x00390001);
		}
	    else
		{
		wSendStrTag &= ~(SST_SENDINGFIRST | SST_SENDINGLAST);
		PostMessage (hWnd, WM_CHAR, (WPARAM)(BYTE)(*lpStr), 0x00390001);
		}
	    }
	SendMessage (hWnd, WM_KEYUP,   NULL, NULL);
	PeekMessage (&msg, hWnd, NULL, NULL, NULL);
	PostMessage (hWnd, WM_IME_REPORT, IR_STRINGEND, (LPARAM)hStrMem);
	wSendStrTag &= ~(SST_SENDINGFIRST | SST_SENDINGLAST);
	}

    GlobalFree (hStrMem);
    return wCnt;
}

UINT WINAPI WseAppendStringCache (LPSTR lpStr)
{
    UINT wCnt;
    LPSTR lps;

    if (!lpStr)
	{
	pStrCache = 0;
	return NULL;
	}

    wCnt = lstrlen (lpStr);
    while (wCnt >= wStrCacheSize)
	{
	lps = AnsiNext (lpStr);
	wCnt -= lps-lpStr;
	lpStr = lps;
	}

    lps = GlobalLock (hStrCache);
    while (wStrCacheSize - pStrCache + LOWORD(lps) < wCnt)
	lps = AnsiNext (lps);

    if (LOWORD(lps))
	{
	WseRepMovsb ((LPSTR)MAKELONG(0,HIWORD(lps)),
		     lps, pStrCache-LOWORD(lps));
	pStrCache -= LOWORD(lps);
	*(LPWORD)lps = 0;
	}
    WseRepMovsb (lps+pStrCache, lpStr, wCnt);

    pStrCache += wCnt;
    GlobalUnlock (hStrCache);
    return wCnt;
}

UINT WINAPI WseGetStringCache (UINT wPos, LPSTR lpBuffer, UINT wCnt)
{
    LPSTR lps, lps1, lps2;
    UINT i;

    lps = GlobalLock (hStrCache);
    if (wPos == -1)
	{
	for (i = 0, lps2 = lps1 = lps+pStrCache;
	     i < wCnt && lps1 > lps;
	     i++)
	    lps1 = WseCharPrev (HCODE_DEFAULT, lps, lps1);
	wCnt = i;
	}
    else
	{
	for (i = 0, lps1 = lps;
	     i < wPos, lps1 < lps+pStrCache;
	     i++)
	    lps1 = WseCharNext (HCODE_DEFAULT, lps1);
	for (i = 0, lps2 = lps1;
	     i < wCnt, lps2 < lps+pStrCache;
	     i++)
	    lps2 = WseCharNext (HCODE_DEFAULT, lps2);
	wCnt = i;
	}
    WseRepMovsb (lpBuffer, lps1, lps2 - lps1);
    GlobalUnlock (hStrCache);
    return wCnt;
}

void SendCharKey (char c)
{
    UINT uChar;

    uChar = VkKeyScan (c);
    if ((GetKeyState (VK_SHIFT) & 0x80) && HIBYTE(uChar) == 0)
	    {
	    WseSendOneKey (VK_SHIFT, FALSE);
	    WseSendOneKey (uChar & 0xff, TRUE);
	    WseSendOneKey (uChar & 0xff, FALSE);
	    WseSendOneKey (VK_SHIFT, TRUE);
	    }
    else if (!(GetKeyState (VK_SHIFT) & 0x80) && HIBYTE(uChar) == 1)
	    {
	    WseSendOneKey (VK_SHIFT, TRUE);
	    WseSendOneKey (uChar & 0xff, TRUE);
	    WseSendOneKey (uChar & 0xff, FALSE);
	    WseSendOneKey (VK_SHIFT, FALSE);
	    }
    else if (HIBYTE(uChar) < 2)
	    {
	    WseSendOneKey (uChar & 0xff,TRUE);
	    WseSendOneKey (uChar & 0xff,FALSE);
	    }
}

/*
LRESULT CALLBACK PenCallWndProc (int Code, WPARAM wParam, LPARAM lParam)
{
    int        i;
    char       Buff[4];
    LPRCRESULT lpRcs;
    HANDLE     hHW;
    HANDWRITEHEADER FAR *lpHW;
    LPPENDATA  lpPenDat;
    LPPOINT    lpPnts;
    STROKEINFO sInfo;

#ifndef DEMO
    i = ((LPWORD)lParam)[3];
    if (Code < 0)
	return CallNextHookEx (hPenHook, Code, wParam, lParam);
    else if (i == WM_LBUTTONDOWN)
	{
	GetKeyboardState ((LPBYTE)pKbState);
	if (DispatchHotKey (VK_LBUTTON, NULL, pKbState))
	    ((LPWORD)lParam)[3] = WM_TIMER;
	return 0L;
	}
    else if (i == WM_RBUTTONDOWN)
	{
	GetKeyboardState ((LPBYTE)pKbState);
	if (DispatchHotKey (VK_RBUTTON, NULL, pKbState))
	    ((LPWORD)lParam)[3] = WM_TIMER;
	return 0L;
	}
    else if (i != WM_RCRESULT)
	return 0L;

    if (!bEnableCIM)
	return 0L;

    lpRcs = *(LPRCRESULT FAR *)lParam;

    if (wPenTag & PENTAG_TRAPALPHA)
	{
	for (i=0; i < lpRcs->cSyv; i++)
	    {
	    if (fpSymbolToCharacter (lpRcs->lpsyv+i, (int)1,
				     (LPSTR)Buff, (LPINT)NULL))
		{
		SendCharKey (*Buff);
		((LPWORD)lParam)[3] = WM_TIMER;
		}
	    }
	}

    else if (wPenTag & PENTAG_TRAPSTROKE)
	{
	if (lpPenDat = (LPPENDATA)fpBeginEnumStrokes ((HANDLE)lpRcs->hpendata))
	    {
	    hHW = GlobalAlloc (GMEM_SHARE | GHND,
			       lpPenDat->cStrokes*sizeof(HANDWRITEDATA) +
			       lpPenDat->cPnt*sizeof(POINT) +
			       sizeof(HANDWRITEHEADER) + 16);
	    lpHW = (HANDWRITEHEADER FAR *)GlobalLock (hHW);
	    lpHW->cStrokes	   = lpPenDat->cStrokes;
	    lpHW->cPnt		   = lpPenDat->cPnt;
	    lpHW->cPntMax	   = lpPenDat->cPntStrokeMax;
	    lpHW->rectBound.left   = lpPenDat->rectBound.left;
	    lpHW->rectBound.right  = lpPenDat->rectBound.right;
	    lpHW->rectBound.top    = lpPenDat->rectBound.top;
	    lpHW->rectBound.bottom = lpPenDat->rectBound.bottom;
	    lpHW++;

	    for (i = 0; i <lpPenDat->cStrokes; i++)
		{
		if (fpGetPenDataStroke ((LPPENDATA)lpPenDat,
					(UINT)i,
					(LPPOINT FAR *)&lpPnts,
					(LPVOID FAR *)NULL,
					(LPSTROKEINFO)&sInfo))
		    {
		    ((LPHANDWRITEDATA)lpHW)->cPnt   = sInfo.cPnt;
		    ((LPHANDWRITEDATA)lpHW)->dwTick = sInfo.dwTick;
		    ((LPHANDWRITEDATA)lpHW)++;
		    WseRepMovsb ((LPSTR)lpHW, (LPSTR)lpPnts,
				 sizeof(POINT)*sInfo.cPnt);
		    (LPPOINT)lpHW += sInfo.cPnt;
		    }
		}
	    EndEnumStrokes (lpRcs->hpendata);
	    GlobalUnlock (hHW);
	    lpHW = (HANDWRITEHEADER FAR *)GlobalLock (hHW);

//	    WseSendControlMessage (CMSYS_CONTROL, MC_PENUP, 0, (LPARAM)lpHW);
	    {
	    HCURSOR hCur = SetCursor (LoadCursor (NULL, IDC_WAIT));
	    ShowCursor (TRUE);
	    if (WseSendControlMessage (CMSYS_CIM, MC_PENUP, 0, (LPARAM)lpHW))
		{
		lpRcs->wResultsType = RCRT_NOSYMBOLMATCH;
		}
	    ShowCursor (FALSE);
	    SetCursor (hCur);
	    }
	    GlobalUnlock (hHW);
	    GlobalFree (hHW);
	    }
	}
#endif
    return 0L;
}

#ifdef CHECKPEN

/////////////////////////////////////////////////////////////////////////
//  This Code is used for MC_PENUP (HandWriting) Data testing
//
void PaintPenStrokes (HWND hWnd, LPHANDWRITEHEADER lpHW)
{
    RECT rect;
    LPHANDWRITEDATA lpStroke;
    LPPOINT lpPoint;
    int i,j;
    HDC hDC;
    HBRUSH hbOld;

    hDC = GetDC (hWnd);

    GetWindowRect (hWnd, &rect);
    rect.right -= rect.left+16;
    rect.bottom -= rect.top+16;
    hbOld = SelectObject (hDC, GetStockObject (LTGRAY_BRUSH));
    Rectangle (hDC, 0, 0, rect.right+16, rect.bottom+16);
    SelectObject (hDC, hbOld);
    for (i = 0, lpStroke = (LPHANDWRITEDATA)(lpHW+1); i<lpHW->cStrokes; i++)
	{
	lpPoint = lpStroke->pts;
	MoveTo (hDC,
		MulDiv (lpPoint->x-lpHW->rectBound.left,
			rect.right,
			lpHW->rectBound.right - lpHW->rectBound.left) + 8,
		MulDiv (lpPoint->y-lpHW->rectBound.top,
			rect.bottom,
			lpHW->rectBound.bottom - lpHW->rectBound.top) + 8);
	for (j = 0; j < lpStroke->cPnt; j++, lpPoint++)
	    {
	    LineTo (hDC,
		    MulDiv (lpPoint->x-lpHW->rectBound.left,
			    rect.right,
			    lpHW->rectBound.right - lpHW->rectBound.left)+8,
		    MulDiv (lpPoint->y-lpHW->rectBound.top,
			    rect.bottom,
			    lpHW->rectBound.bottom - lpHW->rectBound.top)+8);
	    }
	lpStroke = (LPHANDWRITEDATA)lpPoint;
	}
    ReleaseDC (hWnd, hDC);
}

#endif
*/
LRESULT CALLBACK MouseHookProc (int Code, WPARAM wParam, LPARAM lParam)
{
    if (Code < 0)
	return CallNextHookEx (hhMouse, Code, wParam, lParam);

    if (wParam == WM_LBUTTONDOWN)
	{
	GetKeyboardState ((LPBYTE)pKbState);
	if (DispatchHotKey (VK_LBUTTON, (LPARAM)NULL, (LPBYTE)pKbState))
	    return 1L;
	}
    else if (wParam == WM_RBUTTONDOWN)
	{
	GetKeyboardState ((LPBYTE)pKbState);
	if (DispatchHotKey (VK_RBUTTON, (LPARAM)NULL, (LPBYTE)pKbState))
	    return 1L;
	}

    return 0;
}

BOOL far _InitEvents ()
{
    pKbState = (BYTE NEAR *)LocalAlloc (LPTR, 0x110);
    hKbHook = SetWindowsHookEx (WH_KEYBOARD, (HOOKPROC)KeyBoardHookProc,
				hInst, NULL);

/*
#ifndef DEMO
    if (hPenWin = GetSystemMetrics (SM_PENWINDOWS))
	{
	fpSymbolToCharacter = GetProcAddress (hPenWin, szSymbolToCharacter);
	fpBeginEnumStrokes  = (BEGINENUMSTROKES)GetProcAddress (hPenWin,
			      szBeginEnumStrokes);
	fpGetPenDataStroke  = GetProcAddress (hPenWin, szGetPenDataStroke);
	if (fpSymbolToCharacter && fpBeginEnumStrokes && fpGetPenDataStroke)
	    hPenHook = SetWindowsHookEx (WH_CALLWNDPROC,
					 (FARPROC)PenCallWndProc,
					 hInst,
					 NULL);
	}
#endif
*/
    hhMouse = SetWindowsHookEx (WH_MOUSE, (FARPROC)MouseHookProc,
				hInst, NULL);

    if (WseGetProfileInt (szSystem, szCWinKey, 0))
	wCWinKey = 0x0000;

	return TRUE;
}

BOOL far _ExitEvents ()
{
#ifndef DEMO
    if (hPenHook)
	UnhookWindowsHookEx (hPenHook);
#endif

    UnhookWindowsHookEx (hKbHook);
    LocalFree ((HANDLE)pKbState);

	return TRUE;
}