jyinput.cpp

嵌入式终端中文输入法（for MiniGUI) 包括拼音、笔画、英文大小写、符号等

	case KEY_JING:
		_SwitchVariable();
		m_piinfo.keymode = _GetNextMode(m_piinfo.keymode);
		if ( m_piinfo.keymode & IME_MODE_T9PY
			|| m_piinfo.keymode & IME_MODE_T9BH
			|| m_piinfo.keymode & IME_MODE_HANDWRITE
			) 
		{
			m_bHZAssn = FALSE;
			_put_often_to_array();
		}
		break;

	default:
		return 0;
	}
	return 1;
}

static void _refresh_input_method_area(HWND hwnd, HDC hDC)
{
	RECT rc;
	GetClientRect (hwnd, &rc);

	if (m_piinfo.keymode & IME_MODE_HANDWRITE)
	{
		DisabledTextOutEx (hDC, hwnd, METHODAREA_XPOS, METHODAREA_YPOS, "【手】");
		//if (!GetHWSelect())
		//{
		//	//Show_HWInput_page(g_hImeWnd);
		//}	
		_Draw_Select_HZ(hDC);
	}
	else if (m_piinfo.keymode & IME_MODE_T9PY)
	{
		DisabledTextOutEx (hDC, hwnd, METHODAREA_XPOS, METHODAREA_YPOS, "【拼】");
		_XorPyList(hDC);
		_Draw_Select_HZ(hDC);	
	}
	else if (m_piinfo.keymode & IME_MODE_T9BH)
	{
		DisabledTextOutEx (hDC, hwnd, METHODAREA_XPOS, METHODAREA_YPOS, "【笔】");
		_XorBhList(hDC);	
		_Draw_Select_HZ(hDC);
	}
	else if (m_piinfo.keymode & IME_MODE_ALPHABET_UP)
	{
		DisabledTextOutEx (hDC, hwnd, METHODAREA_XPOS, METHODAREA_YPOS, "【EN】");
		_Draw_EN_AlphaList(hDC);
	}
	else if (m_piinfo.keymode & IME_MODE_ALPHABET_LOW)
	{
		DisabledTextOutEx (hDC, hwnd, METHODAREA_XPOS, METHODAREA_YPOS, "【en】");
		_Draw_EN_AlphaList(hDC);
	}
	else if (m_piinfo.keymode & IME_MODE_NUMBER)
	{
		DisabledTextOutEx (hDC, hwnd, METHODAREA_XPOS, METHODAREA_YPOS, "【数】");
	}
	else if (m_piinfo.keymode & IME_MODE_SYMBOL)
	{
		DisabledTextOutEx (hDC, hwnd, METHODAREA_XPOS, METHODAREA_YPOS, "【符】");
		_DrawSymbolKeyPad(hDC);
	}
}

int JYInputWinProc (HWND hWnd, int message, WPARAM wParam, LPARAM lParam)
{
	//...
	HDC hdc;
	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:
			//if (m_piinfo.outcode_cur)
			//	return 0;
			//else
			//	return 1;
			return m_IsOpened;
			break;
		case MSG_IME_SETTARGET:
			if (m_hosting != (HWND)wParam)
				m_hosting = (HWND)wParam;
			break;
		case MSG_IME_GETTARGET:
			return (int)m_hosting;

		case MSG_SETFOCUS:
		case MSG_KILLFOCUS:
		case MSG_CHAR:
			return 0;

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

				nScanKey = (int)wParam;
				if (nScanKey == m_nCallExitKey)
				{
					PostMessage(hWnd, 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 = nScanKey;
					break;
				}

				if (_proc_keydown(nCharKey))
					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 (IsHanziInput && oldx > 0 && oldx < 4*zwidth && oldy > 2 && oldy < zheight+2){ 
				//             imeSetStatus (IS_METHOD, -1);
				//             InvalidateRect (hWnd, NULL, TRUE);
				//             return 0;
				//         }

				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 | WS_VISIBLE;
	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()
{
	delete []g_pszPyImeArray;
	g_pszPyImeArray = NULL;
}

BOOL Init_PYIME_Arrary()
{	
	int nRet = 0;
	g_pszPyImeArray = new unsigned char[PY_ARRAY_SIZE];
	memset(g_pszPyImeArray, 0x00, PY_ARRAY_SIZE);
	nRet = _readfile_to_array(g_pszPyImeArray, PYIME_FILENAME, PY_ARRAY_SIZE);

	if (nRet < 0)
	{
		Free_PYIME_Array();

		return FALSE;
	}
	return TRUE;
}

#define BH_ARRAY_SIZE					(80 * 1024)

BOOL Init_BHIME_Arrary()
{	
	int nRet = 0;
	unsigned char szBhImeArray[BH_ARRAY_SIZE];
	memset(szBhImeArray, 0x00, BH_ARRAY_SIZE);
	nRet = _readfile_to_array(szBhImeArray, BHIME_FILENAME, BH_ARRAY_SIZE);

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

		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);

		pPos = szBhImeArray;
		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;
	}

	return FALSE;
}

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

#define HZASSN_ARRAY_COUNT				(1024 * 5)		/// 词的首字个数
#define HZASSN_FILE_SIZE				(80 * 1024)		/// 读取词库

BOOL Init_HzAssn_Arrary()
{	
	int nRet = 0;
	unsigned char szHzAssnArray[HZASSN_FILE_SIZE];
	memset(szHzAssnArray, 0x00, HZASSN_FILE_SIZE);
	nRet = _readfile_to_array(szHzAssnArray, HZASSN_FILENAME, HZASSN_FILE_SIZE);

	if (nRet > 0)
	{
		int nIndex = 0;
		int nOffset = 0;
		int nMaxCounts = 0;

		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 == nRet || (nIndex - 1) == HZASSN_ARRAY_COUNT)
				break;

			//g_pstAssnArray[nIndex].nOffset = nOffset;
			memcpy(g_pstAssnArray[nIndex].szWord, szHzAssnArray+nOffset, 2);
			memcpy(&g_pstAssnArray[nIndex].nCounts, szHzAssnArray+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, szHzAssnArray+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;
	}
	return FALSE;
}

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

	delete g_pstAssnArray;
	g_pstAssnArray = NULL;
}

BOOL InitJYInput()
{
	Init_PYIME_Arrary();
	Init_BHIME_Arrary();
	Init_HzAssn_Arrary();
	g_hImeWnd = JYInputWindowEx(NULL, 0, IME_LEFT, SCREEN_WIDTH - 10, IME_RIGHT, FALSE);

	return TRUE;
}