hzutil.c

一种中文输入法

			}
			else{
				wFlag = 0;
				for(j=0;j<3;j++){
					if( !_tcscmp(szPY[k],szSlStr[j]) ){
						wFlag=1;
						wSlPos=j;
						break;
					}
				}
				if(wFlag){
					for(j=0;awSlKey[wSlPos][j];j++){
						awPYArrayKey[wCount][wKeyLen++] = awSlKey[wSlPos][j];
					}
				}
				else {
					for(j=0;(lpPYTab + wHead*MAX_EACH_PY_NUM+j)->wKey;j++){
						if( !_tcscmp(szPY[k],(lpPYTab + wHead*MAX_EACH_PY_NUM +j)->szPY)){
							awPYArrayKey[wCount][wKeyLen++] = (lpPYTab + wHead*MAX_EACH_PY_NUM+j)->wKey;
							break;
						}
					}
				}
			}
		}
		awPYArrayKey[wCount][wKeyLen]=0;
		wCount++;
	}
	return wCount;
}

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=0;j<awKeyArrayLen[TOGGLE(i)];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;

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

	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);
	_tcscpy(szTotal,"<>");

	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,"%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,"%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; 
  }
  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;
}