基于GTK的拼音输入法.docx
《基于GTK的拼音输入法.docx》由会员分享，可在线阅读，更多相关《基于GTK的拼音输入法.docx（39页珍藏版）》请在冰豆网上搜索。
基于GTK的拼音输入法
基于GTK的拼音输入法
基于GTK的拼音输入法
（1）
2009-11-1710:
03
#include
#include
#include
#include
#include
charT[]={"abcdefghijklmnopqrstuvwxyz"};
charTT[]={"ABCDEFGHIJKLMNOPQRSTUVWXYZ"};
charpin_y[20];
charpy_store[10];
char*CH_CON[10][9];
charOPERATE; //操作标志位；
intSYMBOL=0; //测试字数组的标志位，用来判断循环的
intROW,COLUMN,ROW_MAX,COLUMN_MIN; //抽出字的数组的行列值
charci_buffer[20]; //预选存放字词的～
charci_py_buffer[20]; //存放词的拼音;
charhanzi[60]; //label显示用的变量
charlabel_swap[30];
charentry_buffer[100];
GtkWidget*entry_all;
GtkWidget*label_py,*label_cn,*label_yx;
structchinese_container
{
charlabel[2];
charpy[8];
charch[3];
}s;
structChinese_data
{
chardata[4]; //存放的一个字
intFrequency; //使用的频度
structChinese_data*next; //指向下一个字
//structChinese_data*pre;//指向前一个字
};
structword
{
chardata[20];
intFrequency;
structword*next;
};
structElement
{
charElementType;//元素的类型
structChinese_data*ch;//存放数据（汉子）
structElement*Father;//父指针
intOld_new;//是新的还是旧的词
intIsword;//判断是字还是词
structElement*letter[26];//孩子指针
structword*ci; //词的指针
};
structElement*pointer=NULL;
structElement*p_element=NULL;
structElement*father=NULL;
structChinese_data*pointer_ch=NULL;
structChinese_data*pu=NULL;
structword*pointer_ci,*pi;
/*******************************************************************
函数名：
creat_node_data;
输入参数：
void；
输出：
void;
功能：
开辟汉字的存储空间；
********************************************************************/
structChinese_data*creat_node_data（void）
{
structChinese_data*c;
c=（structChinese_data*）malloc（sizeof（structChinese_data））;
returnc;
}
/*******************************************************************
函数名：
creat_node_word;
输入参数：
void；
输出：
void;
功能：
开辟词的存储空间，
********************************************************************/
structword*creat_node_word（void）
{
structword*c;
c=（structword*）malloc（sizeof（structword））;
returnc;
}
/*******************************************************************
函数名：
creat_node;
输入参数：
void；
输出：
void;
功能：
开辟链表的存储空间，
********************************************************************/
structElement*creat_node（void）
{
structElement*b;
b=（structElement*）malloc（sizeof（structElement））;
returnb;
}
/*******************************************************************
函数名：
bl;
输入参数：
structElement*head；
输出：
void;
功能：
对输入的链表进行遍历输出，按照汉子表的形式输出，
********************************************************************/
voidbl（structElement*head） //等深度遍历函数
{
inti,j,k;
structChinese_data*ph;
structElement*pe;
structword*pi;
charpiny[8],piy[8];
charci_piny[20],ci_piy[20];
piny[0]='\0';
piy[0]='\0';
for（i=0;i<26;i++）
{
if（head->letter[i]）
{
head=head->letter[i];
if（head->ch!
=NULL） //可以在底下一级插入排序函数即为遍历排序或者插入释放类存的语句！
{
ph=head->ch;
pe=head;
j=0;
while（pe->ElementType） //得到的倒序拼音
{
sprintf（&piny[j],"%c",pe->ElementType）;
pe=pe->Father;
j++;
}
for（k=0;k { //
piy[k]=piny[j-k-1]; //
} //
while（j<8） //
{ //
piy[j]='\40'; //这部分取得拼音，且补上空格！
j++; //
} //
piy[j]='\0'; //
for（k=0;k<26;k++）
{
if（piy[0]==T[k]）
{
printf（"%c",TT[k]）;//打印出大写字母标志
}
}
printf（"%s",piy）; //打印出拼音
pe=NULL;
ph=head->ch;
while（ph!
=NULL）
{
printf（"%s",ph->data）; //打印拼音之后的字
ph=ph->next;
}
printf（"\n"）; //打印换行符号，即拼音后面的汉子结束了。
ph=NULL; //清空指针
}
if（head->ci!
=NULL）
{
pe=head;
j=0;
while（pe->ElementType） //得到的倒序拼音
{
sprintf（&ci_piny[j],"%c",pe->ElementType）;
pe=pe->Father;
j++;
}
for（k=0;k {
ci_piy[k]=ci_piny[j-k-1];
}
ci_piy[j]='\0';
//printf（"%s\n",ci_piy）;
for（k=0;k<26;k++）
{
if（ci_piy[0]==T[k]）
{
printf（"%c",TT[k]）;//打印出大写字母标志
printf（"%c",T[2]）;
}
}
printf（"%s",ci_piy）;
pe=NULL;
pi=head->ci;
while（pi!
=NULL）
{
printf（"%s",pi->data）;
pi=pi->next;
}
printf（"\n"）;
pi=NULL;
}
bl（head）;
head=head->Father;
}
}
}
/*******************************************************************
函数名：
order;
输入参数：
structElement*Head；
输出：
void;
功能：
对输入的链表结构里面有词的节点按照使用频度值进行排序，排序完毕后，将排序完的
表头赋值给输入的指针；
********************************************************************/
voidorder（structElement*Head）/*排序函数*/
{
structwordsh;
structword*head;
sh.next=Head->ci;
head=&sh;
structword*temp=NULL;//默认为NULL,也就是链表的结尾
structword*ptr1=head;
structword*ptr2=head->next;
while（ptr1->next!
=temp）//（ptr1!
=NULL）
{
while（ptr2->next!
=temp）//（ptr2!
=NULL）
{
if（ptr1->next->Frequencynext->Frequency）//（ptr1->score>ptr2->score）
{//交换ptr1->link和ptr2->link
ptr1->next=ptr2->next;
ptr2->next=ptr2->next->next;//temp->link=ptr2;
ptr1->next->next=ptr2;//ptr2->link=ptr1;
}
ptr1=ptr1->next;//ptr2=ptr2->link;
ptr2=ptr1->next;//从上面移动下来的
}
temp=ptr2;//新加的
ptr1=head;//ptr1=ptr1->link;
ptr2=ptr1->next;//从上面移动下来的
}
head=head->next;
Head->ci=head;
}
/*******************************************************************
函数名：
sort;
输入参数：
structElement*Head；
输出：
void;
功能：
对输入的链表结构里面有字的节点按照使用频度值进行排序，排序完毕后，将排序完的
表头赋值给输入的指针；
********************************************************************/
voidsort（structElement*Head）/*排序函数*/
{
structChinese_datash;
structChinese_data*head;
sh.next=Head->ch;
head=&sh;
structChinese_data*temp=NULL;//默认为NULL,也就是链表的结尾
structChinese_data*ptr1=head;
structChinese_data*ptr2=head->next;
while（ptr1->next!
=temp）//（ptr1!
=NULL）
{
while（ptr2->next!
=temp）//（ptr2!
=NULL）
{
if（ptr1->next->Frequencynext->Frequency）//（ptr1->score>ptr2->score）
{//交换ptr1->link和ptr2->link
ptr1->next=ptr2->next;
ptr2->next=ptr2->next->next;//temp->link=ptr2;
ptr1->next->next=ptr2;//ptr2->link=ptr1;
}
ptr1=ptr1->next;//ptr2=ptr2->link;
ptr2=ptr1->next;//从上面移动下来的
}
temp=ptr2;//新加的
ptr1=head;//ptr1=ptr1->link;
ptr2=ptr1->next;//从上面移动下来的
}
head=head->next;
Head->ch=head;
}
/*******************************************************************
函数名：
blpx;
输入参数：
structElement*Head；
输出：
void;
功能：
用字，词的排序函数来实现整个链表的频度排序；
********************************************************************/
voidblpx（structElement*head） //遍历排序总体的
{
inti,j,k;
structChinese_data*p_ch;
//structElement*pe;
for（i=0;i<26;i++）
{
if（head->letter[i]）
{
head=head->letter[i];
//blpx（head）;
if（head->ch!
=NULL）
{
sort（head）; //对这一级的汉子排序
}
if（head->Isword）
{
order（head）;
}
blpx（head）;
head=head->Father;
}
}
}
/*******************************************************************
函数名：
blw;
输入参数：
structElement*Head；
输出：
void;
功能：
对输入的链表进行回写，将链表节点的字，词写入文件中；
********************************************************************/
voidblw（structElement*head） //等深度遍历函数
{
FILE*w_file;
inti,j,k;
structChinese_data*ph;
structword*pi;
structElement*pe;
charpiny[8],piy[8];
charc_piny[20],c_piy[20];
char*space="";
char*enter="\n";
piny[0]='\0';
piy[0]='\0';
for（i=0;i<26;i++）
{
if（head->letter[i]）
{
head=head->letter[i];
//blw（head）;
if（head->ch!
=NULL） //可以在底下一级插入排序函数即为遍历排序或者插入释放类存的语句！
{
ph=head->ch;
pe=head;
j=0;
while（pe->ElementType） //得到的倒序拼音
{
//strncpy（&piny[j],&（pe->ElementType）,1）;
sprintf（&piny[j],"%c",pe->ElementType）;
pe=pe->Father;
j++;
}
for（k=0;k { //
piy[k]=piny[j-k-1]; //
} //
while（j<8） //
{ //
piy[j]='\40'; //这部分取得拼音，且补上空格！
j++; //
} //
piy[j]='\0'; //
for（k=0;k<26;k++）
{
if（piy[0]==T[k]）
{
//printf（"%c",TT[k]）; //大写字母
w_file=fopen（"dx","a+b"）;
fwrite（&TT[k],sizeof（char）,1,w_file）; //写大写字母标记位置！
fwrite（space,sizeof（char）,1,w_file）; //大写字母＋空格
fclose（w_file）;
}
}
//printf（"%s",piy）; //打印出拼音
pe=NULL;
ph=head->ch;
w_file=fopen（"dx","a+b"）; //
fwrite（piy,sizeof（char）,8,w_file）; //写入拼音
fclose（w_file）; //
while（ph）
{
//printf（"%s",ph->data）; //拼音之后的字
w_file=fopen（"dx","a+b"）;
fwrite（ph->data,sizeof（char）,3,w_file）;
fclose（w_file）;
ph=ph->next;
}
//printf（"\n"）;
ph=NULL;
w_file=fopen（"dx","a+b"）;
fwrite（enter,sizeof（char）,strlen（enter）,w_file）; //写换行
fclose（w_file）;
}
if（head->ci!
=NULL）
{
pi=head->ci;
pe=head;
j=0;
while（pe->ElementType） //得到的倒序拼音
{
//strncpy（&piny[j],&（pe->ElementType）,1）;
sprintf（&c_piny[j],"%c",pe->ElementType）;
pe=pe->Father;
j++;
}
for（k=0;k { //
c_piy[k]=c_piny[j-k-1]; //
}
/* //
while（j<20） //
{ //
c_piy[j]='\40'; //这部分取得拼音，且补上空格
升级会员 