C语言实现文本编辑器系统

2023-09-16 00:09:05 92
本文实例为大家分享了C语言实现文本编辑器系统的具体代码，供大家参考，具体内容如下
/*文本编辑器editor源代码*/


#include
#include
#include
#include
#defineLEFT0x4b00/*←：光标左移*/
#defineRIGHT0x4d00/*→：光标右移*/
#defineDOWN0x5000/*↓键：光标下移*/
#defineUP0x4800/*↑键：光标上移*/
#defineESC0x011b/*ESC键：取消菜单打开操作*/
#defineENTER0x1c0d/*回车键：换行*/
#defineDEL21248/*DEL键：删除当前字符*/
#defineBACK3592/*BackSpace键：删除当前光标位置前一个字符*/
#defineCL29440/*ctrl+←键：从右至左，选定文本*/
#defineCR29696/*ctrl+→键：从左到右，选定文本*/
#defineCc11779/*ctrl+c键：将选定文本，复制一份到剪贴板中*/
#defineCv12054/*ctrl+v键：将剪贴板中的内容复制到当前位置*/
#defineCx11544/*ctrl+x键：对选定文本，执行剪切操作*/
#defineF115104/*F1键：打开文件菜单*/
#defineF215360/*F2键：打开编辑菜单*/
#defineF315616/*F3键：打开帮助菜单*/
#defineF1017408/*F10键:进入文本快速预览模式*/
intvalue,backup,NUM;
/*value保存有值数组元素的最大下标值，backup保存value的副本，NUM保存当前行中的用户输入的字符个数*/
typedefstructrecord
{
charch;/*保存一字符*/
intcol,line;/*x轴和y轴坐标*/
}record;
recordr[500];/*定义一个有500个元素的结构体数组，保存选定的文本字符的属性*/

typedefstructnode/*定义保存行中的单个字符的结构*/
{
charch;/*数据域：保存一字符*/
structnode*next;/*指针域：指向下一个结点的指针*/
}node;/*由此类型节点构成的单链表，命名为：列单链表*/


typedefstructHnode/*定义保存所有列单链表首节点的指针的结构*/
{
node*next;/*指向列单链表的首节点的地址*/
structHnode*nextl;/*指向下一个节点的指针*/
}Hnode;/*由此类型节点构成的单链表，命名为：行单链表*/



voiddrawmain()/*画主窗口函数*/
{
inti,j;
gotoxy(1,1);/*在文本窗口中设置光标至(1,1)处*/
textbackground(7);/*选择新的文本背景颜色,7为LIGHTGRAY淡灰色*/
textcolor(0);/*在文本模式中选择新的字符颜色0为BLACK黑*/
insline();/*在文本窗口的(1,1)位置处中插入一个空行*/
for(i=1;i<=24;i++)
{
gotoxy(1,1+i);/*（x,y)中x不变，y++*/
cprintf("%c",196);/*在窗口左边输出-,即画出主窗口的左边界*/
gotoxy(80,1+i);
cprintf("%c",196);/*在窗口右边，输出-，即画出主窗口的右边界*/
}
for(i=1;i<=79;i++)
{
gotoxy(1+i,2);/*在第2行，第2列开始*/
cprintf("%c",196);/*在窗口顶端，输出-*/
gotoxy(1+i,25);/*在第25行，第2列开始*/
cprintf("%c",196);/*在窗口底端，输出-*/
}
gotoxy(1,1);cprintf("%c",196);/*在窗口左上角，输出-*/
gotoxy(1,24);cprintf("%c",196);/*在窗口左下角，输出-*/
gotoxy(80,1);cprintf("%c",196);/*在窗口右上角，输出-*/
gotoxy(80,24);cprintf("%c",196);/*在窗口右下角，输出-*/
gotoxy(7,1);cprintf("%c%cFile%c%c",179,17,16,179);/*|<>|*/
gotoxy(27,1);cprintf("%c%cEdit%c%c",179,17,16,179);/*|<>|*/
gotoxy(47,1);cprintf("%c%cHelp%c%c",179,17,16,179);/*|<>|*/
gotoxy(5,25);/*跳至窗口底端*/
textcolor(1);
cprintf("Row:1Col:1");
gotoxy(68,25);
cprintf("Version2.0");
}



voidqview(Hnode*q)/*快速预览文本：开头：#，回车：**/
{
voidview(Hnode*q);/*view()函数声明*/
node*p;
inti;
window(1,1,80,25);/*定义文本窗口大小*/
clrscr();/*清屏*/
/*循环读取两个单链表中的值：q是一个指向行单链表首节点的指针，
此单链表数据域的值为实际保存各行字符的列单链表p中的首节点地址*/
do{
p=q->next;/*p指向保存行数据的列单链表的首节点的地址*/
cprintf("#");/*每行开头，打印此字符，不管前面是否有回车符*/
while(p!=NULL)/*循环读取单链表p中的值*/
{
if(p->ch==13)putch('*');/*若为回车键，打印出*号*/
else
putch(p->ch);/*输出各行中的字符到预览窗口*/
p=p->next;/*指向下一个节点*/
}
q=q->nextl;/*指向下一个节点*/
printf("\n");/*输出一个回车*/
}while(q!=NULL);

getch();
clrscr();
drawmain();/*按任意键后，回到主窗口界面*/
window(2,2,79,23);
textbackground(9);
for(i=0;i<24;i++)
insline();/*插入24个空行*/
window(3,3,78,23);
textcolor(10);
}


voidview(Hnode*q)/*按行显示保存在单链表中的文本字符,q为指向行单链表中第一个节点的指针*/
{
node*p;/*p为保存列单链表节点元素地址的指针*/
clrscr();/*清屏*/
/*双重循环，读取并显示保存在单链表中字符*/
do{
p=q->next;
while(p!=NULL&&p->ch>=32&&p->ch<127&&p->ch!=13&&p->ch!=-1)/*指针p不能为空，且数据域必须为常规字符*/
{
putch(p->ch);/*在文本窗口中输出该字符*/
p=p->next;/*指向下一个节点*/
}
q=q->nextl;/*指向下一个节点*/
if((p->ch==13||p->ch==-1)&&q!=NULL)gotoxy(1,wherey()+1);/*若ch为回车或EOF标记，光标跳至下行的开始处*/
}while(q!=NULL);/*逐行逐列显示文本字符*/
}

intcheck(Hnode*Hhead,intm,intn)/*check():在单链表中检查第m行第n列位置的字符，若为常规字符，则返回该字符*/
{
inti;
Hnode*q;
node*p;
q=Hhead;
for(i=1;inextl;
p=q->next;/*获取第m个节点的数据域*/
for(i=1;inext;
if(p->ch==13)return-1;/*若第m行，第n列的字符为回车键，则返回-1*/
if(p->ch>=32&&p->ch<127)returnp->ch;/*若第m行，第n列的字符为常规字符,则返回该字符*/
elsereturn0;/*若第m行，第n列的字符既非回车符又非常规字符，则返回0*/
}


intjudge(Hnode*Hhead,intm)/*judge():返回第m行中的常规字符总的个数，不包括回车符*/
{
Hnode*q;
node*p;
inti,num=0;
q=Hhead;
for(i=1;inextl;

if(q==NULL)return-1;/*返回-1,表示第m行不存在*/
p=q->next;
while(p->next!=NULL)
{
p=p->next;
num++;/*统计第m行的字符个数*/
}
/*行尾字符还没有判断，接下来判断行尾字符*/
if(p->ch==13&&num==0)return0;/*返回0,表示当前行只有一个回车字符*/
if(p->ch>=32&&p->ch<127)returnnum+1;/*返回num+1,表示当前行的最后一个字符为常规字符*/
if(p->ch==13&&num!=0)returnnum;/*返回num,表示当前行的最后一个字符为回车符，不计算在内*/
elsereturn1;/*返回num,表示当前行中只有一个字符，且没有回车符*/
}




intdel(Hnode*Hhead,intm,intn)/*del():删除第m行，第n列位置的字符*/
{
Hnode*q,*q1;
node*p1,*p2,*tail;
inti,num=0,j,flag=0;
q=Hhead;
if(n==0&&m==1)return;/*第1行，第0列不存在*/
if(n==0&&m>1)/*若为第0列字符，但行必须大于1,执行向上行移处理*/
{
n=76;
m=m-1;
gotoxy(n,m);/*移至第m-1行，第76列*/
flag=1;/*移位的标志置1*/
}

for(i=1;inextl;
p1=q->next;

for(i=1;inext;
p2=p1->next;/*p2指向列单链表中的第n个元素*/

if(n==1)/*若是删除第m行第1列的字符*/
{
q->next=p1->next;
free(p1);
}
else
{
p1->next=p2->next;/*在单链表中删除第m行第n列的元素*/
free(p2);
}

/*删除掉第m行第n列的元素后，处理行单链表中第m个节点后的数据向前移的任务*/
while((num=judge(Hhead,m++))>0)/*执行一次judge(Head,m)后，m才加1.这里必须满足行常规字符数不为0的条件*/
{
p1=q->next;q1=q;
if(p1!=NULL)/*若当前行非空*/
{
while(p1->next!=NULL)
p1=p1->next;
tail=p1;/*tail保存列单链表最后一个元素的地址*/
q=q->nextl;/*指向下一行的元素的地址*/
p1=p2=q->next;
tail->next=p1;/*tail的指针域指向下一行的第一个元素的地址*/
}
else/*若当前行的字符个数为0,即删除该字符后，只剩下回车符，则将下一个行单链表中节点的数据域移至前一下节点的数据域*/
{
q=q->nextl;p1=p2=q->next;
q1->next=p1;/*q1->next指向下一行的第一个元素的地址*/
}

for(i=0;i<76-num;i++)
/*当前行还有76-num个空位没有字符，在下一行的单链表中读取字符，直至遇到回车符为止*/
{
p1=p2;/*p1指向p2的前一个节点,p2指向行单链表中下一个节点*/
p2=p2->next;
if(p2->ch==13)break;/*若为回车，跳出循环*/
}
q->next=p2;/*在列单链表中去掉移至上行的元素*/
p1->next=NULL;/*下行移至上行的最后一个元素，指针置空*/
}
returnflag;/*返回0：表示没有换位，返回1：表示有换位*/
}

/*执行insert()后，检验第n行及后面的数据，使其满足规则*/
inttest(Hnode*Hhead,intn)
{
inti=0,num1=1;
node*p1,*p2,*tail,*temp1,*temp2;
Hnode*q;
q=Hhead;
for(i=1;inextl;
tail=p1=q->next;
if(p1==NULL)return;/*若此行没有任何字符，则返回*/
while(tail->next!=NULL)/*定位至列单链表中的最后一个元素*/
tail=tail->next;

/*若此单链表中没有回车符且有超过76个节点时，则p1会指向此列单链表中的第76个节点*/
for(i=0;i<75;i++)
{
if(p1->ch==13||p1->next==NULL)break;
p1=p1->next;
}

p2=p1->next;
p1->next=NULL;/*在此行的最后一个字符的前一个字符处断行,因为插入在此行插入了一个新的字符*/
if(tail->ch!=13)/*若此行行尾不是回车键*/
{
if(p1->ch==13&&q->nextl==NULL)/*若p1的数据域为回车符且行单链表中只有n个节点*/
{
q->nextl=(Hnode*)malloc(sizeof(Hnode));/*新建一个行单链表节点，相当于添加一个新行*/
q->nextl->nextl=NULL;
tail->next=(node*)malloc(sizeof(node));/*在tail所指节点位置开始继续准备添加字符*/
tail->next->ch=13;tail->next->next=NULL;
q->nextl->next=p2;/*新行单链表节点保存此行多出的字符*/
}
else/*若此行行尾和行中都没有回车键,或者q->nextl不为空*/
{
q=q->nextl;/*q->nextl有可能为空*/
tail->next=q->next;/*将多出的字符与下一行的字符相连*/
q->next=p2;/**/
if(q!=NULL)test(Hhead,++n);/*若行单链表第n个节点后还有节点，继续test()的相同处理*/
}

}
else/*若此列单链表最后一个元素为回车符*/
{
temp2=p2;/*p2指向第77个字符，或者为空(为空表示此行插入一个字符后，没有超出范围*/
while(q!=NULL&&p2!=NULL)/*q指向行列表中的第n个节点.条件:行单链表中第n个节点存中且有第77个字符*/
{/*条件：在行单链表中只有n个节点,且字符超过了一行规定的76个，且num1标志为1*/
if((q->nextl==NULL)&&(p1!=tail||p2!=NULL)&&(num1==1))
{
num1++;
q->nextl=(Hnode*)malloc(sizeof(Hnode));/*新建一个行单链表节点,准备存储此行中多出的字符*/
q->nextl->nextl=NULL;q->nextl->next=NULL;/*初始化值*/

}
/*行单链表中第n+1个节点已经存在，下面为在行单链表中插入一个新的节点*/
q=q->nextl;/*q指向行列表中的第n+1个节点*/
temp1=q->next;
q->next=temp2;/*q的数据域为此行中多出的字符所在的列单链表中的节点地址*/
temp2=temp1;
}
}
}

voidinsert(Hnode*Hhead,intm,intn,chara)/*第m行，第n列的位置之前一个位置，插入单字符*/
{
inti;
Hnode*q;
node*p,*p1,*p2;
q=Hhead;
for(i=1;inextl;
p1=q->next;
for(i=1;inext;
p=(node*)malloc(sizeof(node));/*创建一个新的列单链表节点*/
p->ch=a;/*给此节点的数据域赋值*/
if(n==1)/*插入之前，若只有一个字符在行中，则插在此节点之前*/
{
p->next=q->next;
q->next=p;
}
else
{
p->next=p1->next;/*在第m行，第n列的字符前，插入一字符*/
p1->next=p;
}
test(Hhead,m);/*在插入新元素后，检验并处理单链表中第m行开始的元素，使其满足规则*/

}

/*对控制键进行响应，A：按键的整数值，Hhead:行单链表的首地址*/
voidcontrol(intA,Hnode*Hhead)
{
voidcolorview(Hnode*,int,int);/*函数声明*/
intx,y,flag=0;
x=wherex();y=wherey();/*得到当前光标的坐标值*/
if((A==CL)&&(x!=1))/*ctrl+←，当前光标不是在行首,光标移动*/
gotoxy(wherex()-1,wherey());

if((A==CL)&&(x==1))/*ctrl+←，在行首*/
gotoxy(abs(judge(Hhead,wherey()-1)),wherey()-1);/*judge(Hhead,wherey()-1)上一行的字符个数作为x值，光标移动*/

if((A==CR)&&check(Hhead,wherey(),wherex())>0)/*ctrl+→,当前光标的右边有字符，光标移动*/
{flag=1;gotoxy(wherex()+1,wherey());}

if((A==CR)&&check(Hhead,wherey()+1,1)>0&&check(Hhead,y,x)==0)/*ctrl+→,当前光标处没有字符但下一行的第一列有字符，光标移动*/
{flag=1;gotoxy(1,wherey()+1);}

if((A==CR)&&x==76)/*ctrl+→，当前光标在当前行的行尾，光标移动*/
{flag=1;gotoxy(1,wherey()+1);}

if(A==CR&&flag==1)/*ctrl+→，光标已经跳至新处，将当前光标所在位置的字符的坐标和值保存在r数组中*/
{
r[abs(value)].col=wherex();
r[abs(value)].line=wherey();
r[abs(value)].ch=check(Hhead,r[abs(value)].line,r[abs(value)].col);
if(r[abs(value)].ch==-1)r[abs(value)].ch=13;/*若第line行，第col列的字符为回车键，则返回-1*/
value--;

}

if(A==CL&&(x!=1||y!=1))/*ctrl+←,当前光标并不在窗口左上角,将当前光标所在位置的字符的坐标和值保存在r数组中*/
{

r[abs(value)].col=wherex();
r[abs(value)].line=wherey();
r[abs(value)].ch=check(Hhead,r[abs(value)].line,r[abs(value)].col);
value++;
}

colorview(Hhead,wherex(),wherey());

}

/*用不同的前背景色显示选择的字符*/
voidcolorview(Hnode*Hhead,intx,inty)
{

inti;
view(Hhead);/*重新显示所有文本字符*/
for(i=0;iopenfileerror!\n");
getchar();
return;
}
do{
p=q->next;/*指向node类型的数据*/
while(p!=NULL)
{if((int)p->ch==13)
{
fputc('\n',fp);p=p->next;count++;
}
else
{fputc(p->ch,fp);
p=p->next;
count++;}
}
q=q->nextl;
}while(q!=NULL);

fclose(fp);/*关闭此文件*/
return;
}

/*文件另存为:将head所指的行单链表中所指的各个列单链表中的数据域的值写入文件，文件路径和文件名由用户指定*/
voidsaveas(Hnode*head)
{
FILE*fp;
Hnode*q;
node*p;
intcount=0,x,y;
charfilename[10];/*保存文件名*/
q=head;
clrscr();/*清屏*/
printf("Enterinfilename,forexample[c:\\wb.txt]:");/*输入文件名格式*/
scanf("%s",filename);/*输入文件名*/
fp=fopen(filename,"w");
if(fp==NULL)/*打开文件失败*/
{
printf("\n=====>openfileerror!\n");
getchar();
return;
}
do{
p=q->next;/*指向node类型的数据*/
while(p!=NULL)
{if((int)p->ch==13)
{
fputc('\n',fp);p=p->next;count++;
}
else
{fputc(p->ch,fp);
p=p->next;
count++;}

}
q=q->nextl;
}while(q!=NULL);

fclose(fp);/*关闭此文件*/
return;
}

/*从任意文本文件中读取文件内容，保存至行单链表和列单链表形式的数据结构中*/
voidopens(Hnode*Hp)
{
FILE*fp;
Hnode*q11,*q22;
node*p11,*p22,*hp;
chartemp;
intcount=0,flags=1;
charfilename[10];/*保存文件名*/
clrscr();/*清屏*/
printf("Enterinfilename,forexample[c:\\wb.txt]:");/*输入文件名格式*/
scanf("%s",filename);/*输入文件名*/
fp=fopen(filename,"r");/*以只读方式打开文件，filename必须要存在*/
if(fp==NULL)/*打开文件失败*/
{textbackground(2);
textcolor(13);
cprintf("openfileerror!");
getchar();
exit(0);
}
q11=Hp;
while(!feof(fp))
{count=0;flags=1;
q22=(Hnode*)malloc(sizeof(Hnode));/*新建一个行单链表中的节点*/
p11=(node*)malloc(sizeof(node));/*新建一个列单链表中的节点*/
while((temp=fgetc(fp))!=10&&count<=76&&!feof(fp))/*循环结束，表示在单链表中一行处理完毕，开始新行*/
{p22=(node*)malloc(sizeof(node));/*新建一个列单链表中的节点*/
if(flags==1){hp=p22;flags=0;}/*hp保存列单链表中的首节点的地址*/
p22->ch=temp;p22->next=NULL;
p11->next=p22;p11=p22;
count++;
}
if(temp==10){/*若为换行符，将其转换为回车符，因为在程序中，是按回车符处理的*/
p22=(node*)malloc(sizeof(node));p22->ch=13;p22->next=NULL;
p11->next=p22;p11=p22;
}
if(!feof(fp))/*若没此条件，文件最后一行会处理两次.*/
{q22->next=hp;q22->nextl=NULL;/*将存储了字符的新列单链表与行单链表中的新节点建立关联*/
q11->nextl=q22;q11=q22;}
}
fclose(fp);
Hp=Hp->nextl;/*因为Hp的所在节点的数据域为空，所以Hp=Hp->nextl*/
return;
}


voidmain()
{
chara;
inti,A,x,y,flag=0,b;
Hnode*Hhead,*q;
node*p1,*p2;
Hhead=(Hnode*)malloc(sizeof(Hnode));/*为行单链表中首节点分配内存空间*/
q=Hhead;Hhead->nextl=NULL;
p1=p2=q->next=(node*)malloc(sizeof(node));/*为列单链表中首节点分配内存空间*/
p1->ch=13;p1->next=NULL;
drawmain();/*显示主窗口*/
window(2,2,79,23);
textbackground(9);
for(i=0;i<24;i++)
insline();
window(3,3,78,23);
textcolor(10);

while(1)
{
while(bioskey(1)==0)continue;/*等待用户按键*/
a=A=bioskey(0);/*返回输入的字符的键值*/
if(a>=32&&a<127)/*若输入为常规字符或回车键*/
{

if(check(Hhead,wherey(),wherex())<=0)/*当前位置没有字符且输入是常规字符，则执行添加字符操作*/
{
NUM++;
p2->ch=a;
putch(a);
if(NUM==76)/*连续输入满行，分别生成一个新的行单链表和列单链表节点*/
{
p2->next=NULL;
q->nextl=(Hnode*)malloc(sizeof(Hnode));
q=q->nextl;q->nextl=NULL;q->next=NULL;
p1=p2=q->next=(node*)malloc(sizeof(node));
p1->ch=13;p1->next=NULL;
NUM=0;
}
else/*连续输入未满一行,生成一个新的列单链表节点*/
{
p2->next=(node*)malloc(sizeof(node));
p2=p2->next;
p2->ch=13;
p2->next=NULL;

}
}

else/*当前位置有字符且输入是常规字符,则执行插入字符操作*/
{
x=wherex();y=wherey();
insert(Hhead,wherey(),wherex(),a);
NUM++;
view(Hhead);
gotoxy(x,y);
}


}

/*若输入为回车键*/
if(a==13)
{
gotoxy(1,wherey()+1);
q->nextl=(Hnode*)malloc(sizeof(Hnode));
q=q->nextl;q->nextl=NULL;q->next=NULL;
p1=p2=q->next=(node*)malloc(sizeof(node));
p1->ch=13;p1->next=NULL;
NUM=0;
}

x=wherex();y=wherey();
/*文本窗口中左移,当前光标不在窗口的第1列*/
if((A==LEFT)&&(x!=1))gotoxy(wherex()-1,wherey());
/*文本窗口中左移,当前光标在窗口的第1列*/
if((A==LEFT)&&(x==1))gotoxy(abs(judge(Hhead,wherey()-1)),wherey()-1);
/*文本窗口中右移,若当前光标的右边一位有字符*/
if((A==RIGHT)&&check(Hhead,wherey(),wherex())>0)gotoxy(wherex()+1,wherey());
/*文本窗口中右移至下行的第1列,若当前光标位置没有字符且下行的第1列有字符*/
if((A==RIGHT)&&check(Hhead,wherey()+1,1)!=0&&check(Hhead,y,x)<=0)gotoxy(1,wherey()+1);
/*右移*/
if((A==RIGHT)&&x==76)gotoxy(1,wherey()+1);
/*上移*/
if((A==UP)&&check(Hhead,wherey()-1,wherex())!=0)gotoxy(wherex(),wherey()-1);
/*上移*/
if((A==UP)&&check(Hhead,wherey()-1,wherex())<=0)
{
if(judge(Hhead,wherey()-1)==0)
gotoxy(-judge(Hhead,wherey()-1)+1,wherey()-1);
else
gotoxy(-judge(Hhead,wherey()-1),wherey()-1);
}

/*下移*/
if((A==DOWN)&&check(Hhead,wherey()+1,wherex())!=0)
gotoxy(wherex(),wherey()+1);

/*处理BackSpace键*/
if(A==BACK)/*处理BackSpace键*/
{
flag=del(Hhead,wherey(),wherex()-1);
x=wherex()-1;y=wherey();
view(Hhead);
if(flag==0)
{
if(x!=0)gotoxy(x,y);
elsegotoxy(x+1,y);
}
if(flag==1)
{
gotoxy(x+1,y);
flag=0;
}
}
/*处理菜单按键F1F2F3*/
if((A==F1)||(A==F2)||(A==F3)||(a<32||a>127))
{A=menuctrl(Hhead,A);
if(A==100){main();}/*新建文件*/

if(A==101){/*打开文件*/
Hhead=(Hnode*)malloc(sizeof(Hnode));
opens(Hhead);
getchar();clrscr();gotoxy(3,3);view(Hhead);
}
/*保存文件*/
if(A==102){save(Hhead);clrscr();cprintf("savesuccessfully!");getch();gotoxy(3,3);view(Hhead);}
/*文件另存为*/
if(A==103){saveas(Hhead);clrscr();cprintf("saveassuccessfully!");getch();gotoxy(3,3);view(Hhead);}
/*帮助*/
if(A==120){clrscr();cprintf("F1:FileF2:EditF3:Help");
getch();gotoxy(3,3);view(Hhead);}
if(A==121){clrscr();cprintf("Abort:Version2.0Tel:XXXXXXXXXX");getch();gotoxy(3,3);view(Hhead);}
}

/*处理DEL键,删除当前位置的单个字符*/
if(A==DEL)
{
x=wherex();y=wherey();
del(Hhead,wherey(),wherex());
view(Hhead);
gotoxy(x,y);
}
/*处理已经选定文本字符后，按DEL键的情况*/
if(A==DEL&&value!=0)
{
if(value>0)
x=wherex(),y=wherey();
else
x=r[0].col,y=r[0].line;
for(i=0;i0)
del(Hhead,r[i].line,r[i].col);
if(value<0)
del(Hhead,r[abs(value)-1-i].line,r[abs(value)-1-i].col);
}
value=0;/*此value为全局变量*/
view(Hhead);
gotoxy(x,y);
}
/*处理Ctrl+x按键*/
if(A==Cx&&value!=0)
{
if(value>0)
x=wherex(),y=wherey();
else
x=r[0].col,y=r[i].line;
for(i=0;i0)
del(Hhead,r[i].line,r[i].col);
if(value<0)
del(Hhead,r[abs(value)-1-i].line,r[abs(value)-1-i].col);
}
backup=value;/*保存r数组的有值元素的最大下标值*/
value=0;/*此value为全局变量*/
view(Hhead);
gotoxy(x,y);
}

/*处理Ctrl+c按键*/
if(A==Cc&&value!=0)
{
x=wherex();y=wherey();
backup=value;value=0;/*此value为全局变量*/
view(Hhead);
gotoxy(x,y);
}

/*处理Ctrl+v按键*/
if(A==Cv&&backup!=0)
{
x=wherex();y=wherey();
if(backup<0)/*Ctrl+右移键选定的文本，贴切此当前位置*/
for(i=0;i0)/*Ctrl+左移键选定的文本，贴切此当前位置*/
for(i=0;i
以上就是本文的全部内容，希望对大家的学习有所帮助，也希望大家多多支持毛票票。
C语言实现文本编辑器系统

热门推荐

随机推荐
