jyinput.c

基于minigui的软键盘设计的相关资料

	static BOOL fCaptured = FALSE;
	static int oldx, oldy;
	int x, y;
	int maxx, maxy;
	RECT rcWindow;
	RECT *prcExpect, *prcResult;
	int nScanKey=0,nCharKey=0;

	switch (message) {
		case MSG_NCCREATE:
			break;

		case MSG_IME_REGISTER:

			m_hImeEdit = lParam;
			m_nCallExitKey = wParam;
			if (m_nCallExitKey <= 0)
			{
				m_nCallExitKey = SCANCODE_KEY_F4;
			}
			break;
		case MSG_IME_INPUTMODE:
			_SetInputMode((int)wParam, (int)lParam);
			break;
		case MSG_IME_OPEN:
			if (!m_IsOpened) 
			{
				ShowWindow(hWnd, SW_SHOW);

				_ResetVariable();
				_put_often_to_array();
	//			SetActiveWindow(m_hosting);
			}
			break;
		case MSG_IME_CLOSE:
			if (m_IsOpened) 
			{
				ShowWindow(hWnd, SW_HIDE);
				m_IsOpened = 0;
			}
			break;
		case MSG_IME_GETSTATUS:
			return m_IsOpened;
			break;

		case MSG_IME_SETTARGET:
			if (m_hosting != (HWND)wParam)
				m_hosting = (HWND)wParam;

			if (m_hImeEdit != (HWND)lParam)
				m_hImeEdit = (HWND)lParam;

			break;

		case MSG_IME_GETTARGET:
			if ((int)wParam == 1)
			{
				return (int)m_hosting;
			}

			if ((int)lParam == 1)
			{
				return (int)m_hImeEdit;
			}

			break;

		case MSG_SETFOCUS:
		case MSG_KILLFOCUS:
			return 0;

		case MSG_CHAR:
			return 0;

		case MSG_KEYDOWN:
			{
				if (m_hImeEdit != NULL)
					ShowCaret(m_hImeEdit);

				nScanKey = (int)wParam;
				if (nScanKey == m_nCallExitKey)
				{
					PostMessage(g_hImeWnd, MSG_IME_CLOSE, 0, 0);
					return 0;
				}

				switch(nScanKey)
				{
				case SCANCODE_1:
				case SCANCODE_2:
				case SCANCODE_3:
				case SCANCODE_4:
				case SCANCODE_5:
				case SCANCODE_6:
				case SCANCODE_7:
				case SCANCODE_8:
				case SCANCODE_9:
					m_bHZAssn = FALSE;
					nCharKey = nScanKey + KEY_0 - 1;
					break;
				case SCANCODE_0:
					nCharKey = KEY_0;
					break;
				case SCANCODE_KEY_XING: 
					nCharKey = KEY_XING;
					break;
				case SCANCODE_KEY_JING:
					nCharKey = KEY_JING;
					break;
				case SCANCODE_KEY_LFUNC:
				case SCANCODE_KEY_ENTER:
					nCharKey = KEY_LFUNC;
					break;
				case SCANCODE_KEY_RFUNC:
					nCharKey = KEY_RFUNC;
					break;
				case SCANCODE_KEY_LEFT:
					nCharKey =	KEY_LEFT;
					break;
				case SCANCODE_KEY_RIGHT:
					nCharKey =	KEY_RIGHT;
					break;
				case SCANCODE_KEY_UP:
					nCharKey =	KEY_UP;
					break;
				case SCANCODE_KEY_DOWN:
					nCharKey =	KEY_DOWN;
				//case SCANCODE_BACKSPACE:
					//return PostMessage(m_hosting, MSG_KEYDOWN, SCANCODE_BACKSPACE, 0);
					break;
				default:
					nCharKey = 0;//nScanKey;
					break;
				}

				if (_proc_keydown(nCharKey))
				{
					InvalidateRect(hWnd, NULL, TRUE);
					//SendMessage(g_hImeWnd, MSG_PAINT, 0, 0);
					return 1;
				}
			}
			break;
 
		case MSG_PAINT:
			hdc = BeginPaint (hWnd);
			SetBkColor(hdc, GetWindowElementColor (BKC_CONTROL_DEF));
			_refresh_input_method_area (hWnd, hdc);
			EndPaint (hWnd, hdc);
			return 0;

		case MSG_LBUTTONDOWN:
			{
				RECT rc;
				int zwidth = GetSysCCharWidth();
				int zheight = GetSysCharHeight();

				GetClientRect (hWnd, &rc);

				oldx = LOWORD (lParam);
				oldy = HIWORD (lParam);

				if (oldx > rc.right - 4 - 32 && oldx < rc.right - 4 - 16 && oldy > 2 && oldy < 16+2){
					InvalidateRect (hWnd, NULL, TRUE);
					return 0;
				}
				if (oldx > rc.right - 4 - 16 && oldx < rc.right - 4 && oldy > 2 && oldy < 16+2){
					InvalidateRect (hWnd, NULL, TRUE);
					return 0;
				}

				SetCapture (hWnd);
				ClientToScreen (hWnd, &oldx, &oldy);
				fCaptured = TRUE;
			}
			break;

		case MSG_LBUTTONUP:
			ReleaseCapture ();
			fCaptured = FALSE;
			break;

		case MSG_MOUSEMOVE:
			if (fCaptured) {
				GetWindowRect (hWnd, &rcWindow);
				x = LOSWORD (lParam);
				y = HISWORD (lParam);
				OffsetRect (&rcWindow, x - oldx, y - oldy);
#ifndef _LITE_VERSION
				MoveWindow (hWnd, rcWindow.left, rcWindow.top,
					RECTW (rcWindow), RECTH (rcWindow), FALSE);
#endif
				oldx = x;
				oldy = y;
			}
			break;

		case MSG_SIZECHANGING:
			prcExpect = (PRECT)wParam;
			prcResult = (PRECT)lParam;

			*prcResult = *prcExpect;
			if (prcExpect->left < 0) {
				prcResult->left = 0;
				prcResult->right = RECTWP (prcExpect);
			}
			if (prcExpect->top < 0) {
				prcResult->top  = 0;
				prcResult->bottom = RECTHP (prcExpect);
			}

			maxx = GetGDCapability (HDC_SCREEN, GDCAP_HPIXEL);
			maxy = GetGDCapability (HDC_SCREEN, GDCAP_VPIXEL);

			if (prcExpect->right > maxx) {
				prcResult->right = maxx;
				prcResult->left = maxx - RECTWP (prcExpect);
			}
			if (prcExpect->bottom > maxy) {
				prcResult->bottom = maxy;
				prcResult->top = maxy - RECTHP (prcExpect);
			}

			return 0;

		case MSG_CLOSE:
			SendMessage (HWND_DESKTOP, MSG_IME_UNREGISTER, (WPARAM)hWnd, 0);
			DestroyMainWindow (hWnd);
#ifndef _LITE_VERSION
			PostQuitMessage (hWnd);
#endif
			return 0;
	}
	return DefaultMainWinProc(hWnd, message, wParam, lParam);
}

//////////////////////////////////////////////////////////////////////////
//#ifdef _LITE_VERSION
static void _initIMEWinCreateInfo (PMAINWINCREATE pCreateInfo)
{
	pCreateInfo->dwStyle = WS_ABSSCRPOS | WS_BORDER;
	pCreateInfo->dwExStyle = WS_EX_TOPMOST;
	pCreateInfo->spCaption = "The JYInput Window" ;
	pCreateInfo->hMenu = 0;
	pCreateInfo->hCursor = GetSystemCursor(0);
	pCreateInfo->hIcon = 0;
	pCreateInfo->MainWindowProc = JYInputWinProc;
	pCreateInfo->lx = GetGDCapability (HDC_SCREEN, GDCAP_MAXX) - 400; 
	pCreateInfo->ty = GetGDCapability (HDC_SCREEN, GDCAP_MAXY) - 80; 
	pCreateInfo->rx = GetGDCapability (HDC_SCREEN, GDCAP_MAXX);
	pCreateInfo->by = GetGDCapability (HDC_SCREEN, GDCAP_MAXY) - 40;
	pCreateInfo->iBkColor = GetWindowElementColor (BKC_CONTROL_DEF); 
	pCreateInfo->dwAddData = 0;
	pCreateInfo->hHosting = 0;
}

//////////////////////////////////////////////////////////////////////////

HWND Set_JYInputHwnd(HWND hosting, int lx, int ty, int rx, int by, BOOL two_lines)
{
	MAINWINCREATE CreateInfo;
	if (m_hosting == NULL)
	{
		HWND hMainWnd;

		_initIMEWinCreateInfo (&CreateInfo);
		CreateInfo.hHosting = hosting;
		if (lx != 0 || ty != 0 || rx != 0 || by != 0) {
			CreateInfo.lx = lx;
			CreateInfo.ty = ty;
			CreateInfo.rx = rx;
			CreateInfo.by = by;
			bTwoLines = two_lines;
		}
		else
			bTwoLines = TRUE;

		hMainWnd = CreateMainWindow(&CreateInfo);
		if (hMainWnd == HWND_INVALID)
			return HWND_INVALID;

		g_hImeWnd = hMainWnd;

#ifdef IME_T9BH_ENABLE
		_init_bh_array();
#endif

#ifdef IME_HANDWRITE_ENABLE
		//_initHWLib();
#endif

	}
	else
		MoveWindow(g_hImeWnd, lx, ty, rx, by, TRUE);

	m_hosting = hosting;

	memset((void*)&m_stEN_info, 0, sizeof(ST_EN_INFO));
	memset((void*)&m_piinfo, 0, sizeof(ST_INPUT_INFO));
	m_nSelectPos = 0;
	m_piinfo.keymode = IME_MODE_T9PY;

//	ShowWindow (g_hImeWnd, SW_SHOWNORMAL); 
//	ShowWindow(g_hImeWnd, SW_HIDE);
	m_IsOpened = 0;

	return g_hImeWnd;
}

HWND JYInputWindowEx (HWND hosting, int lx, int ty, int rx, int by, BOOL two_lines)
{
	//_writefile("data/py.ime");
	return Set_JYInputHwnd(hosting, lx, ty, rx, by, two_lines);
}
//#endif

//////////////////////////////////////////////////////////////////////////

static int _readfile_to_array(unsigned char *pBuffer, const char *szFilename, int nSize)
{
	int nLength = 0;
	int fh = FILE_OPEN(szFilename, FILE_READ_FLAG, FILE_READ_MODE);
	if (fh == FILE_OPEN_FAIL)
		return -1;

	nLength = FILE_LSEEK(fh, 0, SEEK_END);
	if (nLength > nSize)
		nLength = nSize;

	FILE_LSEEK(fh, 0, SEEK_SET);
	FILE_READ(fh, pBuffer, nLength);
	FILE_CLOSE(fh);

	return nLength;
}

//////////////////////////////////////////////////////////////////////////
#define PY_ARRAY_SIZE				(16 * 1024)

void Free_PYIME_Array()
{
	free(g_pszPyImeArray);
	//delete []g_pszPyImeArray;
	g_pszPyImeArray = NULL;
}

BOOL Init_BHIME_Arrary(unsigned char *pBhImeArray, unsigned int nFileLength)
{
	int n;
	unsigned char *pPos = pBhImeArray;
	int nValidHZ = 0;	//因为库中有GBK码，在初始化的时候必须剔除掉GBK

	if (pBhImeArray == NULL || nFileLength < 1)
		return FALSE;

	g_pstBhTable = (ST_BHBM *)malloc(sizeof(ST_BHBM) * BHBM_COUNT);
	if (g_pstBhTable == NULL)
		return FALSE;

	memset(g_pstBhTable, 0x00, sizeof(ST_BHBM) * BHBM_COUNT);

	for (n = 0; n < BHBM_COUNT; n++)
	{
		int j = 0;
		unsigned char szOne[20] = "";
		while (1)
		{
			if (*pPos != 0x0a)
			{
				szOne[j++] = (unsigned char)*pPos;
			}
			else
			{
				int nlen = strlen((char*)szOne);
				memcpy((char *)g_pstBhTable[nValidHZ].szHz, (char*)&szOne[nlen - 2], 2);
				memcpy((char *)g_pstBhTable[nValidHZ].szBm, (char*)&szOne[0], nlen - 2);

				nValidHZ++;
				pPos++;
				break;
			}
			pPos++;
		}
	}
	return TRUE;
}

void Free_BHIME_Array()
{
	free(g_pstBhTable);	//delete g_pstBhTable;
	g_pstBhTable = NULL;
}

#define HZASSN_ARRAY_COUNT				(1024 * 5)		/// 词的首字个数
BOOL Init_HzAssn_Arrary(unsigned char *pAssnImeArray, unsigned int nFileLength)
{
	int nIndex = 0;
	int nOffset = 0;
	int nMaxCounts = 0;

	if (pAssnImeArray == NULL)
		return FALSE;

	g_pstAssnArray = (ST_HZASSN *)malloc(sizeof(ST_HZASSN) * HZASSN_ARRAY_COUNT);
	if (g_pstAssnArray == NULL)
		return FALSE;

	memset(g_pstAssnArray, 0x00, sizeof(ST_HZASSN) * HZASSN_ARRAY_COUNT);
	while (1)
	{
		if (nOffset == nFileLength || (nIndex - 1) == HZASSN_ARRAY_COUNT)
			break;

		//g_pstAssnArray[nIndex].nOffset = nOffset;
		memcpy(g_pstAssnArray[nIndex].szWord, pAssnImeArray+nOffset, 2);
		memcpy(&g_pstAssnArray[nIndex].nCounts, pAssnImeArray+nOffset+2, 2);

		g_pstAssnArray[nIndex].snWords = 
			(unsigned short *)malloc(sizeof(unsigned short) * g_pstAssnArray[nIndex].nCounts + 1);
		memset(g_pstAssnArray[nIndex].snWords, 0x00, sizeof(unsigned short) * g_pstAssnArray[nIndex].nCounts + 1);
		memcpy(g_pstAssnArray[nIndex].snWords, pAssnImeArray+nOffset+2+2, 
			g_pstAssnArray[nIndex].nCounts * 2);

		if (nMaxCounts < g_pstAssnArray[nIndex].nCounts)
			nMaxCounts = g_pstAssnArray[nIndex].nCounts;	

		nOffset += (2 + 2 + g_pstAssnArray[nIndex].nCounts*2);
		nIndex++;
	}
	g_nHzAssnWordCount = nIndex;

	return TRUE;
}

void Free_HzAssn_Array()
{
	int n = 0;
	for (n=0; n<g_nHzAssnWordCount; n++)
	{
		char *p = (char *)g_pstAssnArray[n].snWords;
		if (p)
		{
			free(p);
			p = NULL;
		}
	}

	free(g_pstAssnArray);
	g_pstAssnArray = NULL;
}
 
#define HZIME_ADDR		(19*64*1024) 
BOOL InitJYInput()
{
	char *pPyIme = NULL;
	char *pBhIme = NULL;
	char *pAssnIme = NULL;
	unsigned int nPyImeSize = 0;
	unsigned int nBhImeSize = 0;
	unsigned int nAssnImeSize = 0;

#ifdef WIN32
	int fp;
	int size = 0;
	fp=_open(HZIME_FILENAME, _O_RDONLY|_O_BINARY);
	if (fp!=FILE_OPEN_FAIL) 
	{
		_read(fp, &size, sizeof(int));
		pPyIme = (char *)malloc(size + 1);
		memset(pPyIme, 0x00, size+1);
		_read(fp,(void*)pPyIme, size);				//读表文件
		nPyImeSize = size;

		_read(fp, &size, sizeof(int));
		pBhIme = (char *)malloc(size + 1);
		memset(pBhIme, 0x00, size+1);
		_read(fp,(void*)pBhIme, size);				//读表文件
		nBhImeSize = size;

		_read(fp, &size, sizeof(int));
		pAssnIme = (char *)malloc(size + 1);
		memset(pAssnIme, 0x00, size+1);
		_read(fp,(void*)pAssnIme, size);				//读表文件
		nAssnImeSize = size;

		_close(fp);
	}
#else
	unsigned int addr = HZIME_ADDR;
	int *pnSize = (int *)addr;
	addr += sizeof(int);
	pPyIme = (char* )addr;
	addr += *pnSize;
	nPyImeSize = *pnSize;

	pnSize = (int *)addr;
	addr += sizeof(int);
	pBhIme = (char* )addr;
	addr += *pnSize;
	nBhImeSize = *pnSize;

	pnSize = (int *)addr;
	addr += sizeof(int);
	pAssnIme = (char* )addr;
	nAssnImeSize = *pnSize;

#endif
	if (nPyImeSize > 0 && nBhImeSize > 0 && nAssnImeSize > 0)
	{
		g_pszPyImeArray = pPyIme;
		//Init_PYIME_Arrary(pPyIme);
		Init_BHIME_Arrary(pBhIme, nBhImeSize);
		Init_HzAssn_Arrary(pAssnIme, nAssnImeSize);
	}

#ifdef WIN32
	free(pBhIme);	pBhIme = NULL;
	free(pAssnIme);	pAssnIme = NULL;
#endif


	return TRUE;
}
 
//////////////////////////////////////////////////////////////////////////
BOOL CloseImeHwnd()
{
	if (m_IsOpened)
	{
		m_hosting = 0;
		m_hImeEdit = 0;
		return SendMessage(g_hImeWnd, MSG_IME_CLOSE, 0, 0);
	}

	return TRUE;
}
 
BOOL OpenImeHwnd(HWND hDlgWnd, HWND hEdit)
{
	if (m_IsOpened)
		return FALSE;

	SendMessage(g_hImeWnd, MSG_IME_SETTARGET, hDlgWnd, hEdit);
	SendMessage(g_hImeWnd, MSG_IME_OPEN, 0, 0);
	//SendMessage(g_hImeWnd, MSG_PAINT, 0, 0);
	
	SetActiveWindow(hDlgWnd);
	if (hEdit)
	{
		SetFocusChild(hEdit);
	}

	return TRUE;
}
 
BOOL GetImeHwndStatus()
{
	return SendMessage(g_hImeWnd, MSG_IME_GETSTATUS, 0, 0);
}
 
BOOL RemoveImeHwnd(int x, int y, int w, int h, BOOL fPaint)
{
	MoveWindow(g_hImeWnd, x, y, w, h, TRUE);	
	SendMessage(g_hImeWnd, MSG_PAINT, 0, 0);
	return TRUE;
}
 
BOOL ResetImeHwnd()
{
	RemoveImeHwnd(0, IME_LEFT, SCREEN_WIDTH-2, IME_RIGHT - IME_LEFT, TRUE);
	SetInputModeImeHwnd((IME_MODE_T9PY | IME_MODE_T9BH /*| IME_MODE_HANDWRITE*/| IME_MODE_ALPHABET_UP | IME_MODE_ALPHABET_LOW | IME_MODE_NUMBER | IME_MODE_SYMBOL)
		, IME_MODE_T9PY);

	return TRUE;
}
 
BOOL SetInputModeImeHwnd(int paramInput, int paramDefault)
{
	SendMessage(g_hImeWnd, MSG_IME_INPUTMODE, paramInput, paramDefault);
	return TRUE;
}