hzutil.cpp

windows ce 平台下的輸入法 程序編寫 範例

			}
		}
		awPYArrayKey[wCount][wKeyLen]=0;
		wCount++;
	}
	return wCount;
}

void SortPhrase(LPPHRASE lpPh, WORD wLen)
{
	int i,j;
	PHRASE TempPh;
	DWORD dwAttrib;

	for(i=0;i<wLen;i++){
		dwAttrib=(lpPh+i)->lpHZPH->dwAttrib;
		for(j=i;j<wLen;j++){
			if( dwAttrib < (lpPh+j)->lpHZPH->dwAttrib){
				TempPh = *(lpPh+i);
				*(lpPh+i)=*(lpPh+j);
				*(lpPh+j)=TempPh;
			}
		}
	}
	dwCurPhraseAttrib=lpPh->lpHZPH->dwAttrib;
	
	if (dwMaxPhraseAttrib < lpPh->lpHZPH->dwAttrib) {
		dwMaxPhraseAttrib=lpPh->lpHZPH->dwAttrib;
	}
}



void ConvertPY(LPTSTR lpPYArray,WORD wMaxPYLen,WORD wPYArrayLen,LPFREEPYCAND lpPYCand)
{
	LPHANZI lpHanZi = lpPYCand->aHanZi;
	LPPHRASE lpPhrase = lpPYCand->aPhrase;

	WORD awPYArrayKey[MAX_PHRASE_LEN][2*MAX_EACH_PY_NUM+1];
	BYTE abKey[MAX_PHRASE_LEN+1];
	BYTE abKeyArray[2][MAX_SELECT_PH*5][MAX_PHRASE_LEN+1];
	WORD awKeyArrayLen[2];
	LPKEYPH	alpKeyPh[MAX_SELECT_PH];
	LPKEYPH alpTempKeyPh[2];
	PHRASE aTempPh[MAX_SELECT_PH];
	WORD wResult,wTotal,wHZLen;	
	WORD wCount,wTemp;
	int i,j,k;
	WORD wPhLen,wTotalPh=0;

	if(wPYArrayLen < 1){
		lpPYCand->wPhraseNum = 0;
		lpPYCand->wHZNum = 0;
		return;
	}

	wCount = CreatePYKey(lpPYArray,wMaxPYLen,wPYArrayLen,awPYArrayKey);

	awKeyArrayLen[0]=0;
	awKeyArrayLen[1]=0;
	
	wHZLen = 0;
	wTotal = 0;
	for(k=0;awPYArrayKey[0][k];k++){
		wHZLen += _tcslen(*(alpHZTab+(awPYArrayKey[0][k]-1)));
		lpHanZi->lpHZ = *(alpHZTab+(awPYArrayKey[0][k]-1));
		lpHanZi->wKey = awPYArrayKey[0][k];

#ifdef _UNICODE
		(lpHanZi++)->wLen = wHZLen;
#else
		(lpHanZi++)->wLen = wHZLen/2;
#endif	
		
		abKey[1] = (BYTE)( awPYArrayKey[0][k] & 0xff);
		abKey[0] = 0;
		abKey[0] |= (BYTE)(( awPYArrayKey[0][k] & 0x0100) >> 8);
		
		wResult=QueryPhrase(abKey,1,alpTempKeyPh);
		if( alpTempKeyPh[0] != NULL) *(alpKeyPh + (wTotal++)) = alpTempKeyPh[0];
		if( alpTempKeyPh[1] != NULL) *(alpKeyPh + (wTotal++)) = alpTempKeyPh[1];
		if(wResult > 0)
			memcpy(abKeyArray[0][awKeyArrayLen[0]++],abKey,2);
	}
	
	lpPYCand->wHZNum = lpHanZi - lpPYCand->aHanZi;
	
#define TOGGLE(i) ( (i%2) ? 0 : 1 )	
	for(i=1;i<wCount;i++){
		for(j=awKeyArrayLen[TOGGLE(i)]-1;j+1;j--){
			for(k=0;awPYArrayKey[i][k];k++){
				memcpy(abKey,abKeyArray[TOGGLE(i)][j],i+1);
				abKey[i+1] = (BYTE) ( awPYArrayKey[i][k] & 0xff);
				abKey[0] |= (BYTE)(( awPYArrayKey[i][k] & 0x0100) >> (8-i));

				wResult=QueryPhrase(abKey,(WORD)(i+1),alpTempKeyPh);
				if( alpTempKeyPh[0] != NULL) *(alpKeyPh + (wTotal++)) = alpTempKeyPh[0];
				if( alpTempKeyPh[1] != NULL) *(alpKeyPh + (wTotal++)) = alpTempKeyPh[1];	
				if(wResult > 0)
					memcpy(abKeyArray[i%2][awKeyArrayLen[i%2]++],abKey,i+2);
			}
		}
		awKeyArrayLen[TOGGLE(i)] = 0;
	}

#undef TOGGLE

	if(wTotal > 0){
		wTotalPh = 0;
		wPhLen = 0;
		wTemp = alpKeyPh[wTotal-1]->wLen;
		
		for(i=wTotal-1;i+1;i--){
			if(alpKeyPh[i]->wLen == wTemp){
				aTempPh[wPhLen].lpHZPH = alpKeyPh[i]->lpHZPH;
				aTempPh[wPhLen].lpKeyPH = alpKeyPh[i];
				wPhLen++;
				
				while(aTempPh[wPhLen-1].lpHZPH->lpNext != NULL){
					aTempPh[wPhLen].lpHZPH = aTempPh[wPhLen-1].lpHZPH->lpNext;
					aTempPh[wPhLen].lpKeyPH = alpKeyPh[i];
					wPhLen++;
				}
				wTemp = alpKeyPh[i]->wLen;
				if( i==0 ){
					if( wConversionSet & CONVERSION_SET_SORT)
						SortPhrase(aTempPh,wPhLen);
					memcpy(lpPhrase + wTotalPh,aTempPh,wPhLen*sizeof(PHRASE));
					wTotalPh += wPhLen;
				}
			}
			else{
				if( wConversionSet & CONVERSION_SET_SORT)
					SortPhrase(aTempPh,wPhLen);
				memcpy(lpPhrase + wTotalPh,aTempPh,wPhLen*sizeof(PHRASE));
				wTotalPh += wPhLen;
				wPhLen=0;
				wTemp = alpKeyPh[i]->wLen;
				i++;
			}
		}
	}
	lpPYCand->wPhraseNum = wTotalPh;
	return;
}

WORD CreateCandStr(LPFREEPYCAND lpPYCand, WORD wDirect, LPTSTR lpCandStr,WORD wMaxCandStrSize)
{
	LPHANZI lpHanZi = lpPYCand->aHanZi;
	LPPHRASE lpPhrase = lpPYCand->aPhrase;
	WORD *lpwStatus = &(lpPYCand->wSelectStatus);
	SHORT *lpwCurPos = lpPYCand->awCurrentPos;
	SHORT *lpwBfPos = lpPYCand->awBeforePos;
	WORD awLen[2];
	WORD wCount=0,wTemp,wTempPos,wTempBfPos;
	TCHAR szTemp[30],szTotal[150];
	TCHAR szHZStr[2*MAX_PHRASE_LEN+10],szStrBuf[CAND_PAGESIZE+4][2*MAX_PHRASE_LEN+10];
	int i,flag;
	HDC hDC;
	SIZE sz;
	HFONT oldFont;

	awLen[1] = lpPYCand->wPhraseNum;
	awLen[0] = (lpPYCand->aHanZi + lpPYCand->wHZNum - 1)->wLen;

	RETAILMSG(DEBUGMODE,(TEXT("CreateCandStr: %d  %d  %d\n"),awLen[1],awLen[0],*lpwStatus));
	//DebugLog(0,(DebugLogFile,"CreateCandStr: %d  %d  %d\n",awLen[1],awLen[0],*lpwStatus));	

	if( *lpwStatus && awLen[*lpwStatus] < 1){
		*lpwStatus = 0;
	}
	
	if(!(*lpwStatus) && awLen[*lpwStatus]<1) return wCount;
	hDC = GetDC(NULL);
	oldFont = (HFONT)SelectObject(hDC, hUIFont);
	_tcscpy(szTotal,_T("<>"));

	switch(wDirect){
	case SELECT_FORWARD:
		if( !(lpPYCand->wSelectDirect & wDirect) ){
			wTempPos = *(lpwCurPos+(*lpwStatus));
			*(lpwCurPos+(*lpwStatus)) = *(lpwBfPos+(*lpwStatus))+1;
			*(lpwBfPos+(*lpwStatus)) = wTempPos+1;
			lpPYCand->wSelectDirect = wDirect;
		}
		
		if( *(lpwCurPos+(*lpwStatus)) > awLen[*lpwStatus] - 1){
			if(!(*lpwStatus)){
				MessageBeep(0xFFFFFFFF );
				return wCount;
			}
			else{
				*lpwStatus = 0;
				*(lpwBfPos+(*lpwStatus)) = 0;
				*(lpwCurPos+(*lpwStatus)) = 0;
			}
		}
		
		if(*(lpwCurPos+(*lpwStatus)) < 0) *(lpwCurPos+(*lpwStatus)) = 0;
		
		if((!(*lpwStatus) && awLen[1]>0) || *(lpwCurPos+(*lpwStatus)) > 0)
			_tcscpy( lpCandStr , _T("<") );
		else
			_tcscpy( lpCandStr , _T("") );

		*(lpwBfPos+(*lpwStatus)) = *(lpwCurPos+(*lpwStatus));
		wCount = 2;
		while( *(lpwCurPos+(*lpwStatus)) < awLen[*lpwStatus] && wCount <= CAND_PAGESIZE+1) {
			if(*lpwStatus){
				_tcscpy( szHZStr,(lpPhrase+(*(lpwCurPos+(*lpwStatus))))->lpHZPH->szHZ );
			}
			else{
				for(i=0;i<lpPYCand->wHZNum;i++){
					if((lpHanZi+i)->wLen > *(lpwCurPos+(*lpwStatus)) ) break;
				}
#ifdef _UNICODE
				if(i)
					_tcsncpy(szHZStr,(lpHanZi+i)->lpHZ+(*(lpwCurPos+(*lpwStatus))-(lpHanZi+i-1)->wLen),1);
				else
					_tcsncpy(szHZStr,(lpHanZi+i)->lpHZ+(*(lpwCurPos+(*lpwStatus))),1);
				szHZStr[1]=_T('\0');
#else
				if(i)
					_tcsncpy(szHZStr,(lpHanZi+i)->lpHZ+2*(*(lpwCurPos+(*lpwStatus))-(lpHanZi+i-1)->wLen),2);
				else
					_tcsncpy(szHZStr,(lpHanZi+i)->lpHZ+2*(*(lpwCurPos+(*lpwStatus))),2);
				szHZStr[2]=_T('\0');
#endif
			}

			_stprintf(szTemp,_T("%d%s "),wCount%10,szHZStr);
			
			if(wConversionSet & CONVERSION_SET_GBK) {
				if(wConversionSet & CONVERSION_SET_SHAPE) {
					_tcscat(szTotal,szTemp);
					GetTextExtentPoint(hDC,szTotal,_tcslen(szTotal),&sz);
					if(sz.cx > sizeCand[1].cx) break;
				}
				_tcscpy( (lpCandStr + (wCount++)*wMaxCandStrSize),szHZStr);
			}
			else {
				if(*lpwStatus){
					if(wConversionSet & CONVERSION_SET_SHAPE) {
						_tcscat(szTotal,szTemp);
						GetTextExtentPoint(hDC,szTotal,_tcslen(szTotal),&sz);
						if(sz.cx > sizeCand[1].cx) break;
					}
					_tcscpy( (lpCandStr + (wCount++)*wMaxCandStrSize),szHZStr);
				}
				else{
					if( (*((LPBYTE)szHZStr) >= GB_QUFIRST && *((LPBYTE)szHZStr) <= GB_QULAST) && 
						(*((LPBYTE)szHZStr+1) >= GB_WEIFIRST && *((LPBYTE)szHZStr+1) <= GB_WEILAST) ) {
						if(wConversionSet & CONVERSION_SET_SHAPE) {
							_tcscat(szTotal,szTemp);
							GetTextExtentPoint(hDC,szTotal,_tcslen(szTotal),&sz);
							if(sz.cx > sizeCand[1].cx) break;
						}
						_tcscpy( (lpCandStr + (wCount++)*wMaxCandStrSize),szHZStr);
					}
				}
			}
			*(lpwCurPos+(*lpwStatus)) += 1;
		}
		
		if(*lpwStatus || *(lpwCurPos+(*lpwStatus)) < awLen[*lpwStatus] - 1 && wCount > 1){
			_tcscpy( (lpCandStr + wMaxCandStrSize),_T(">"));
		}
		else {
			_tcscpy( (lpCandStr + wMaxCandStrSize),_T(""));
		}
		
		break;
		
	case SELECT_BACKWARD:
		if( (*lpwStatus && !(*(lpwBfPos+(*lpwStatus))))
			|| (!(*lpwStatus) && awLen[1]<1 && !(*(lpwBfPos+(*lpwStatus)))) ){
			MessageBeep(0xFFFFFFFF );
			return wCount;
		}
		if( !(lpPYCand->wSelectDirect & wDirect) ){
			*(lpwCurPos+(*lpwStatus)) = *(lpwBfPos+(*lpwStatus))-1;
			lpPYCand->wSelectDirect = wDirect;
		}
		
		flag=0;
		if( *(lpwCurPos+(*lpwStatus)) < 0 ){
			if(*lpwStatus || awLen[1] < 1 ){
				MessageBeep(0xFFFFFFFF );
				return wCount;
			}
			else{
				*lpwStatus = 1;
				flag = 1;
				wTempBfPos = *(lpwBfPos+1);
			}
		}
		
		if(flag && *(lpwCurPos+(*lpwStatus)) < awLen[*lpwStatus]-1)
			*(lpwCurPos+(*lpwStatus)) = awLen[*lpwStatus] - 1;

		if( *(lpwCurPos+(*lpwStatus)) > awLen[*lpwStatus]-1)
			*(lpwCurPos+(*lpwStatus)) = awLen[*lpwStatus] - 1;

		if( *lpwStatus || *(lpwCurPos+(*lpwStatus)) < awLen[*lpwStatus] -1)
			_tcscpy( szStrBuf[0], _T(">"));
		else szStrBuf[0][0]=_T('\0');
		
		*(lpwBfPos+(*lpwStatus)) = *(lpwCurPos+(*lpwStatus));

		wCount = 2;	
		while( *(lpwCurPos+(*lpwStatus)) >= 0  && wCount <= CAND_PAGESIZE+1) {
			if(*lpwStatus){
				_tcscpy( szStrBuf[wCount],(lpPhrase+(*(lpwCurPos+(*lpwStatus))))->lpHZPH->szHZ );
				_stprintf(szTemp,_T("%d%s "),wCount%10,(lpPhrase+(*(lpwCurPos+(*lpwStatus))))->lpHZPH->szHZ );
			}
			else{
				for(i=0;i<lpPYCand->wHZNum;i++){
					if((lpHanZi+i)->wLen > *(lpwCurPos+(*lpwStatus)) ) break;
				}
#ifdef _UNICODE
				if(i)
					_tcsncpy(szHZStr,(lpHanZi+i)->lpHZ+(*(lpwCurPos+(*lpwStatus))-(lpHanZi+i-1)->wLen),1);
				else
					_tcsncpy(szHZStr,(lpHanZi+i)->lpHZ+(*(lpwCurPos+(*lpwStatus))),1);
				szHZStr[1]=_T('\0');
				_tcscpy(szStrBuf[wCount],szHZStr);
#else
				if(i)
					_tcsncpy(szHZStr,(lpHanZi+i)->lpHZ+2*(*(lpwCurPos+(*lpwStatus))-(lpHanZi+i-1)->wLen),2);
				else
					_tcsncpy(szHZStr,(lpHanZi+i)->lpHZ+2*(*(lpwCurPos+(*lpwStatus))),2);
				szHZStr[2]=_T('\0');
				_stprintf(szTemp,"%d%s ",wCount%10,szHZStr);
				_tcscpy(szStrBuf[wCount],szHZStr);
#endif
			}

			if(flag && *(lpwCurPos+(*lpwStatus)) == wTempBfPos-1) break;

			if(wConversionSet & CONVERSION_SET_GBK) {
				if(wConversionSet & CONVERSION_SET_SHAPE) {
					_tcscat(szTotal,szTemp);
					GetTextExtentPoint(hDC,szTotal,_tcslen(szTotal),&sz);
					if(sz.cx > sizeCand[1].cx) break;
				}
				wCount++;
			}
			else {
				if(*lpwStatus) {
					if(wConversionSet & CONVERSION_SET_SHAPE) {
						_tcscat(szTotal,szTemp);
						GetTextExtentPoint(hDC,szTotal,_tcslen(szTotal),&sz);
						if(sz.cx > sizeCand[1].cx) break;
					}
					wCount++;
				}
				else{
					if( (*((LPBYTE)szHZStr) >= GB_QUFIRST && *((LPBYTE)szHZStr) <= GB_QULAST) && 
						(*((LPBYTE)szHZStr+1) >= GB_WEIFIRST && *((LPBYTE)szHZStr+1) <= GB_WEILAST) ) {
						if(wConversionSet & CONVERSION_SET_SHAPE) {
							_tcscat(szTotal,szTemp);
							GetTextExtentPoint(hDC,szTotal,_tcslen(szTotal),&sz);
							if(sz.cx > sizeCand[1].cx) break;
						}
						wCount++;
					}
				}
			}
			*(lpwCurPos+(*lpwStatus)) -= 1;
		}
		wTemp = wCount;

		if((!(*lpwStatus) && awLen[1] > 0 ) || (*(lpwCurPos+(*lpwStatus)) > 0 && wCount > 1))
			_tcscpy( lpCandStr, _T("<") );
		else
			_tcscpy( lpCandStr, _T("") );

		wCount = 2;
		for(i = wTemp-1;i>1;i--){
			_tcscpy( (lpCandStr + (wCount++)*wMaxCandStrSize),szStrBuf[i]);
		}
		if( _tcslen(szStrBuf[0])){
			_tcscpy( (lpCandStr + wMaxCandStrSize),szStrBuf[0]);
		}
		else{
			_tcscpy( (lpCandStr + wMaxCandStrSize),_T(""));
		}
		
		break;
		
	default:
		break; 
  }
  SelectObject(hDC, oldFont);
  ReleaseDC(NULL,hDC);
  return wCount -2;
}

void CreatePaintStr(LPTSTR lpPYArray,WORD wMaxSize,WORD wLen,LPTSTR lpConvStr,LPTSTR lpPaintStr)
{
	
	int i;
	_tcscpy(lpPaintStr,lpConvStr);
	for(i=0;i<wLen;i++){
		_tcscat(lpPaintStr,lpPYArray+i*wMaxSize);
		if(i==wLen-1 || 
			*(lpPYArray+(i+1)*wMaxSize)==_T('\'')|| *(lpPYArray+i*wMaxSize)==_T('\''))
			continue;
		else
			_tcscat(lpPaintStr,_T(" "));
	}
	return;
}

WORD EffectPYArrayLen( LPTSTR lpPYArray,WORD wMaxSize,WORD wLen)
{
	int i;
	TCHAR ch;
	WORD wCount=0;
	
	for(i=0;i<wLen;i++){
		ch = *(lpPYArray + i * wMaxSize);
		if(ch == _T('i') || ch == _T('u') || ch == _T('v') ) continue;
		if(ch < _T('a') || ch > _T('z')) continue;
		wCount++;
	}
	return wCount;
}

WORD CalculatePosSpan(LPTSTR lpPYArray,WORD wMaxSize,WORD wLen,WORD wCount)
{
	WORD i;
	TCHAR ch;
	WORD wNum=0;
	
	for(i=0;i<wLen;i++){
		ch=*(lpPYArray + i*wMaxSize);
		if(ch == _T('i') || ch == _T('u') || ch == _T('v')) continue;
		if(ch < _T('a') || ch > _T('z')) continue;
		wNum++;
		if(wNum == wCount) return i+1;
	}
	return 0;
}

SHORT CalculateUnConvPos(LPTSTR lpPYArray,WORD wMaxSize,WORD wLen,LPTSTR lpStr)
{
	int i;
	TCHAR szStr[150];
	SHORT wPos = 0;
	LPTSTR lpDest;

	szStr[0] = _T('\0');
	for(i=0;i<wLen;i++)
		_tcscat(szStr,lpPYArray + i*wMaxSize);
	lpDest = _tcsstr(lpStr,szStr);
	if(lpDest)
		wPos = lpDest - lpStr;
	return wPos;
}