skbwin.c

详细的MiniGUI源代码

/*
	Copyright (C) 2004-2005 Li Yudong
*/
/*
** This program is free software; you can redistribute it and/or modify
** it under the terms of the GNU General Public License as published by
** the Free Software Foundation; either version 2 of the License, or
** (at your option) any later version.
**
** This program is distributed in the hope that it will be useful,
** but WITHOUT ANY WARRANTY; without even the implied warranty of
** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
** GNU General Public License for more details.
**
** You should have received a copy of the GNU General Public License
** along with this program; if not, write to the Free Software
** Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
*/

#include "../include/common.h"
#include "../include/bmp.h"
#include "../include/regclass.h"
#include "../include/hdc.h"
#include "../include/keyboard_pro.h"
#include "../include/skbwin.h"
#include "../include/gdi.h"
#include "../include/rect.h"
#include "../include/message.h"
#include "../include/blockheap.h"
#include "../include/invalidregion.h"
#include "../include/clipregion.h"
#include "../include/caret.h"
#include "../include/winnc.h"
#include "../include/winbase.h"
#include "../include/window.h"
#include "../include/text.h"
#include "../include/lguiapp.h"
#include "../include/imewin.h"



extern int _lGUI_iBytesDataType;

static BOOL 
InitKeyBoardData();


static void 
DestroyKeyBoardData(
	HWND hWnd
);


static BOOL 
GetClickedKeyValue(
	int x, 
	int y,
	int* iScanCode,
	int* iSubValue
);


static void 
SkbProcessKeyDown(
	HWND hWnd,
	int x, 
	int y
);


static void* 
GetLayoutStartAddress(
	void* pData, 
	int iLayout
);


static void 
InvertSetupArea(
	HDC hDC
);


static void 
InvertSKBRect(
	HDC hDC,
	LPRECT lpRect
);


static void 
SkbProcessKeyUp(
	HWND hWnd, 
	int x, 
	int y
);


PWindowsTree _lGUI_pSkbWindow;
extern PWindowsTree _lGUI_pWindowsTree;
extern PWindowsTree _lGUI_pImeWindow;


void 
CreateSkbWindow(
	LPRECT lpRect
)
{
	if(_lGUI_pSkbWindow)
		DestroySkbWindow();

	CreateWindow("skbwindow",NULL,WS_SKBWIN ,lpRect->left,lpRect->top,
		(lpRect->right - lpRect->left + 1),(lpRect->bottom - lpRect->top + 1),
		_lGUI_pWindowsTree,NULL,NULL,NULL);

}


void 
DestroySkbWindow()
{
	DestroyWindow((HWND)_lGUI_pSkbWindow);
}


void 
ShowSkbWindow()
{
	if(IsVisible((HWND)_lGUI_pSkbWindow))
		return;
	if(IsVisible((HWND)_lGUI_pImeWindow)){
		MoveUpImeWindow();
	}
	ShowWindow((HWND)_lGUI_pSkbWindow,true);
}


void 
HideSkbWindow()
{
	if(!IsVisible((HWND)_lGUI_pSkbWindow))
		return;
	if(IsVisible((HWND)_lGUI_pImeWindow)){
		MoveDownImeWindow();
	}
	ShowWindow((HWND)_lGUI_pSkbWindow,false);
}

BOOL 
RegisterSkbWindow()
{
	WNDCLASSEX wcex;

	wcex.cbSize			= sizeof(WNDCLASSEX);
	wcex.style			= 0;
	wcex.lpfnWndProc	= (WNDPROC)SkbWindowProc;
	wcex.cbClsExtra		= 0;
	wcex.cbWndExtra		= 0;
	wcex.hInstance		= 0;
	wcex.hIcon			= 0;
	wcex.hCursor		= 0;
	wcex.hbrBackground	= CreateSolidBrush(RGB(198,239,229));
	wcex.lpszMenuName	= NULL;
	wcex.lpszClassName	= "skbwindow";
	wcex.hIconSm		= 0;

	RegisterClass(&wcex);
	return true;
}


LRESULT 
SkbWindowProc(
	HWND hWnd, 
	int iMsg, 
	WPARAM wParam, 
	LPARAM lParam
)
{
	HDC hDC;
	PAINTSTRUCT ps;
	PWindowsTree pWin;

	void* pDestData;
	void* pSrcData;

	int iLayout;

	int iSize;
	POINT point;
	RECT rc;
	int x,y;


	pWin=(PWindowsTree)hWnd;

	switch(iMsg)
	{
		case LMSG_CREATE:

			InitKeyBoardData(hWnd);
			break;
		case LMSG_PENDOWN:
			CaptureMouse(hWnd,BYCLIENT);
			x = (int)wParam;
			y = (int)lParam;
			ScreenToClient(hWnd,&x, &y);

			SkbProcessKeyDown(hWnd,x,y);
			break;
		case LMSG_PENUP:
			DisCaptureMouse();
			x = (int)wParam;
			y = (int)lParam;
			ScreenToClient(hWnd,&x, &y);
			SkbProcessKeyUp(hWnd,x,y);
			//InvalidateRect(hWnd,&rc,true);

			break;
		case LMSG_PENMOVE:
			point.x = (int)wParam;
			point.y = (int)lParam;
			ScreenToClient(hWnd,&point.x, &point.y);

			break;
		case LMSG_PAINT:

			ps.bPaintDirect=false;
			hDC=BeginPaint(hWnd, &ps);
			if(!hDC){
				return true;
			}


			iLayout = GetSkbLayout();

			pSrcData = ((PLGUIKeyBoard)(pWin->dwAddData))->pData;
			pDestData = hDC->pData;

			iSize = SKBWIN_WIDTH * SKBWIN_HEIGHT * _lGUI_iBytesDataType;


			pSrcData = GetLayoutStartAddress(pSrcData,iLayout);
			memcpy(pDestData,pSrcData,iSize);
			
			if(GetSkbLayout() != SKB_LAYOUT_HANDWRITE){

				InvertSetupArea(hDC);
			}
		

			EndPaint(hWnd, &ps);
			break;
		case LMSG_DESTROY:
			DestroyKeyBoardData(hWnd);
			break;
		case LMSG_COMMAND:
			break;
		default:
			return DefWindowProc(hWnd, iMsg, wParam, lParam);
	}
	return true;
}


void 
SetSkbLayout(
	int iLayout
)
{
	PLGUIKeyBoard pKeyBoard;
	pKeyBoard = (PLGUIKeyBoard)(_lGUI_pSkbWindow->dwAddData);
	if(pKeyBoard->iCurLayout == iLayout)
		return;
	pKeyBoard->iCurLayout = iLayout;
	if((iLayout == SKB_LAYOUT_STANDARD_EXTEND) ||
	   (iLayout == SKB_LAYOUT_SHIFTED_EXTEND))
		pKeyBoard->bExtend = true;
	else
		pKeyBoard->bExtend = false;
		
	if((iLayout == SKB_LAYOUT_SHIFTED) ||
	   (iLayout == SKB_LAYOUT_SHIFTED_EXTEND))
	   	SetLGUIKBShift(true);
	else
		SetLGUIKBShift(false);
		

	InvalidateRect((HWND)_lGUI_pSkbWindow,NULL,true);
}


int  GetSkbLayout()
{
	return ((PLGUIKeyBoard)(_lGUI_pSkbWindow->dwAddData))->iCurLayout;
}


static BOOL 
GetClickedKeyValue(
	int x, 
	int y,
	int* iScanCode,
	int* iSubValue
)
{
	int iCounter, iTotal;
	PLGUIKeyBoard pKeyBoard;
	pKeyBoard = (PLGUIKeyBoard)(_lGUI_pSkbWindow->dwAddData);
	if(pKeyBoard->bExtend){
		iTotal = NR_KEYNUM;
		for(iCounter = 0; iCounter<iTotal;iCounter++){
			if(PtInRect(&(pKeyBoard->ExtendKeyDefTab[iCounter].rc),x,y)){
				*iScanCode = pKeyBoard->ExtendKeyDefTab[iCounter].iScanCode;
				*iSubValue = iCounter;
				return true;
			}
		}
	}
	else{
		iTotal = NR_KEYNUM - 10;
		for(iCounter = 0; iCounter<iTotal;iCounter++){
			if(PtInRect(&(pKeyBoard->KeyDefTab[iCounter].rc),x,y)){
				*iScanCode = pKeyBoard->ExtendKeyDefTab[iCounter].iScanCode;
				*iSubValue = iCounter;
				return true;
			}
		}
	}
	return false;
}


static void 
SkbProcessKeyDown(
	HWND hWnd,
	int x, 
	int y
)
{

	BOOL bValue;
	char ch;
	int iSubValue;
	int iScanCode;
	PWindowsTree pWin;
	PLGUIKeyBoard pKeyBoard;
	pWin = (PWindowsTree)hWnd;
	pKeyBoard = (PLGUIKeyBoard)(pWin->dwAddData);

	if(pKeyBoard->iCurLayout == SKB_LAYOUT_HANDWRITE)
		return;
	if(!GetClickedKeyValue(x,y,&iScanCode, &iSubValue))
		return;

	if(iSubValue == LEFT_SHIFT_SUB || iSubValue == RIGHT_SHIFT_SUB){
		bValue = IsLGUIKBShift();
		SetLGUIKBShift(!bValue);


		switch(pKeyBoard->iCurLayout){
		case SKB_LAYOUT_STANDARD:
			pKeyBoard->iCurLayout = SKB_LAYOUT_SHIFTED;
			break;
		case SKB_LAYOUT_SHIFTED:
			pKeyBoard->iCurLayout = SKB_LAYOUT_STANDARD;
			break;
		case SKB_LAYOUT_STANDARD_EXTEND:
			pKeyBoard->iCurLayout = SKB_LAYOUT_SHIFTED_EXTEND;
			break;
		case SKB_LAYOUT_SHIFTED_EXTEND:
			pKeyBoard->iCurLayout = SKB_LAYOUT_STANDARD_EXTEND;
			break;
		}

		SetLGUIKBCtrl(false);
		SetLGUIKBAlt(false);
		SetLGUIKBCapsLock(false);

		InvalidateRect(hWnd,NULL,true);
		return;
	}

	if(iSubValue == EXTEND_SUB){
		//layout
		switch(pKeyBoard->iCurLayout){
		case SKB_LAYOUT_STANDARD:
			pKeyBoard->iCurLayout = SKB_LAYOUT_STANDARD_EXTEND;
			break;
		case SKB_LAYOUT_SHIFTED:
			pKeyBoard->iCurLayout = SKB_LAYOUT_SHIFTED_EXTEND;
			break;
		case SKB_LAYOUT_STANDARD_EXTEND:
			pKeyBoard->iCurLayout = SKB_LAYOUT_STANDARD;
			break;
		case SKB_LAYOUT_SHIFTED_EXTEND:
			pKeyBoard->iCurLayout = SKB_LAYOUT_SHIFTED;
			break;
		}
		pKeyBoard->bExtend = !pKeyBoard->bExtend;
		//reset status key value
		
		SetLGUIKBCtrl(false);
		SetLGUIKBAlt(false);
		SetLGUIKBCapsLock(false);
		
		InvalidateRect(hWnd,NULL,true);		
		return;
	}
	//ctrl
	if(iSubValue == LEFT_CTRL_SUB || iSubValue == RIGHT_CTRL_SUB){
		bValue = IsLGUIKBCtrl();
		SetLGUIKBCtrl(!bValue);

		if(pKeyBoard->bExtend){
			InvalidateRect(hWnd,
				&(pKeyBoard->ExtendKeyDefTab[LEFT_CTRL_SUB ].rc),true);
			InvalidateRect(hWnd,
				&(pKeyBoard->ExtendKeyDefTab[RIGHT_CTRL_SUB ].rc),true);
		}
		else{
			InvalidateRect(hWnd,&(pKeyBoard->KeyDefTab[LEFT_CTRL_SUB].rc),true);
			InvalidateRect(hWnd,&(pKeyBoard->KeyDefTab[RIGHT_CTRL_SUB].rc),true);
		}
		return;
	}
	//ALT
	if(iSubValue == LEFT_ALT_SUB || iSubValue == RIGHT_ALT_SUB){
		bValue = IsLGUIKBAlt();
		SetLGUIKBAlt(!bValue);

		if(pKeyBoard->bExtend){
			InvalidateRect(hWnd,
				&(pKeyBoard->ExtendKeyDefTab[LEFT_ALT_SUB].rc),true);
			InvalidateRect(hWnd,
				&(pKeyBoard->ExtendKeyDefTab[RIGHT_ALT_SUB].rc),true);
		}
		else{
			InvalidateRect(hWnd,&(pKeyBoard->KeyDefTab[LEFT_ALT_SUB].rc),true);
			InvalidateRect(hWnd,&(pKeyBoard->KeyDefTab[RIGHT_ALT_SUB].rc),true);			
		}
		return;
	}
	//CAPSLOCK
	if(iSubValue == CAPSLOCK_SUB ){
		bValue = IsLGUIKBCapsLock();
		SetLGUIKBCapsLock(!bValue);
		
		if(pKeyBoard->bExtend)
			InvalidateRect(hWnd,&(pKeyBoard->ExtendKeyDefTab[iSubValue].rc),true);
		else
			InvalidateRect(hWnd,&(pKeyBoard->KeyDefTab[iSubValue].rc),true);
		return;
		
	}

		
	pKeyBoard->iPressed = iSubValue;

	if(pKeyBoard->bExtend)
		InvalidateRect(hWnd,&(pKeyBoard->ExtendKeyDefTab[iSubValue].rc),true);
	else
		InvalidateRect(hWnd,&(pKeyBoard->KeyDefTab[iSubValue].rc),true);

	//Call keyboard_pro procedure to send message
	SendKBMessage(iScanCode);

}


static void 
SkbProcessKeyUp(
	HWND hWnd, 
	int x, 
	int y
)
{
	int iValue;

	PLGUIKeyBoard pKeyBoard;

	pKeyBoard = (PLGUIKeyBoard)(_lGUI_pSkbWindow->dwAddData);

	if(pKeyBoard->iCurLayout == SKB_LAYOUT_HANDWRITE)
		return;

	iValue = pKeyBoard->iPressed;
	

	if(iValue!=-1){
		pKeyBoard->iPressed = -1;
		if(pKeyBoard->bExtend){
			InvalidateRect(hWnd,
				&(pKeyBoard->ExtendKeyDefTab[iValue].rc),true);
		}
		else{
			InvalidateRect(hWnd,
				&(pKeyBoard->KeyDefTab[iValue].rc),true);
		}
	}
}