hikerwbui.cpp

自己用Markov模型做的一个整句物笔输入法的原型

#include "stdafx.h"
#include "Afxtempl.h"
#include "HikerWBUI.h"
#include "HikerWBStateWnd.h"
#include "softkeyboard.h"
#include "MakeWordDlg.h"
#include "HikerWBStartDlg.h"
#include "StateWnd.h"

static unsigned char gVKArr[47] = 
		{192, 49, 50, 51, 52, 53, 54, 55, 56, 57, 48, 189, 187, \
		 81, 87, 69, 82, 84, 89, 85, 73, 79, 80, 219, 221, 220, \
		 65, 83, 68, 70, 71, 72, 74, 75, 76, 186, 222, \
		 90, 88, 67, 86, 66, 78, 77, 188, 190, 191};

static unsigned char gKeyArr[SOFTKEYBOARD_NUM*2][SOFTKEYBOARD_LEN] = {
		/*PC keyboard*/
		{
			SOFTKEY_PCC
		},
		{
			SOFTKEY_PCL
		},
		/*Greece letter*/																																								
		{
			SOFTKEY_GLC
		},
		{
			SOFTKEY_GLL
		},
		/*Russia letter*/																																							
		{
			SOFTKEY_RLC
		},
		{
			SOFTKEY_RLL
		},
		/*chinese spell letter*/																																									
		{
			SOFTKEY_NON
		},	
		{
			SOFTKEY_CSL
		},
		/*phonetic notation*/																																										
		{
			SOFTKEY_NON
		},	
		{
			SOFTKEY_CPN
		},
		/*Japanese hiragana */																																								
		{
			SOFTKEY_JHC
		},		
		{
			SOFTKEY_JHL
		},
		/*Japanese katakana*/																																			
		{
			SOFTKEY_JKC
		},
		{
			SOFTKEY_JKL
		},
		/*punctuation*/																																						
		{
			SOFTKEY_NON
		},
		{
			SOFTKEY_PCT
		},
		/*serial number*/																					
		{
			SOFTKEY_SNC
		},
		{
			SOFTKEY_SNL
		},
		/*mathematics notation*/
		{
			SOFTKEY_NON
		},
		{
			SOFTKEY_MAT
		},
		/*special notation*/																																								
		{
			SOFTKEY_NON
		},
		{
			SOFTKEY_SPC
		},
		/*全角字符*/
		{
			SOFTKEY_SBC
		},
		{
			SOFTKEY_SBL
		},
};

static unsigned char gPunctuation[] = "~!@#$%^&*()_+{}|:\"<>?`-=[]\\;',./";
static unsigned char gChinsesPunc[] = "～！·＃￥％…ˉ＊（）—＋｛｝｜：“《》？｀－＝［］、；‘，。／";


static giLastKey = -1;


static HHOOK hHook;
static HINSTANCE hInstDLL;
static HOOKPROC pHookProc;

//05.11.10
typedef BOOL (*LPFSHOWSOFTKEYBOARDPROC)(BOOL, int = 0);
static LPFSHOWSOFTKEYBOARDPROC pShowSoftKeyboardProc;

typedef BOOL (*LPFINITHOOKPROC)();
static LPFINITHOOKPROC pInitHookProc;

typedef BOOL (*LPFENDHOOKPROC)();
static LPFENDHOOKPROC pEndHookProc;

typedef BOOL (*LPFHOOKONPROC)();
static LPFHOOKONPROC pHookOnProc;

typedef BOOL (*LPFHOOKOFFPROC)();
static LPFHOOKOFFPROC pHookOffProc;

typedef BOOL (*LPFTRANSLATEPROC)(unsigned char*, unsigned char*, int&, int&, int*, int*);
static LPFTRANSLATEPROC pTranslateProc;

typedef BOOL (*LPFGETWORDSPROC)(unsigned char*, unsigned char*, int, unsigned char*, int&);
static LPFGETWORDSPROC pGetWordsProc;

typedef BOOL (*LPFGETWORDSELPROC)(unsigned char* pwords, int wdno, unsigned char* pword);
static LPFGETWORDSELPROC pGetWordSelProc;

typedef BOOL (*LPFGETCODESPROC)(unsigned char*, unsigned char*, int&);
static LPFGETCODESPROC pGetCodesProc;

typedef BOOL (*LPFTRAINPROC)(unsigned char*, unsigned char*, int*);
static LPFTRAINPROC pTrainProc;

typedef void (*LPFSETSTYLEPROC)(int);
static LPFSETSTYLEPROC pSetStyleProc;

typedef BOOL (*LPFPYGETWORDSPROC)(unsigned char*, unsigned char*, int&);
static LPFPYGETWORDSPROC pPYGetWordsProc;

typedef BOOL (*LPFFINDCODEBYWORDPROC)(unsigned char*, unsigned char*);
static LPFFINDCODEBYWORDPROC pFindCodeByWordProc;

typedef BOOL (*LPFSETCHARSETPROC)(int);
static LPFSETCHARSETPROC pSetCharSetProc;

typedef BOOL (*LPFGENECODEPROC)(unsigned char*, unsigned char*);
static LPFGENECODEPROC pGeneCodeProc;

typedef BOOL (*LPFNEWWORDPROC)(unsigned char*, unsigned char*);
static LPFNEWWORDPROC pNewWordProc;

typedef BOOL (*LPFDELETEWORDPROC)(unsigned char*, unsigned char*);
static LPFDELETEWORDPROC pDeleteWordProc;

typedef BOOL (*LPFTRAINFROMFILEPROC)(const char*);
static LPFTRAINFROMFILEPROC pTrainFromFileProc;

typedef BOOL (*LPFSETKEYPROCSIGNPROC)(BOOL);
static LPFSETKEYPROCSIGNPROC pSetKeyProcSignProc;

typedef HANDLE (*LPFGETTHREADHANDLEPROC)();
static LPFGETTHREADHANDLEPROC pGetThreadHandleProc;

static unsigned char codestr[SENTLEN];
static unsigned char wordstr[SENTLEN];
static unsigned char lastwordstr[SENTLEN];		//record wordstr for recovering it if error
static unsigned char corrwordstr[SENTLEN];		//correct word stream
static unsigned char code[CODELEN];
static unsigned char wordlist[(DUPWORD+1)*WORDLEN];		//select word list
static unsigned char codelist[(DUPCODE+1)*CODELEN];		//back search code list 


static int			 codeslen[SENTLEN];			//record each code's length, not used now and refreshed by translate api.
static int			 wordslen[SENTLEN];			//record each word's length in wordstr
static int			 corrwordslen[SENTLEN];		//record each correct-word's length

static int codenum;
static int wordnum;
static int corrwordnum;
static int selwordnum;		//word number in wordlist
static int selcodenum;		//code number in codelist
static int currpos;			//the cursor position
static int lastpos;
static int giPageNo;

static BOOL gbChsSta = TRUE;		//Chinses state
static BOOL gbSBCSta = FALSE;		//SBC case state
static BOOL gbChsPctSta = TRUE;		//Chinses puctuation state
static int  giMaxCodeLen = 4;
static BOOL gbTmpPy = FALSE;		//temporary pinyin state
static BOOL gbFirstQuota = TRUE;	//the last quotation is "”"
static BOOL gbOpenSta = TRUE;		//

//system set parameters
static int  giCharset = 0;			//GB2312
static int giSwitchChs = 0;			//
static BOOL gbFloatWnd = TRUE;	//float state window
static BOOL gbShowStateWnd = TRUE;	//float state window


static HANDLE hFile;
static HANDLE *pMem;

static CHikerWBStateWnd editWnd;
static CMakeWordDlg newWordWnd;
static CStateWnd staWnd;

static HWND		ghFocusWnd;

static int giOSVER;

//if a character is a punctation keyed in using shift key
static BOOL IsShPct(char c)
{
	if (   c == ',' || c == '.' || c == '/'
		|| c == ';' || c == '\'' 
		|| c == '[' || c == ']' || c == '\\' 
		|| c == '-' || c == '=' || c == '`')
		return FALSE;
	else
		return TRUE;
}

static void Clean()
{
	memset(codestr, 0, sizeof(codestr));
	memset(wordstr, 0, sizeof(wordstr));
	memset(corrwordstr, 0, sizeof(corrwordstr));
	memset(code, 0, sizeof(code));
	memset(codeslen, 0, sizeof(int)*SENTLEN);
	memset(wordslen, 0, sizeof(int)*SENTLEN);
	memset(corrwordslen, 0, sizeof(int)*SENTLEN);
	codenum = 0;
	wordnum = 0;
	corrwordnum = 0;
	selwordnum = 0;
	currpos = -1;
	lastpos = -1;
	giPageNo = 0;

	editWnd.Clean();
	if (gbFloatWnd)
		editWnd.ShowWindow(SW_HIDE);

    (*(pMem+1)) = 0;		//////////////
}

static void PostSent()
{
    if (ghFocusWnd)
	{
		for (int i = 0; i < strlen((char*)wordstr);)
		{
			if (wordstr[i] >= 0x81)	//chinses character
			{
				SendMessage(ghFocusWnd, WM_IME_CHAR, (wordstr[i]<<8)+wordstr[i+1], 0);
				i += 2;
			}
			else
			{
				SendMessage(ghFocusWnd, WM_IME_CHAR, wordstr[i], 0);
				i++;
			}
		}
	}
}

static void PostChar(CString c, LPARAM lParam)
{
//	hWorkWnd = GetForegroundWindow();
//	hThred = GetWindowThreadProcessId(hWorkWnd, 0);
//    if (!AttachThreadInput(GetCurrentThreadId(), hThred, TRUE))
//		return;
//
//    hFocusWnd = GetFocus();
//	if (!hFocusWnd)
//		return;
    //AttachThreadInput(GetCurrentThreadId(), (DWORD)hFocusWnd, FALSE);

    if (ghFocusWnd)
	{
//		MSG msg;
//		msg.hwnd = ghFocusWnd;
//		msg.lParam = lParam;
//		msg.wParam = wParam;
//		msg.message = WM_KEYDOWN;
//		TranslateMessage(&msg);

		if (c.GetLength() > 1)
			SendMessage(ghFocusWnd, WM_IME_CHAR, (((unsigned char)c[0])<<8)+(unsigned char)c[1], lParam);
		else
			SendMessage(ghFocusWnd, WM_IME_CHAR, c[0], lParam);
	}
}

static void PostKey(WPARAM wParam, LPARAM lParam)
{
    if (ghFocusWnd)
	{
		SendMessage(ghFocusWnd, WM_IME_KEYDOWN, wParam, lParam);
	}
}

static unsigned char* LocateCode(int pos)
{
	unsigned char* pcs = codestr;
	unsigned char lc = *pcs++;
	int lenc = (32 != *pcs && 0 != *pcs) ? 1 : 0;
	BOOL bSpcCode = ((lc == 'z')?TRUE:FALSE);

	for (int n = 0; n < pos; pcs++)
	{
		if (32 != *pcs && lc == 32 || (giMaxCodeLen == lenc && !bSpcCode) || (4 == lenc && bSpcCode) || 0 == *pcs)
		{
			lenc = 1;
			n++;
			bSpcCode = ((*pcs == 'z')?TRUE:FALSE);
		}
		else if (32 != *pcs && 0 != *pcs)
		{
			 lenc++;
		}

		lc = *pcs;
	}
	pcs--;

	return pcs;
}

static void InsertCode(unsigned char* pcode, int pos)
{
	unsigned char* pcs = LocateCode(pos);

	int codelen = strlen((char*)pcode);
	int cslen = strlen((char*)codestr);
//	if (32 == pcode[codelen-1])
//		pcode[codelen-1] = 0;
	//strcpy((char*)(pcs + codelen+1), (char*)pcs);
	//strcpy((char*)pcs, (char*)code);		//strcpy will add '\0'
	for (int i = cslen+codelen-1; i >= pcs+codelen-codestr; i--)
		codestr[i] = codestr[i-codelen];
	for (i = 0; i <codelen; i++)
		*(pcs++) = pcode[i];

	codenum++;
}

static void GetCode(int pos, unsigned char* pcode)
{
	memset(pcode, 0, CODELEN);
	if (pos < 0)
		return;
	
	unsigned char* pcs = LocateCode(pos);
	int cdlen = ((*pcs == 'z')?4:giMaxCodeLen);
	for (int n = 0; 32 != *pcs && 0 != *pcs && n < cdlen; pcs++, n++)
	{
		pcode[n] = *pcs;
	}
	pcode[n] = 0;

	if (strlen((char*)pcode) < giMaxCodeLen)
		pcode[strlen((char*)pcode)] = 32;
}

static void DeleteCode(int pos)
{
	if (pos > codenum-1)
		return;

	//find last space character
	unsigned char* pcs0 = LocateCode(pos);
	unsigned char* pcs = pcs0;
	int cslen = strlen((char*)codestr);

	int cdlen = ((*pcs == 'z')?4:giMaxCodeLen);
	for (int i = 0; i < cdlen-1 && 32 != *pcs; i++)
	{
		*pcs++ = 0;
	}
	*pcs = 0;

	int codelen = pcs-pcs0+1;
	for (pcs = pcs0; pcs < codestr+cslen; pcs++)
	{
		*pcs = *(pcs+codelen);
	}

	codenum --;
}

static unsigned char* LocateCorrWord(int pos)
{
	int len = 0;
	for (int n = 0; n < pos; n++)
		len += corrwordslen[n];
	
	return corrwordstr+len;
}

static void InsertCorrWord(unsigned char* pword, int pos)
{
	unsigned char* pws = LocateCorrWord(pos);

	int wordlen = strlen((char*)pword);
	int cwslen = strlen((char*)corrwordstr);
	int i;

	if (wordlen > 0)
	{
		for (i = cwslen+wordlen-1; i >= pws+wordlen-corrwordstr; i--)
			corrwordstr[i] = corrwordstr[i-wordlen];
		for (i = 0; i <wordlen; i++)
			*(pws++) = pword[i];

		corrwordnum++;
	}

	for (i = wordnum+1; i > pos;  i--)
		corrwordslen[i] = corrwordslen[i-1];
	
	corrwordslen[pos] = wordlen;
}

static void DeleteCorrWord(int pos)
{
	unsigned char* pws = LocateCorrWord(pos);
	int wordlen = corrwordslen[pos];
	int cwslen = strlen((char*)corrwordstr);
	int i;

	if (corrwordslen[pos] > 0)
	{
		if (pws + wordlen <  corrwordstr + cwslen)		//not last word
		{
			int iMax = max(cwslen-(pws+wordlen-corrwordstr), wordlen);
			for (int i = 0; i <= iMax; i++)
			{
				*(pws) = *(pws+wordlen);
				*(pws+wordlen) = 0;
				pws++;
			}
		}
		else
		{
			for (i = pws - corrwordstr; i <= cwslen - 1; i++)
			{
				corrwordstr[i] = 0;
			}
		}

		corrwordnum --;
	}

	for (i = pos; i < wordnum+1; i++)		//!note, here the loop uplimit is wordnum, or wordnum+1(if the DeleteWord before DeleteCorrWord), but not corrwordnum.
	{
		corrwordslen[i] = corrwordslen[i+1];
	}
}

static unsigned char* LocateWord(int pos)
{
	int len = 0;
	for (int n = 0; n < pos; n++)
		len += wordslen[n];
	
	return wordstr+len;
}

static void InsertWord(unsigned char* pword, int pos, BOOL bDelCorrWord)
{
	unsigned char* pws = LocateWord(pos);

	int wordlen = strlen((char*)pword);
	int wslen = strlen((char*)wordstr);

	for (int i = wslen + wordlen-1; i >= pws + wordlen - wordstr; i--)
		wordstr[i] = wordstr[i-wordlen];
	for (i = 0; i <wordlen; i++)
		*(pws++) = pword[i];

	wordnum++;

	for (i = wordnum; i > pos; i--)
	{
		wordslen[i] = wordslen[i-1];
	}
	
	wordslen[pos] = wordlen;

	//auto insert empty correct word at this position
	if (bDelCorrWord)
	{
		for (i = wordnum; i > pos; i--)
		{
			corrwordslen[i] = corrwordslen[i-1];
		}
		corrwordslen[pos] = 0;
	}
}

static void DeleteWord(int pos, BOOL bDelCorrWord)
{
	unsigned char* pws = LocateWord(pos);
	int wordlen = wordslen[pos];
	int wslen = strlen((char*)wordstr);
	int i;

	if (pos > wordnum -1)
		return;

	if (pws + wordlen <  wordstr + wslen)		//not last word
	{
		int iMax = max(wslen-(pws+wordlen-wordstr), wordlen);
		for (int i = 0; i <= iMax; i++)
		{
			*(pws) = *(pws+wordlen);
			*(pws+wordlen) = 0;
			pws++;
		}
	}
	else				// the last word
	{
		for (i = pws - wordstr; i <= wslen - 1; i++)
		{
			wordstr[i] = 0;
		}
	}

	//update wordslen array
	for (i = pos; i < wordnum; i++)
	{
		wordslen[i] = wordslen[i+1];
		wordslen[i+1] = 0;
	}

	//auto delete associated correct word
	if (bDelCorrWord)
	{
		DeleteCorrWord(pos);
//		for (i = pos; i < wordnum; i++)
//		{
//			corrwordslen[i] = corrwordslen[i+1];
//			corrwordslen[i+1] = 0;
//		}
	}

	wordnum --;
}

static CString TransWords(int page)
{
	CString csWords, csiw;
	unsigned char lc = 0;
	unsigned char* pw = wordlist;
	int nw = selwordnum;

	if (nw <= 1)
	{
		csWords = CString("  ") + CString(pw);
		return csWords;
	}
	
	for (int n = 0; n < nw; pw++)
	{
		if (0 != *pw && 0 == lc)
		{
			if (n >= page*10 && n < (page+1)*10)
			{
				csiw.Format(" %1d ", (n+1)%10);
				csWords += csiw + CString(pw);
			}
			else if (n >= (page+1)*10)
			{
				break;
			}
			n++;
		}
		lc = *pw;
	}

	return csWords;
}

static void CorrSent()
{
	unsigned char *pcw;
	unsigned char cw[WORDLEN];
	
	int n = 0;
	for (int i = 0; n < corrwordnum; i++)
	{
		if (corrwordslen[i] != 0)
		{
			pcw = LocateCorrWord(i);
			memset(cw, 0, sizeof(cw));
			strncpy((char*)cw, (char*)pcw, corrwordslen[i]);
			DeleteWord(i, FALSE);
			InsertWord(cw, i, FALSE);
			n++;
		}
	}
}

BOOL InitHook(HWND hEditWnd, HWND hStaWnd)
{
	hInstDLL = LoadLibrary((LPCTSTR)"HikerWB.dll");