inputer.cpp

包含拼音和笔画输入的中文输入法,使用VC.NET2003开发.portable Chinese input method includes phonetic input and stroke, the

#include	"stdafx.h"
//#include	"..\ChineseInputer.h"
#include	"Inputer.h"

#include	"StreamUtils.h"


namespace	Chinese
{

//===============================================================================
//
//  笔顺类
//
//===============================================================================
/**
*	横
*/
Word	StrokesOrder::s_Heng(_T("一"));


/**
*	竖
*/
Word	StrokesOrder::s_Shu(_T("丨"));

/**
*	撇
*/
Word	StrokesOrder::s_Pie(_T("丿"));

/**
*	捺
*/
Word	StrokesOrder::s_Na(_T("丶"));

/**
*	折
*/
Word	StrokesOrder::s_Zhe(_T("乙"));


/**
*	横
*/
TCHAR	StrokesOrder::s_cHeng	=	TCHAR('1');
	
	
/**
*	竖
*/
TCHAR	StrokesOrder::s_cShu	=	TCHAR('2');;
	
/**
*	撇
*/
TCHAR	StrokesOrder::s_cPie	=	TCHAR('3');
	
/**
*	捺
*/
TCHAR	StrokesOrder::s_cNa		=	TCHAR('4');
	
/**
*	折
*/
TCHAR	StrokesOrder::s_cZhe	=	TCHAR('5');


/*
*	构造函数
*/
StrokesOrder::StrokesOrder( const TCHAR* szOrders )
{
	VERIFY( Set( szOrders ) );
}

/*
*	初始化
*/
BOOL	StrokesOrder::Set( const TCHAR* szOrders )
{
	ASSERT(	szOrders );

	m_DigitStroks	=	_T("");
	
	int		len	=	_tcslen(szOrders);	
	// 如果是空字符， 返回真
	if ( len <= 0 )
		return	TRUE;

	if ( szOrders[0] < 0 ) // 笔顺方式
	{
		ASSERT( len % 2 == 0 );

		TCHAR	*szDigitOrder	=	new	TCHAR[len/2+1];
		for	( int i=0; i<len; i+=2 )
		{
			Word	dwCur(szOrders[i], szOrders[i+1]);
			TCHAR	cCur;
			if	( dwCur == s_Heng )
				cCur	=	TCHAR('1');
			else	if	( dwCur == s_Shu )
				cCur	=	TCHAR('2');
			else	if	( dwCur == s_Pie )
				cCur	=	TCHAR('3');
			else	if	( dwCur == s_Na )
				cCur	=	TCHAR('4');
			else	if	( dwCur == s_Zhe )
				cCur	=	TCHAR('5');
			else
				ASSERT( FALSE );

			szDigitOrder[i/2]	=	cCur;
		}

		szDigitOrder[len/2]	=	TCHAR('\0');
		m_DigitStroks	=	szDigitOrder;

		delete	[]	szDigitOrder;
	}
	else	// 数字方式
		m_DigitStroks	=	szOrders;

	return	TRUE;
}

/*
*	以笔画得方式返回
*/
CString	StrokesOrder::GetAsStroks() const
{
	int		nLength	=	GetLength();
	if	( nLength <= 0 )	
		return	CString(_T(""));

	// 转换
	CString	strStroks(TCHAR('\0'), nLength*2+1);
		
	for	( int i=0; i<nLength; i++ )
	{
		TCHAR	cLow, cHigh;
		switch ( m_DigitStroks[i] )
		{
		case	TCHAR('1')	:
			cLow	=	s_Heng.GetLow();
			cHigh	=	s_Heng.GetHigh();
			break;
		case	TCHAR('2')	:
			cLow	=	s_Shu.GetLow();
			cHigh	=	s_Shu.GetHigh();
			break;
		case	TCHAR('3')	:
			cLow	=	s_Pie.GetLow();
			cHigh	=	s_Pie.GetHigh();
			break;
		case	TCHAR('4')	:
			cLow	=	s_Na.GetLow();
			cHigh	=	s_Na.GetHigh();
			break;
		case	TCHAR('5')	:
			cLow	=	s_Zhe.GetLow();
			cHigh	=	s_Zhe.GetHigh();
			break;
		default	:
			ASSERT( FALSE );
			break;
		}

		// set the current stroks
		strStroks.SetAt( i*2, cLow );
		strStroks.SetAt( i*2+1, cHigh );
	} // end of all stroks

	return  strStroks;
}

//=============================================================================
//
//	拼音组
//
//=============================================================================
const	CString&	SpellGroup::operator []( int i )
{
	ASSERT( i>= 0 && i<GetCount() );
	
	int		idx = 0;
	for ( StringList::iterator it=m_vSpell.begin(); 
		  it!=m_vSpell.end() && idx<i;
		  it++ )  ;
		  
		  return	*it;
}

void	SpellGroup::AddGroup( const TCHAR* szSpell )
{
	CString	strSpell	=	szSpell;
	if ( strSpell == _T("") ) return;

	int		iCur	=	0;
	int		iNext	=	-1;

	while	( TRUE )
	{
		iNext=strSpell.Find(TCHAR(':'), iNext+1 );
		if ( iNext == -1 )
		{
			Add( strSpell.Mid( iCur, strSpell.GetLength()-iCur)  );
			break;
		}
		Add( strSpell.Mid( iCur, iNext-iCur) );
		iCur	=	iNext+1;
	}
}

CString	SpellGroup::GetAsString() const
{
	CString	str;
	
	BOOL	bFirst	=	TRUE;
	const_iterator	it;
	for ( it=begin(); it!=end(); it++ )
	{
		if ( bFirst )
			bFirst	=	FALSE;
		else
			str	+=	_T(":");

		str	+=	*it;
	}
	
	return	str;
}

SpellGroup::operator CString() const
{
	return	GetAsString();
}

void	SpellGroup::Add( const TCHAR* szSpell )
{
	if ( !HaveSpell(szSpell) )
		m_vSpell.push_back( szSpell );
}

void	SpellGroup::Remove( const TCHAR* szSpell )
{
	StringList::iterator	it	=	find( m_vSpell.begin(), m_vSpell.end(), szSpell );
	if ( it != m_vSpell.end() )
		m_vSpell.erase (it);
}

void	SpellGroup::RemoveAll()
{
	m_vSpell.clear();
}

//==========================================================================================
//
//	输入法
//
//==========================================================================================
BOOL	ChineseInputer::QueryWords ( WordEnumerator& enumer, Sorter*	pSorter )
{
	/**************************************************************************************
	*  过滤顺序
	*		1.	笔画数
	*		2.	部首
	*		3.  笔顺
	*		4.  拼音
	*
	**************************************************************************************/
	Inputer*	pInputer	=	GetInputer();
	ASSERT( pInputer );

	QueryBroker	qBroker;

	if ( pInputer->GetSpell() != _T("") )
	{
		qBroker.AddFilter( new SpellFilter(pInputer->GetSpell()), TRUE );

		// 如果是拼音则需要加入拼音前缀
		if ( pSorter )
		{
			if ( *pSorter == *GetSpellSort() )
				static_cast<SpellSort*>(pSorter)->SetPrefix( pInputer->GetSpell() );

			/*
			if ( *pSorter == *GetCompositeSort() )
				static_cast<CompositeSort*>(pSorter)->SetPrefix( pInputer->GetSpell() );
			*/
		}// CompisitSort
	}

	if ( pInputer->GetStrokesOrder() != _T("") )
		qBroker.AddFilter( 
		new StrokesOrderFilter( 
		StrokesOrder(pInputer->GetStrokesOrder() ) ), TRUE );

	if ( pInputer->GetStrokes() != _T("") )
		qBroker.AddFilter( new StrokesFilter(pInputer->GetStrokes()), TRUE );

	if ( pInputer->GetBS() != _T("") )
		qBroker.AddFilter( new BSFilter(pInputer->GetBS()), TRUE );


	if ( !qBroker.QueryWords( enumer ) )
		return	FALSE;

	//  排序
	if	(	pSorter )
		pSorter->Sort( enumer );

	return	TRUE;
}

/**
*	构造函数
*/
ChineseInputer::ChineseInputer() 
{
}


/**
*	拼音输入码分隔符
*/
const TCHAR	ChineseInputer::Inputer::s_cSpellLeft	=	TCHAR('{');
const TCHAR	ChineseInputer::Inputer::s_cSpellRight =	TCHAR('}');

/**
*	部首输入码分隔符
*/
const TCHAR	ChineseInputer::Inputer::s_cBSLeft		=	TCHAR('(');
const TCHAR	ChineseInputer::Inputer::s_cBSRight	=	TCHAR(')');

/**
*	笔画输入码分隔符
*/
const TCHAR	ChineseInputer::Inputer::s_cStrokesLeft	=	TCHAR('<');
const TCHAR	ChineseInputer::Inputer::s_cStrokesRight	=	TCHAR('>');	

/**
*	笔顺输入码分隔符
*/
const TCHAR	ChineseInputer::Inputer::s_cStrokesOrderLeft	=	TCHAR('[');
const TCHAR	ChineseInputer::Inputer::s_cStrokesOrderRight	=	TCHAR(']');

TCHAR	ChineseInputer::Inputer::s_cDividTable[4][2]	=	
{
	{	s_cSpellLeft,	s_cSpellRight	},
	{	s_cBSLeft,		s_cBSRight		},
	{	s_cStrokesLeft,	s_cStrokesRight	},
	{	s_cStrokesOrderLeft,	s_cStrokesOrderRight }
};

/**
*	空排序器
*/
ChineseInputer::NullSort*	   ChineseInputer::GetNullSort()
{
	static	NullSort	s_NullSort;
	return	&s_NullSort;
}

/*
*	拼音排序器
*/
ChineseInputer::SpellSort*		ChineseInputer::GetSpellSort()
{
	static	SpellSort	s_SpellSort;
	return	&s_SpellSort;
}

/*
*	笔画排序器
*/
ChineseInputer::StrokesSort*	ChineseInputer::GetStrokesSort()
{
	static	StrokesSort		s_StrokesSort;
	return &s_StrokesSort;
}

/*
*	部首排序器
*/
ChineseInputer::BSSort*		ChineseInputer::GetBSSort()
{
	static	BSSort	s_BSSort;
	return	&s_BSSort;
}

/*
*	笔顺排序器
*/
ChineseInputer::StrokesOrderSort*	ChineseInputer::GetStrokesOrderSort()
{
	static	StrokesOrderSort	s_StrokesOrderSort;
	return	&s_StrokesOrderSort;
}

ChineseInputer::CompositeSort*	ChineseInputer::GetCompositeSort()
{
	static	CompositeSort	sorter;
	return	&sorter;
}

/*
*	获得输入器
*/
ChineseInputer::Inputer*	ChineseInputer::GetInputer()
{
	return	&m_Inputer ;
}

/*
*	输入器构造函数
*/
ChineseInputer::Inputer::Inputer() : m_uMode( Input_Spell )
{
	Reset();
}

/*
*	设置当前模式
*/
void	ChineseInputer::Inputer::SetMode( int uMode )
{
	ASSERT( uMode >= Input_Spell && uMode <= Input_StrokesOrder );

	m_strInputs	+=	s_cDividTable[m_uMode][end];
	m_uMode		=	uMode;
	m_strInputs	+=	s_cDividTable[m_uMode][begin];
}

int		ChineseInputer::Inputer::GetMode() const
{
	return	m_uMode;
}

CString	ChineseInputer::Inputer::GetInputs() const
{
	return	_T("");
}

void	ChineseInputer::Inputer::Put( TCHAR c )
{
	m_strInputs	+=	c;
}

void	ChineseInputer::Inputer::Put( const TCHAR* szChars )
{
	m_strInputs	+=	szChars;
}

void	ChineseInputer::Inputer::Reset()
{
	m_strInputs	=	s_cDividTable[m_uMode][begin];
}

CString	ChineseInputer::Inputer::GetUnparse( ) const
{
	CString		strTemp	=	m_strInputs;
	strTemp	+=	s_cDividTable[m_uMode][end];
	
	return	strTemp;
}

CString	ChineseInputer::Inputer::GetSpell() const
{

	return	InputParser(GetUnparse() ).GetSpell();
}

CString	ChineseInputer::Inputer::GetBS() const
{
	return	InputParser( GetUnparse() ).GetBS();
}

CString	ChineseInputer::Inputer::GetStrokesOrder() const 
{
	return	InputParser( GetUnparse() ).GetStrokesOrder();
}

CString	ChineseInputer::Inputer::GetStrokes() const
{
	return	InputParser( GetUnparse() ).GetStrokes();
}

ChineseInputer::Inputer::InputParser::InputParser( const CString& str ) :
	m_strForParse(str)
{
	VERIFY( Parse( m_strForParse ) );
}

/**
*	提取字符串
*/
CString		PickPhrase( const CString& str, TCHAR cEnd, int& index )
{
	int		nStart	=	index;
	while ( str[index] && str[index] != cEnd ) index++;
	ASSERT( str[index] );

	CString	strCur	=	str.Mid( nStart+1, index- nStart -1 );
	index++;

	return	strCur;
}


BOOL	ChineseInputer::Inputer::InputParser::Parse( const CString& str )
{
	int		index	=	0;

	int		nLength	=	str.GetLength();
	while ( index < nLength )
	{
		switch ( str[index] )
		{
		case	Inputer::s_cBSLeft :
			{
				m_strBS	+=	PickPhrase( str, Inputer::s_cBSRight, index ); /*strCur*/;
			}
			break;
		case	Inputer::s_cSpellLeft :
			{
				m_strSpell	+=	PickPhrase( str, Inputer::s_cSpellRight, index );
			}
			break;
		case	Inputer::s_cStrokesLeft :
			{
				m_strStrokes	=	PickPhrase( str, Inputer::s_cStrokesRight, index );
			}
			break;
		case	Inputer::s_cStrokesOrderLeft :
			{
				m_strStrokesOrder	+=	PickPhrase( str, Inputer::s_cStrokesOrderRight, index );
			}