📄 inputer.h
字号:
protected :
/**
* 初始化字
*/
void InitWord( Word wd, const WordComment& wc );
};
public :
/**
* 获的部首查询器
*/
static BSQuery* GetBSQuery();
/**
* 获的笔画查询器
*/
static StrokesQuery* GetStrokesQuery();
/**
* 获的拼音查询器
*/
static SpellQuery* GetSpellQuery();
/**
* 获的拼写查询器
*/
static StrokesOrderQuery* GetStrokesOrderQuery();
protected :
/**
* 型别转换
*/
template <class TQuery>
struct TypeTraits
{
};
/**
* 获得特定的查询器
*/
template <class TQuery>
static TQuery* GetQuery( TypeTraits<TQuery> )
{
static TQuery s_Query;
static BOOL bInit = FALSE;
// 首次使用初始化
if ( !bInit )
{
if ( !s_Query.Initialize( &s_WordTable ) )
return NULL;
else
bInit = TRUE;
}
return &s_Query;
}
protected :
/**
* 所有汉字表
*/
static WordTable s_WordTable;
/**
* 部首表
*/
static BSWord s_BSWordTable[];
friend class BSWords;
};
/**
* 字典生成器
*/
class ChineseDictionaryMaker
{
public :
/**
* 制作字典
*/
static BOOL Make( const TCHAR* szSpell,
const TCHAR* szBS,
const TCHAR* szStrokes );
protected :
typedef map<Word, ChineseDictionary::WordComment> WordTable;
/**
* 处理拼音
*/
static BOOL ProcessSpell( const TCHAR* szSpell, WordTable& wtbl );
/**
* 处理部首
*/
static BOOL ProcessBS( const TCHAR* szBS, WordTable& wtbl );
/**
* 处理笔画
*/
static BOOL ProcessStrokes( const TCHAR* szStrokes, WordTable& wtbl );
}; // end of DictionaryMaker
/**
* 部首比较器
*/
struct BSLess
{
/**
* 比较wd1和wd2大小
* @param 如果wd1>wd2返回true, 否则为false
*/
BOOL operator()( Word wd1, Word wd2 )
{
return wd1<wd2;
}
};
/**
* 字符串比较器
*/
struct StringLess
{
/**
* 比较str1和str2大小
* @param 如果str1>str2返回true, 否则为false
*/
BOOL operator()( const CString& str1, const CString& str2 ) const
{
return str1<str2;
}
};
/**
* 笔顺比较器
*/
struct StrokesOrderLess : public StringLess
{
};
/**
* 拼音比较器
*/
struct SpellLess : public StringLess
{
};
/**
* 笔画比较器
*/
struct StrokesLess
{
BOOL operator( )( int n1, int n2 ) const
{
return n1 < n2;
}
};
/**
* 字符串包含测试器
*/
struct StringContainTester
{
/**
* 判断strTest前半部分是否包含strPrefix
*/
static BOOL Contain( const TCHAR* strTest,
const TCHAR* strPrefix )
{
int index = 0;
while ( strTest[index] && strPrefix[index] )
{
if ( strTest[index] != strPrefix[index] )
return FALSE;
index++;
}
return strTest[index] ||
strTest[index] == strPrefix[index] ? TRUE : FALSE;
}
};
/**
* 拼音包含测试器
*/
struct SpellContainTester : public StringContainTester
{
};
/**
* 笔顺包含测试器
*/
struct StrokesOrderContainTester : public StringContainTester
{
};
/**
* 中文输入法
*/
class ChineseInputer
{
public :
/**
* 汉字枚举器
*/
typedef list<Word> WordEnumerator;
/**
* 输入器
*/
class Inputer
{
public :
/**
* 输入模式
*/
enum
{
/**
* 输入拼音
*/
Input_Spell = 0,
/**
* 输入部首
*/
Input_BS,
/**
* 输入笔画
*/
Input_Strokes,
/**
* 输入笔顺
*/
Input_StrokesOrder
}; // end of input state
/**
* 构造函数
*/
Inputer();
/**
* 设置输入模式
*/
void SetMode( int nMode );
/**
* 获得输入模式
*/
int GetMode() const;
/**
* 获得所有输入
*/
CString GetInputs() const;
/**
* 输入字符
*/
void Put( TCHAR c );
/**
* 输入字符串
*/
void Put( const TCHAR* szChars );
/**
* 输入法重置
*/
void Reset();
/**
* 获得输入的拼音
*/
CString GetSpell() const;
/**
* 获得输入的部首
*/
CString GetBS() const;
/**
* 获得输入的笔顺
*/
CString GetStrokesOrder() const;
/**
* 获得输入的笔画
*/
CString GetStrokes() const;
protected :
/**
* 获得原始串
*/
CString GetUnparse() const;
protected :
/**
* 输入解析器
*/
class InputParser
{
public :
/**
* 构造函数
*/
InputParser( const CString& str );
/**
* 获得输入的拼音
*/
const CString& GetSpell() const
{
return m_strSpell;
};
/**
* 获得输入的部首
*/
const CString& GetBS() const
{
return m_strBS;
};
/**
* 获得输入的笔顺
*/
const CString& GetStrokesOrder() const
{
return m_strStrokesOrder;
};
/**
* 获得输入的笔画
*/
const CString& GetStrokes() const
{
return m_strStrokes;
};
protected :
/**
* 解析函数
*/
BOOL Parse( const CString& str );
protected :
/**
* 需要解析得字符串
*/
CString m_strForParse;
/**
* 拼音
*/
CString m_strSpell;
/**
* 笔顺
*/
CString m_strStrokesOrder;
/**
* 笔画
*/
CString m_strStrokes;
/**
* 部首
*/
CString m_strBS;
};
public :
/**
* 拼音输入码分隔符
*/
static const TCHAR s_cSpellLeft, s_cSpellRight;
/**
* 部首输入码分隔符
*/
static const TCHAR s_cBSLeft, s_cBSRight;
/**
* 笔画输入码分隔符
*/
static const TCHAR s_cStrokesLeft, s_cStrokesRight;
/**
* 笔顺输入码分隔符
*/
static const TCHAR s_cStrokesOrderLeft, s_cStrokesOrderRight;
/**
* 分割字符
*/
static TCHAR s_cDividTable[4][2];
/**
* 分别指左右分隔符
*/
enum
{
begin = 0,
end = 1
};
protected :
/**
* 当前输入模式
*/
int m_uMode;
/**
* 已经输入的所有码
*/
CString m_strInputs;
};
/**
* 构造函数
*/
ChineseInputer();
/**
* 排序器
*/
class Sorter
{
protected :
/**
* 排序模式
*/
Sorter( int nMode ) : m_nMode(nMode) { }
public :
/**
* 输出汉字排序模式
*/
enum
{
/**
* 不排序
*/
OrderByNone,
/**
* 按部首排序
*/
OrderByBS,
/**
* 按拼音排序
*/
OrderBySpell,
/**
* 按笔画排序
*/
OrderByStrokes,
/**
* 按笔顺排序
*/
OrderByStrokesOrder
};
/**
* 排序
*/
virtual void Sort( WordEnumerator& enumer ) = 0;
/**
* 判断排序器是否相等
*/
BOOL operator==( const Sorter& sb ) const
{
return m_nMode == sb.m_nMode;
}
/**
* 判断是否不等
*/
BOOL operator!=( const Sorter& sb ) const
{
return m_nMode != sb.m_nMode;
}
/**
* 获得排序模式
*/
int GetMode() const
{
return m_nMode;
}
protected :
/**
* 排序模式
*/
int m_nMode;
};
/**
* 根据输入码， 查询汉字
*/
BOOL QueryWords( WordEnumerator& enumer, Sorter* pSorter=NULL );
typedef ChineseDictionary::BSQuery BSQuery;
/**
* 获得部首查询器
*/
BSQuery* GetBSQuery()
{
return ChineseDictionary::GetBSQuery( );
}
typedef ChineseDictionary::SpellQuery SpellQuery;
/**
* 获得查询查询器
*/
SpellQuery* GetSpellQuery( )
{
return ChineseDictionary::GetSpellQuery();
}
typedef ChineseDictionary::StrokesQuery StrokesQuery;
/**
* 获得笔画查询器
*/
StrokesQuery* GetStroksQuery()
{
return ChineseDictionary::GetStrokesQuery();
}
typedef ChineseDictionary::StrokesOrderQuery StrokesOrderQuery;
/**
* 获得笔顺查询器
*/
StrokesOrderQuery* GetStrokesOrderQuery()
{
return ChineseDictionary::GetStrokesOrderQuery();
}
/**
* 获得输入器
*/
Inputer* GetInputer();
protected :
/**
* 输入器
*/
Inputer m_Inputer;
protected :
/**
* 查询过滤器
*/
class QueryFilter
{
public :
QueryFilter( const TCHAR* szFilter ) : m_strFilter(szFilter)
{
}
/**
* 析构函数
*/
~QueryFilter() { }
/**
* 查询
*/
virtual BOOL QueryWords( WordEnumerator& enumer ) = 0;
/**
* 过滤字
*/
virtual BOOL Pass( Word wd ) = 0;
/**
* 获得过滤器名称
*/
const CString& GetFilter() const
{
return m_strFilter;
}
protected :
const ChineseDictionary::WordComment& GetComment(Word wd)
{
ChineseDictionary::WordItemRef ref = ChineseDictionary::Get(wd);
ASSERT ( ref != ChineseDictionary::NullWordItemRef );
return ref.GetComment( );
}
protected :
/**
* 过滤器
*/
CString m_strFilter;
};
/**
* 拼音过滤器
*/
class SpellFilter : public QueryFilter
{
public :
/**
* 构造函数
*/
SpellFilter( const TCHAR* szSpell );
~SpellFilter() { }
/**
* 查询
*/
BOOL QueryWords( WordEnumerator& enumer );
/**
* 过滤字
*/
BOOL Pass( Word wd );
};
/**
* 部首过滤器
*/
class BSFilter : public QueryFilter
{
public :
/**
* 构造函数
*/
BSFilter( const TCHAR* szBS );
/**
* 查询
*/
BOOL QueryWords( WordEnumerator& enumer );
/**
* 过滤字
*/
BOOL Pass( Word wd );
};
/**
* 笔画过滤器
*/
class StrokesFilter : public QueryFilter
{
public :
/**
* 构造函数
*/
StrokesFilter( const TCHAR* szBS );
/**
* 查询
*/
BOOL QueryWords( WordEnumerator& enumer );
/**
* 过滤字
*/
BOOL Pass( Word wd );
/**
* 笔画数
*/
int GetStrokes() const
{
return m_nStrokes;
};
protected :
/**
* 笔画数
*/
int m_nStrokes;
};
/**
* 笔顺过滤器
*/
class StrokesOrderFilter : public QueryFilter
{
public :
/**
* 构造函数
*/
StrokesOrderFilter( const StrokesOrder& sodr );
/**
* 查询
*/
BOOL QueryWords( WordEnumerator& enumer );
/**
* 过滤字
*/
BOOL Pass( Word wd );
};
/**
* 查询代理器
*/
class QueryBroker
{
public :
/**
* 析构函数
*/
~QueryBroker();
/**
* 加入过滤器
*/
void AddFilter( QueryFilter* pFilter, BOOL bAutoDel=FALSE );
/**
* 查询
*/
BOOL QueryWords( WordEnumerator& enumer );
protected :
/**
* 过滤器集合
*/
vector<QueryFilter*> m_vFilters;
/**
* 自动删除标记
*/
vector<BOOL> m_vDeletes;
};
/**
* 拼音排序
*/
class SpellSort : public Sorter
{
public :
/**
* 排序器构造函数
*/
SpellSort() : Sorter(OrderBySpell) {};
/**
* 排序
*/
void Sort( WordEnumerator& enumer );
/**
* 获得前缀
*/
const CString& GetPrefix() const
{
return m_strSpellPrefix;
}
/**
* 设置前缀
*/
void SetPrefix( const TCHAR* szPrefix )
{
m_strSpellPrefix = szPrefix;
}
protected :
/**
* 排序得主拼音
*/
CString m_strSpellPrefix;
};
/**
* 部首排序
*/
class BSSort : public Sorter
{
public :
/**
* 排序器构造函数
*/
BSSort() : Sorter(OrderByBS) {};
/**
* 排序
*/
void Sort( WordEnumerator& enumer );
};
/**
* 笔画排序
*/
class StrokesSort : public Sorter
{
public :
/**
* 排序器构造函数
*/
StrokesSort() : Sorter(OrderByStrokes) {};
/**
* 排序
*/
void Sort( WordEnumerator& enumer );
};
/**
* 笔顺排序
*/
class StrokesOrderSort : public Sorter
{
public :
/**
* 排序器构造函数
*/
StrokesOrderSort() : Sorter(OrderByStrokesOrder) {};
/**
* 排序
*/
void Sort( WordEnumerator& enumer );
};
/**
* 空排序器
*/
class NullSort : public Sorter
{
public :
/**
* 排序器构造函数
*/
NullSort() : Sorter(OrderByNone) {};
/**
* 排序
*/
void Sort( WordEnumerator& enumer ) {};
};
public :
/**
* 组合排序器
*/
class CompositeSort : public SpellSort
{
public :
/**
* 构造函数
*/
CompositeSort() { m_nMode = -1;}
/**
* 加入排序模式
*/
void AddMode( int uMode );
/**
* 排序
*/
void Sort( WordEnumerator& enumer );
/**
* 清除所有模式
*/
void ClearModes();
protected :
/**
* 排序模式
*/
vector<int> m_vModes;
};
/**
* 空排序器
*/
static NullSort* GetNullSort();
/**
* 拼音排序器
*/
static SpellSort* GetSpellSort();
/**
* 笔画排序器
*/
static StrokesSort* GetStrokesSort();
/**
* 部首排序器
*/
static BSSort* GetBSSort();
/**
* 笔顺排序器
*/
static StrokesOrderSort* GetStrokesOrderSort();
/**
* 组合排序起
*/
static CompositeSort* GetCompositeSort();
};
/**
* 名称转换类
* 将中文名转换成拼音名
*/
class NameTransform
{
public :
/**
* 将中文名转换成拼音文件名
*/
static BOOL Chinese2PY( const TCHAR* szName, TCHAR* szNewName )
{
const char* pCurSrc = szName;
char* pCurDst = szNewName;
while ( *pCurSrc )
{
if ( *pCurSrc > 0 ) // digit and char
{
*pCurDst++ = *pCurSrc++;
}
else // chinese
{
char strWord[3];
strWord[0] = *pCurSrc;
strWord[1] = *(pCurSrc+1);
strWord[2] = '\0';
ChineseDictionary::WordItemRef wordRef = ChineseDictionary::Get( Word(strWord) );
if ( wordRef == ChineseDictionary::NullWordItemRef )
return FALSE;
// 获得第一拼音
const SpellGroup& spells = wordRef.GetComment().GetSpellGroup();
SpellGroup::const_iterator it = spells.begin();
CString strEnglishName = *it;
int nLen = strEnglishName.GetLength();
strncpy( pCurDst, strEnglishName, nLen );
pCurSrc += 2;
pCurDst += nLen;
}
}
*pCurDst = '\0';
return TRUE;
}
};
//=========================================================================================
// 拼音组
//=========================================================================================
inline
SpellGroup::SpellGroup()
{
m_vSpell.reserve(3);
}
inline
SpellGroup::SpellGroup( const TCHAR* szSpellGroup )
{
AddGroup( szSpellGroup );
}
inline
int SpellGroup::GetCount() const
{
return m_vSpell.size();
}
};
#endif
⌨️ 快捷键说明
复制代码
Ctrl + C
搜索代码
Ctrl + F
全屏模式
F11
切换主题
Ctrl + Shift + D
显示快捷键
?
增大字号
Ctrl + =
减小字号
Ctrl + -