文本编辑器C语言代码

/************************************
名 称：文本编辑器
作 者：黄健
版 本：v1.0
时 间：2006-08
Email：freewind22@https://www.doczj.com/doc/963752833.html,
*************************************/

/* File.c 功能：仿window打开，保存对话框*/

int InputBox(int l,int t,int r,int b,int isFocus,char * filename)
{
int len,ah,al,idelay=0,iCursor=1;
int x,y,c;
char cc[2]="a";
int result=FALSE;
settextjustify(0,1);
y=t+2;
refresh:
len=strlen(filename);
TextBox(l,t,r+1,b);
setcolor(iTextBoxColor);
if (len>32) {
c=len-32;
x=l+32*8+4;
}else{
c=0;
x=l+len*8+4;
}
outtextxy(l+4,t+8,&filename[c]);
Cursor2(x,y,iCursor);
while(isFocus){
while(!kbhit()){
delay(lDelay);
idelay++;
if(idelay>5){
idelay=0;
iCursor=-iCursor+1;
Cursor2(x,y,iCursor);
}
}
GetKey(&ah,&al);
if(ah==1 && al==27){ /* ESC */
result=-1;
isFocus=0;
}
if(al>=33 && al<=126 && len<127){ /* a-z A-Z 0-9 ...*/
filename[len]=al;
filename[len+1]=0;
len++;
if(len<=32){
Cursor2(x,y,FALSE);
cc[0]=al;
setcolor(iTextBoxColor);
outtextxy(x,t+8,cc);
x+=8;
Cursor2(x,y,TRUE);
}else goto refresh;
}
if(ah==14 && al==8 && len>0){ /* backspace */
len--;
cc[0]=filename[len];
filename[len]=0;
if(len<32){
Cursor2(x,y,FALSE);
x-=8;
setcolor(iTextBoxBgColor);
outtextxy(x,t+8,cc);
Cursor2(x,y,TRUE);
}else goto refresh;
}
if(ah==28 && al==13){ /* Enter */
isFocus=0;
result=TRUE;
}
if(ah==15 && al==9) isFocus=0;
}
Cursor2(x,y,FALSE);
return result;
}
void ShowCurPath(int l,int t,char * path){
char cpath[33];
int i;
setfillstyle(SOLID_FILL,iBgColor);
bar(l,t-7,l+260,t+7);
setcolor(iForeColor);
if(strlen(path)>32){
for(i=0;i<29;i++)
cpath[i]=path[i];
cpath[i]=0;
strcat(cpath,"...");
path=cpath;
}
outtextxy(l,t+1,path);
}
int DriveListBox(int l,int t,int r,int b,int isFocus,int * drive){
int result=FALSE;
int ah=0,al=0,i;
char c[]="[- A -]";
Reset:
TextBox(l,t,r,b);
c[3]=''A''+ *drive;
if(isFocus){
setfillstyle(SOLID_FILL,iTextBoxColor);
bar(l+1,t+1,r-1,b-1);
setcolor(iTextBoxBgColor);
}else
setcolor(iTextBoxColor);
outtextxy(l+4,t+8,c);
Button(r-15,t+1,r-1,b-1,iBgColor);
setcolor(iForeColor);
for(i=1;i<5;i++)
line(r-12+i,b-10+i,r-3-i,b-10+i);
while(isFocus){
GetKey(&ah,&al);
if(ah==1 && al==27){ /* ESC */
result=-1;
isFocus=0;
}
if(ah==72 && al==0) /* UP */
if(*drive>2){
(*drive)--;
goto Reset;
}
if(ah==80 && al==0) /* Down */
if(*drive(*drive)++;
goto Reset;
}
if(ah==15 && al==9 || ah==28 && al==13){ /* Tab Enter */
isFocus=0;
goto Reset;
}
}
return result;
}
int DirListBox(int l,int t,int r,int b,int isFocus,char * curpath){
char AllDirs[50][13],filename[3];
struct ffblk ff;
int x,y,i,done;

int result=FALSE;
static int currow,maxrow,curpage;
int ah,al,linehei=13;
x=l+4,y=t+9;
if(isFocus==-1 || isFocus==2){
refresh:
currow=0,maxrow=0,curpage=0;
if(chdir(curpath)){
printf(" ERROR ");
}
done=findfirst("*",&ff,FA_DIREC);
while(!done && maxrow<50){ /* found */
if(strcmp(ff.ff_name,".")){
strcpy(AllDirs[maxrow],ff.ff_name);
maxrow++;
}
done=findnext(&ff);
}
ShowCurPath(l,t-57,curpath);
FileListBox(l+140,t-34,l+140+120,t-34+145,-1,curpath,filename);
changepage:
TextBox(l,t,r,b);
x=l+4,y=t+9;
ScollBar(r-16,t+1,b-t-2,TRUE,currow+1,maxrow,8);
setcolor(iTextBoxColor);
for(i=curpage*8;iouttextxy(x,y,AllDirs[i]);
y+=linehei;
}
}
while(isFocus>0){
y=t+9+(currow-curpage*8)*linehei;
setfillstyle(SOLID_FILL,iTextBoxColor); /* show */
setcolor(iTextBoxBgColor);
bar(x-2,y-6,r-18,y+5);
outtextxy(x,y,AllDirs[currow]);
GetKey(&ah,&al);
if(ah==1 && al==27){ /* ESC */
result=-1;
isFocus=0;
}
if(((ah==72 && currow>0) || (ah==80 && currow{
setfillstyle(SOLID_FILL,iTextBoxBgColor); /* hide */
setcolor(iTextBoxColor);
bar(x-2,y-6,r-18,y+5);
outtextxy(x,y,AllDirs[currow]);
if(ah==72) currow--; /* UP */
else currow++; /* Down */
if(currow>=(curpage+1)*8){ /* page down */
curpage++;
goto changepage;
}
if(currowcurpage--;
goto changepage;
}
}
if(ah==15 && al==9){ /* Tab */
isFocus=0;
goto changepage;
}
if(ah==28 && al==13){ /* Enter */
if(!strcmp(AllDirs[currow],"..")){ /* back up */
for(i=strlen(curpath)-1;i>0;i--)
if(curpath[i]==''\\'') break;
if(i>3) curpath[i]=0; else curpath[i+1]=0;
}else{ /* sub directory */
if(strlen(curpath)>3) strcat(curpath,"\\");
strcat(curpath,AllDirs[currow]);
}
ShowCurPath(l,t-57,curpath);
FileListBox(l+140,t-34,l+140+120,t-34+145,-1,curpath,filename);
goto refresh;
}
}
return result;
}
int FileListBox(int l,int t,int r,int b,int isFocus,char * curpath,char * filename)
{
char AllFiles[100][13];
struct ffblk ff;
int x,y,i,done;
static int currow,maxrow,curpage;
int result=FALSE;
int ah,al,linehei=13;
x=l+4,y=t+9;
if(isFocus){
currow=0,maxrow=0,curpage=0;
if(chdir(curpath)){
printf("ERROR");
}
done=findfirst("*.*",&ff,FA_RDONLY|FA_HIDDEN|FA_SYSTEM|FA_ARCH);
while(!done && maxrow<100){ /* found */
strcpy(AllFiles[maxrow],ff.ff_name);
maxrow++;
done=findnext(&ff);
}
changepage:
TextBox(l,t,r,b);
x=l+4,y=t+9;
ScollBar(r-16,t+1,b-t-2,TRUE,currow+1,maxrow,11);
setcolor(iTextBoxColor);
for(i=curpage*11;iouttextxy(x,y,AllFiles[i]);
y+=linehei;
}
}
while(isFocus>0){
y=t+9+(currow-curpage*11)*linehei;
setfillstyle(SOLID_FILL,iTextBoxColor); /* show */
setcolor

(iTextBoxBgColor);
bar(x-2,y-6,r-18,y+5);
outtextxy(x,y,AllFiles[currow]);
GetKey(&ah,&al);
if(ah==1 && al==27){ /* ESC */
result=-1;
isFocus=0;
}
if(((ah==72 && currow>0) || (ah==80 && currow{
setfillstyle(SOLID_FILL,iTextBoxBgColor); /* hide */
setcolor(iTextBoxColor);
bar(x-2,y-6,r-18,y+5);
outtextxy(x,y,AllFiles[currow]);
if(ah==72) currow--; /* UP */
else currow++; /* Down */
if(currow>=(curpage+1)*11){ /* page down */
curpage++;
goto changepage;
}
if(currowcurpage--;
goto changepage;
}
}
if(ah==15 && al==9){ /* Tab */
isFocus=0;
goto changepage;
}
if(ah==28 && al==13){ /*Enter */
isFocus=0;
strcpy(filename,AllFiles[currow]);
result=1;
goto changepage;
}
}
return result;
}
/**************************** FrmGetFileName() **************************/
int FrmGetFileName(int OorS){
int l,t,r,b;
int iFocus=1;
char * filename=cFileName,curpath[240],tempfilename[13];
int drive,i,iExit=FALSE,ah,al;
char *cc[]={"File Name:","\0","Drives:","Directories:","Files:","O K","Cancel"};
int x[7],y[7],focus[7];
int retval=FALSE,tempdrive;
char cTitle[10],cError[81];
FILE *fp;
if(OorS==OPENFILE ) {
strcpy(cTitle,"Open File");
strcpy(cError,"File not exist,please input again.");
}else{
strcpy(cTitle,"Save File");
strcpy(cError,"File already exist,overwrite(Y/N)");
}
l=iMaxX/2-140,t=iMaxY/2-140,r=iMaxX/2+142,b=iMaxY/2+125;
for(i=0;i<7;i++){
x[i]=l+10;
focus[i]=1;
}
x[4]=x[0]+140,x[5]=l+35,x[6]=x[5]+140;
y[0]=t+34,y[1]=y[0]+26,y[4]=y[2]=y[1]+23;
y[3]=y[2]+34,y[5]=y[6]=y[4]+158;
/* get data */
drive=getdisk();
MaxDrives=setdisk(drive);
for(i=3;iif(getcurdir(i,curpath)) break;
MaxDrives=i-4;
getcwd(curpath,200);
/* show message */
refresh:
OpenWindow(l,t,r,b,FALSE,TRUE,cTitle);
settextjustify(0,1);
setcolor(iForeColor);
for(i=0;i<7;i++)
if (i<5) outtextxy(x[i],y[i]-8,cc[i]);
else Button(x[i],y[i],x[i]+70,y[i]+16,iConBtnBgColor);
setcolor(iConBtnColor);
outtextxy(x[5]+23,y[5]+8,cc[5]);
outtextxy(x[6]+11,y[6]+8,cc[6]);
DriveListBox(x[2],y[2],x[2]+120,y[2]+16,FALSE,&drive);
DirListBox(x[3],y[3],x[3]+120,y[3]+111,-1,curpath);
/* list box */
while(!iExit){
switch(iFocus){
case 1:
setcolor(iBgColor);
rectangle(x[6]-2,y[6]-2,x[6]+72,y[6]+18);
retval=InputBox(x[0],y[0],x[0]+260,y[0]+16,focus[0],filename);
if(!retval) /* Tab */
iFocus+=2;
break;
case 3:
tempdrive=drive;
retval=DriveListBox(x[2],y[2],x[2]+120,y[2]+16,focus[2],&drive);
if(!retval){ /* Tab ,Enter 2:refresh and foucs -1:refresh 1:focus*/
iFocus++;
if(tempdrive!=drive) {
focus[3]=2;
curpath[0]=''A''+drive;
curpath[1]=0;
strcat(curpath,":\\");
setdisk(drive);
}
}
break;
case 4:
retval=DirListBox(

x[3],y[3],x[3]+120,y[3]+111,focus[3],curpath);
if(!retval) /* Tab */
iFocus++;
break;
case 5:
retval=FileListBox(x[4],y[4],x[4]+120,y[4]+145,focus[4],curpath,filename);
if(!retval)
iFocus++;
break;
case 6:
case 7:
if (iFocus==7){
setcolor(iBgColor);
rectangle(x[5]-2,y[5]-2,x[5]+72,y[5]+18);
}
setcolor(iForeColor);
rectangle(x[iFocus-1]-2,y[iFocus-1]-2,x[iFocus-1]+72,y[iFocus-1]+18);
while(TRUE){
GetKey(&ah,&al);
if(ah==1 && al==27){ /* ESC */
retval=-1;
break;
}
if(ah==28 && al==13){ /* Enter */
if(iFocus==7) iExit=TRUE;
else {
if(strlen(cFileName)<1) {
iFocus=1;
setcolor(iBgColor);
rectangle(x[5]-2,y[5]-2,x[5]+72,y[5]+18);
}else
retval=1;
}
break;
}
if(ah==15 && al==9){ /* Tab */
iFocus++;
if(iFocus>7) iFocus=1;
break;
}
}
break;
}
if(retval==-1) /* ESC */
iExit=TRUE;
if(retval==1){ /* already select */
fp=fopen(cFileName,"r");
if((fp==NULL && OorS==OPENFILE) || (fp!=NULL && OorS==SAVEFILE)){
MsgBox(l+2,iMaxY/2-30,r-2,iMaxY/2+30,cError);
settextjustify(0,1);
GetKey(&ah,&al);
if(OorS==SAVEFILE && (al==89 || al==121))
iExit=TRUE;
fclose(fp);
if(OorS==OPENFILE && iFocus==6){
iFocus=1;


setcolor(iBgColor);
rectangle(x[5]-2,y[5]-2,x[5]+72,y[5]+18);
}
}else
iExit=TRUE;
if(iExit){
ah=strlen(cFileName);
for(i=0;iif(cFileName[i]==''\\'') break;
if(i==ah){ /* no path */
strcpy(tempfilename,cFileName);
strcpy(cFileName,curpath);
strcat(cFileName,"\\");
strcat(cFileName,tempfilename);
}
}else goto refresh;
} /* end if */
} /* end while */
RefreshText(t,b);
return retval;
}
/* File.c 结束*/

/*　主文件 */

#include
#include
#include
#include
#include
#include
#include
/****************************** const *****************************/
#define TRUE 1
#define FALSE 0
#define UP 5
#define DOWN 4
#define LEFT 2
#define RIGHT 3
#define HOME 6
#define END 7
#define CTRLHOME 8
#define CTRLEND 9
#define PAGEUP 10
#define PAGEDOWN 11
#define OPENFILE 12
#define SAVEFILE 13
#define LINEHEI 16
#define ROWHEI 12
#define PAGEROW 35
#define PAGECOL 77
#define INDENTCOL 30
#define INDENTROW 30
#define MAXCOL 300
#define LEN sizeof(struct fileline)
/****************************** struct ***************************/
struct fileline{
char * line;
struct fileline * next;
struct fileline * prev;
};
/******************************* public variable ****************************/
/* color */
int iBgColor,iForeColor;
int iTitleColor,iTitleBgColor,iConBtnColor,iConBtnBgColor;
int iTextBoxBgColor,iTextBoxColor;
int iScollBarColor;
int KeyColor,CommentColor;
/* data */
int CLanguag

e=TRUE,TextChanged=FALSE;
char cFileName[128];
char cFilePath[128];
char cImagePath[64];
int MaxDrives;
struct time CurTime;
struct fileline * head=NULL,* end=NULL,* curline=NULL;
int RowChanged=FALSE;
char Line[MAXCOL+1];
int CurRow=0,CurCol=0,T_CurCol=0;
int MaxRowPage=0,MaxColPage=0;
int CurRowPage=0,CurColPage=0;
int SubRow=PAGEROW-INDENTROW-1;
int TotalRow=0;
int TabSize,CurTab=0;
int iMaxX,iMaxY;
char cAppName[]="MyEditor";
int iLeft=0,iTop=0,iRight=639,iBottom=479;
int ieLeft=5,ieTop=39,ieRight=620,ieBottom=457;
long lDelay=30000L;
int SelStartRow=0,SelStartCol=0,SelEndRow=0,SelEndCol=0;
int isComment=FALSE;
int Key_Ins=TRUE,Key_Shift=FALSE;
unsigned myname1[]={544,4088,544,544,16383,128,2032,1168,2032,1168,1168,2032,0,544,1040,2056};
unsigned myname2[]={32,4128,5116,8228,10238,28196,41980,9248,10488,9248,9212,10784,9248,10784,12799,8192};
unsigned Icon[]={0,4104,16380,8188,7192,6152,7200,8176,8176,7200,6152,7192,8188,16380,4104,0};
char *cMacro[]={"define",
"else",
"endif",
"if",
"ifdef",
"ifndef",
"include",
"undef"};
char *cKeyWord[]={"auto",
"break",
"case","char","const","continue",
"default","do","double",
"else","enum","extern",
"float","for",
"goto",
"if","int",
"long",
"register","return",
"short","signed","sizeof","static","struct","switch",
"typedef",
"union","unsigned",
"void","volatile",
"while"};
/* menu */
int imMain=4,imLen=144,iExitMenu;
int iCurMenu=0,isCurMenu=0;
int imMenu[4];
char cmMain[3][5]={"File","Edit","Help"};
char *cmMenu[]={"New Ctrl+N",
"Open... Ctrl+O",
"Save... Ctrl+D",
"Save as... Ctrl+A",
"-",
"Exit",
"|",
"Cut Ctrl+X",
"Copy Ctrl+C",
"Paste Ctrl+V",
"-",

"Option...",
"|",
"About... F1",
"|","||"};
/***************************** declaring the functions *******************/
void TextBox(int l,int t,int r,int b);
void MsgBox(int l,int t,int r,int b,char cMsg[81]);
void GetKey(int *ah,int *al);
void Delete();
void AllocMemFail();
void Cursor(int flag);
void Cursor2(int x,int y,int flag);
void FindKeyWord(int row,int col,char * string,int times,int refresh);
void Button(int x1,int y1,int x2,int y2,int icolor);
void CloseButton(int x1,int y1,int x2,int y2,int icolor);
void MinButton(int x1,int y1,int x2,int y2,int icolor);
void OpenWindow(int x1,int y1,int x2,int y2,int btnMin,int btnClose,char cTitle[20]);
int FileListBox(int l,int t,int r,int b,int isFocus,char * curpath,char * filename);
void ScollBar(int l,int t,int hei,int refresh,int currow,int maxline,int pagerow);
void Refresh();
void ChangeString();
int FindTab(int startcol,int endcol,char * string);
struct fileline * PointerMove(int n);
void RefreshText(int top,int bottom);
int SaveFile();
void OpenFile();
void NewFil

e();
void End();
void Move(int dir);
void Free();
void SetCol(char * string);
/*************************************************************************/
#include "G:\c\myeditor\file.c"
/********************************* Init_Color ****************************/
void Init_Color()
{
iBgColor=7;
iForeColor=1;
iTitleColor=10;
iTitleBgColor=0;
iConBtnColor=1;
iConBtnBgColor=7;
iTextBoxBgColor=13;
iTextBoxColor=0;
iScollBarColor=7;
KeyColor=9;
CommentColor=2;
}
/********************************* Init_Data ******************************/
void Init_Data()
{
int i,j;
/* color */
iMaxX=getmaxx();
iMaxY=getmaxy();
TabSize=4;
/* menu */
imMenu[0]=0,i=0,j=1;
while(strcmp(cmMenu[i],"||"))
{
if(!strcmp(cmMenu[i],"|"))
{
imMenu[j]=i+1;
j++;
}
i++;
}
gettime(&CurTime);
}
/**************************** Init_Graph **********************************/
void Init_Graph()
{
int gdriver=DETECT,gmode,errorcode;
initgraph(&gdriver, &gmode, "");
errorcode = graphresult();
if (errorcode != grOk) /* an error occurred */
{
printf("Graphics error: %s\n", grapherrormsg(errorcode));
printf("Press any key to halt:");
getch();
exit(1); /*terminate with an error code */
}
}
/************************** Set_Mode() *********************************/
void Set_Mode()
{
int i,colornum[]={61, 1};
int redvalue[ ] ={56,0};
int greenvalue[]={56,15};
int bluevalue[ ]={56,36};
for(i=0;i<2;i++)
{
outportb(0x3c8,colornum[i]);
outportb(0x3c9,redvalue[i]);
outportb(0x3c9,greenvalue[i]);
outportb(0x3c9,bluevalue[i]);
}
}
/******************************* Init ************************************/
void Init()
{
Init_Graph();
Init_Color();
Init_Data();
Set_Mode();
}
/***************************** GetKeyStatus ******************************/
unsigned char GetKeyStatus()
{
union REGS r;
r.h.ah=2;
int86(0x16,&r,&r);
return r.h.al;
}
/*************************** GetKey **************************************/
void GetKey(int *ah,int *al)
{
union REGS r;
r.h.ah=0;
int86(0x16,&r,&r);
*ah=r.h.ah;
*al=r.h.al;
}
/******************************** GetL **********************************/
int GetL(int icolor)
{
if(icolor==15) return 7;
return icolor<=7?icolor+8:15;
}
/******************************** Button ********************************/
void Button(int x1,int y1,int x2,int y2,int icolor)
{
int lightcolor;
lightcolor=GetL(icolor);
setfillstyle(SOLID_FILL,icolor);
setcolor(lightcolor);
bar3d(x1,y1,x2,y2,0,0);
}
/******************************** CloseButton ****************************/
void CloseButton(int x1,int y1,int x2,int y2,int icolor)
{
int i=3;
Button(x1,y1,x2,y2,icolor);
setcolor(iConBtnColor);
/* \ */
line(x1+i,y1+i,x2-i-1,y2-i+1);
line(x1+i+1,y1+i,x2-i,y2-i+1);
/* / */
line(x1+i,y2-i+1,x2-i-1,y1+i);
line(x1+i+1,y2-i+1,x2-i,y1+i);
}
/********************************* MinButton *********

*********************/
void MinButton(int x1,int y1,int x2,int y2,int icolor)
{
int i=4;
Button(x1,y1,x2,y2,icolor);
setcolor(iConBtnColor);
line(x1+i,y2-i+1,x2-i,y2-i+1);
line(x1+i,y2-i,x2-i,y2-i);
}
/********************************* Bar ***********************************/
void Bar(int l,int t,int r,int b,int icolor)
{
int lightcolor;
setfillstyle(SOLID_FILL,icolor);
lightcolor=GetL(icolor);
setcolor(lightcolor);
bar3d(l,t,r,b,0,0);
}
/********************************* SetPath *********************************/
void SetPath(char * fullpath,char * path,int len)
{
int i,j,l,filenamelen;
l=strlen(fullpath);
for(i=l-1;i>0;i--)
if(fullpath[i]==''\\'') break;
filenamelen=l-i;
for(j=i-1;j>0;j--)
if(fullpath[j]==''\\'' && j+filenamelen+3<=len-1)
{
for(l=0;l<=j;l++)
path[l]=fullpath[l];
path[l]=0;
strcat(path,"...");
for(l=j+4;fullpath[i];l++,i++)
path[l]=fullpath[i];
path[l]=0;
break;
}
}
/*********************************** StatusBar *****************************/
void StatusBar(int loc)
{
int t,b,i;
int pos[]={2,66,429,478,607,639};
char * cpos[]={"F1:Help","noname.c","00:00","Ln: 1 Col: 1 ","Ins"};
char c[3];
t=iBottom-19,b=iBottom-1;
settextjustify(0,1);
setcolor(iForeColor);
switch(loc)
{
case -1:
for(i=0;i<6;i++)
{
Bar(pos[i],t+1,pos[i+1]-2,b-1,iBgColor);
setcolor(iForeColor);
outtextxy(pos[i]+4,t+10,cpos[i]);
}
break;
case 1:
if(strlen(cFilePath)>44)
SetPath(cFilePath,cpos[loc],45);
else
{
for(i=0;i<31 && cFilePath[i];i++)
cpos[loc][i]=cFilePath[i];
cpos[loc][i]=0;
}
break;
case 2:
itoa(CurTime.ti_hour,c,10);
if(CurTime.ti_hour<10)
{
c[2]=0;
c[1]=c[0];
c[0]=''0'';
}
strcpy(cpos[loc],c);
strcat(cpos[loc],":");
itoa(CurTime.ti_min,c,10);
if(CurTime.ti_min<10)
{
c[2]=0;
c[1]=c[0];
c[0]=''0'';
}
strcat(cpos[loc],c);
break;
case 3:
setfillstyle(SOLID_FILL,iBgColor);
bar(pos[loc]+27,t+5,pos[loc]+64,t+14);
bar(pos[loc]+100,t+5,pos[loc]+122,t+14);
itoa(CurRow+1,cpos[0],10);
itoa(T_CurCol+1,cpos[1],10);
settextjustify(2,1);
outtextxy(pos[loc]+60,t+10,cpos[0]);
outtextxy(pos[loc]+124,t+10,cpos[1]);
settextjustify(0,1);
break;
case 4:
Key_Ins=Key_Ins*-1+1;
if(!Key_Ins)
setcolor(8);
break;
}
if(loc==2 || loc==4 || loc==1)
{
setfillstyle(SOLID_FILL,iBgColor);
bar(pos[loc]+1,t+2,pos[loc+1]-3,b-2);
outtextxy(pos[loc]+4,t+10,cpos[loc]);
}
}
/********************************* ScollBar ********************************/
void ScollBar(int l,int t,int hei,int refresh,int currow,int maxline,int pagerow)
{
int i,b=t+hei,curloc;
if(refresh==TRUE)
{
setfillstyle(SOLID_FILL,iBgColor);
bar(l,t,l+15,b);
/* button*/
Button(l+1,t+1,l+14,t+12,iBgColor);
setcolor(iForeColor);
for(i=1;i<5;i++)
line(l+8-i,t+4+i,l+7+i,t+4+i);
Button(l+1,b-12,l+14,b-1,iB

gColor);
setcolor(iForeColor);
for(i=1;i<5;i++)
line(l+3+i,b-9+i,l+12-i,b-9+i);
t+=13,b-=13;
hei-=26;
hei=hei/((maxline-1)/pagerow+1);
curloc=(currow-1)/pagerow+1;
Button(l+1,t+(curloc-1)*hei,l+14,t+curloc*hei,iScollBarColor);
}
}
/***************************** TextBox ***********************************/
void TextBox(int l,int t,int r,int b)
{
int lightcolor;
setfillstyle(SOLID_FILL,iTextBoxBgColor);
lightcolor=GetL(iTextBoxBgColor);
setcolor(lightcolor);
bar3d(l,t,r,b,0,0);
}
/******************************** MsgBox *********************************/
void MsgBox(int l,int t,int r,int b,char cMsg[81])
{
Button(l,t,r,b,iBgColor);
settextjustify(1,1);
setcolor(iForeColor);
outtextxy(l+(r-l)/2,t+(b-t)/2,cMsg);
}
/****************************** showchinese *****************************/
void showchinese(int x,int y,int color,unsigned point[],int size)
{
unsigned num,flag;
int i,j,c=color,row,col;
int colors[]={0,10,11,10,11,10,11,10,11,10,11,10,11,10,11,10,11};
for(i=0;i<16;i++)
{
num=point[i];
flag=0x8000u;
for(j=0;j<16;j++)
{
if(num>=flag && flag>0)
{
if(color<0) c=colors[i];
if(size==1)
putpixel(x+j,y+i,c);
else
for(row=1;row<=size;row++)
putpixel(x+j*size+row,y+i*size+row,c);
num-=flag;
}
flag/=2u;
}
}
}
/*********************************** OpenWindow ****************************/
void OpenWindow(int x1,int y1,int x2,int y2,int btnMin,int btnClose,char cTitle[20])
{
int bx=x2;
Button(x1,y1,x2,y2,iBgColor);
setfillstyle(SOLID_FILL,iTitleBgColor);
bar(x1+2,y1+2,x2-2,y1+17);
/* draw icon */
showchinese(x1+2,y1+2,-1,Icon,1);
/* control button */
if (btnClose)
{
CloseButton(x2-17,y1+4,x2-4,y1+15,iConBtnBgColor);
bx-=17;
}
if (btnMin)
{
MinButton(bx-17,y1+4,bx-4,y1+15,iConBtnBgColor);
bx-=17;
}
setcolor(iTitleColor);
settextjustify(1,1);
outtextxy(x1+(x2-x1)/2 ,y1+10,cTitle);
}
/******************************* FrmAbout *******************************/
void FrmAbout()
{
int l,r,t,b,x,y;
int ah,al;
l=iMaxX/2-110,r=iMaxX/2+110;
t=100,b=245;
OpenWindow(l,t,r,b,0,1,"About");
x=l+6,y=t+22;
showchinese(x-5,y+5,-1,Icon,3);
x+=51,y+=13;
settextjustify(0,1);
setcolor(iForeColor);
outtextxy(x,y,cAppName);
y+=20;
outtextxy(x,y,"Version:0.1 ");
y+=20;
outtextxy(x,y,"Author :");
showchinese(x+60,y-10,iForeColor,myname1,1);
showchinese(x+78,y-10,iForeColor,myname2,1);
y+=20;
outtextxy(x,y,"Copyright(c) 2005");
y+=15;
line(l+5,y,r-5,y);
y+=15;
outtextxy(l+15,y,"Email:Freewind22@https://www.doczj.com/doc/963752833.html,");
GetKey(&ah,&al);
RefreshText(t,b);
}
/******************************** Cursor2 ********************************/
void Cursor2(int x,int y,int flag)
{
int icolor=iTextBoxBgColor,isave;
isave=getcolor();
if(flag) icolor=iTextBoxColor;
setcolor(icolor);
line(x,y,x,y+12);
setcolor(isave);
}
/******************************* Sho

wMenu *******************************/
void ShowMenu(int refresh)
{
int x[4],y=36,i,j,lightcolor;
int l,t,r,b;
x[0]=6;
for (i=1;i<4;i++)
x[i]=x[i-1]+strlen(cmMain[i-1])*8+10;
if (refresh)
{
setfillstyle(SOLID_FILL,iTextBoxBgColor);
bar(ieLeft,ieTop-2,ieRight,ieTop+80);
setcolor(iBgColor);
line(ieLeft,ieTop-3,ieRight,ieTop-3);
for(i=0;i<3;i++)
rectangle(x[i],y-16,x[i+1]-5,y-2);
lightcolor=GetL(iTextBoxBgColor);
setcolor(lightcolor);
line(ieLeft,ieTop-2,ieRight,ieTop-2);
RefreshText(ieTop+3,ieTop+100);
}
lightcolor=GetL(iBgColor);
if (refresh && iCurMenu>-1)
{
i=iCurMenu;
l=x[i],t=y,r=x[i]+imLen+14,b=y+(imMenu[i+1]-imMenu[i]-1) * LINEHEI + 2;
Button(l,t,r,b,iBgColor);
setcolor(lightcolor);
rectangle(x[i],t-16,x[i+1]-5,t-2);
for (j=0;j{
if(!strcmp(cmMenu[imMenu[i]+j],"-"))
{
setcolor(10);
line(x[i]+7,y+10+j*LINEHEI,x[i]+imLen+7,y+10+j * LINEHEI);
}
else
{
setcolor(iForeColor);
settextjustify(0,1);
outtextxy(x[i]+7,y+10+j * LINEHEI,cmMenu[imMenu[i]+j]);
}
}/* end for */
}/* end if */
/* show curmenu */
if(iCurMenu>-1)
{
i=isCurMenu,j=iCurMenu;
setfillstyle(SOLID_FILL,iTitleBgColor);
setcolor(iTitleColor);
bar(x[j]+2,y+2+i*LINEHEI,x[j]+imLen+12,y+(i+1)*LINEHEI);
outtextxy(x[j]+7,y+10+i*LINEHEI,cmMenu[imMenu[j]+i]);
}
}
/******************************* HideMenu ********************************/
void HideMenu()
{
iCurMenu=-1;
isCurMenu=0;
ShowMenu(TRUE);
iExitMenu=TRUE;
}
/******************************* SelectMenu ******************************/
void SelectMenu()
{
int x[4],ah,al;
int y=36,i,j;
x[0]=6;
for (i=1;i<4;i++)
x[i]=x[i-1]+strlen(cmMain[i-1])*8+10;
iExitMenu=FALSE;
ShowMenu(TRUE);
settextjustify(0,1);
while (!iExitMenu)
{
GetKey(&ah,&al);
if (ah==1 && al==27) /* ESC */
{
HideMenu();
continue;
}
if (ah==75 && al==0) /* <- */
{
if (--iCurMenu<0) iCurMenu=2;
isCurMenu=0;
ShowMenu(TRUE);
continue;
}



if (ah==77 && al==0) /* -> */
{
if (++iCurMenu>2) iCurMenu=0;
isCurMenu=0;
ShowMenu(TRUE);
continue;
}
/* hide menu */
if((ah==72 && al==0) || (ah==80 && al==0))
{
i=isCurMenu,j=iCurMenu;
setfillstyle(SOLID_FILL,iBgColor);
setcolor(iForeColor);
bar(x[j]+2,y+2+i*LINEHEI,x[j]+imLen+12,y+(i+1)*LINEHEI);
outtextxy(x[j]+7,y+10+i*LINEHEI,cmMenu[imMenu[j]+i]);
}
/* */
if (ah==72 && al==0) /* Up */
{
isCurMenu--;
if (isCurMenu<0) isCurMenu=imMenu[iCurMenu+1]-imMenu[iCurMenu]-2;
if (!strcmp(cmMenu[imMenu[iCurMenu]+isCurMenu],"-")) isCurMenu--;
ShowMenu(FALSE);
}
if (ah==80 && al==0) /* Down */
{
isCurMenu++;
if (isCurMenu>imMenu[iCurMenu+1]-imMenu[iCurMenu]-2) isCurMenu=0;
if (!strcmp(cmMenu[imMenu[iCurMenu]+isCurMenu],"-")) isCurMenu++;
ShowMenu(FALSE);
}
if

(ah==28 && al==13) /* Enter */
{
i=isCurMenu;
j=iCurMenu;
HideMenu();
switch(j)
{
case 0:
switch(i)
{
case 0:
NewFile();
break;
case 1:
OpenFile();
break;
case 2:
SaveFile();
break;
case 5:
End();
break;
}
break;
case 2:
FrmAbout();
}/* end switch */
} /* end if */
}/* end while */
}
/********************************* AllocMemFail ************************************************************/
void AllocMemFail()
{
int i;
Free();
MsgBox(iMaxX/2-200,220,iMaxX/2+200,265,"Can''t allocate more memory.terminating.");
GetKey(&i,&i);
exit(1);
}
/********************************** Create ********************************/
struct fileline * Create(int c)
{
int len,i=0;
struct fileline * newline;
len=strlen(Line);
if(c<0) c=len;
if((newline=(struct fileline *)malloc(LEN))==NULL)
AllocMemFail();
newline->next=NULL;
if((newline->line=(char *)malloc(c+1))==NULL)
AllocMemFail();
while(i{
newline->line[i]=Line[i];
i++;
}
newline->line[i]=0;
return newline;
}
/*********************************** Insert *******************************/
void Insert(struct fileline * newline)
{
if(head==NULL) /* head */
{
head=newline;
head->prev=NULL;
end=newline;
}
else if(curline==end) /* end */
{
end->next=newline;
newline->prev=end;
end=newline;
}
else /* center */
{
newline->next=curline->next;
curline->next->prev=newline;

curline->next=newline;
newline->prev=curline;
}
curline=newline;
}
/************************************ Delete *****************************/
void Delete()
{
struct fileline * delline;
delline=curline;
if(delline==head) /* head */
{
curline=head->next;
curline->prev=NULL;
head=curline;
}else if(delline==end) /* end */
{
curline=end->prev;
curline->next=NULL;
end=curline;
}
else
{ /* center */
curline=curline->prev;
curline->next=delline->next;
delline->next->prev=curline;
}
free(delline->line);
free(delline);
}
/******************************* Free **********************************/
void Free()
{
/*int i=0;*/
while(head)
{
curline=head;
head=head->next;
/*setcolor(iTextBoxColor);
outtextxy(292,30+i*ROWHEI,":");
outtextxy(300,30 + i++ *ROWHEI,curline->line);*/
free(curline->line);
free(curline);
}
curline=NULL;
end=NULL;
/*outtextxy(300,30+i*ROWHEI,"TTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTT");
GetKey(&i,&i);*/
}



/****************************** PointerMove ****************************/
struct fileline * PointerMove(int n)
{
struct fileline * result=curline;
if(n<0)
{
n=-n;
while(n-- > 0 && result)
result=result->prev;
}
else
while(n-- > 0 && result)
result=result->next;
return result;
}
/********************************* ChangeString **************************/
void

ChangeString()
{
int len=strlen(Line);
free(curline->line);
if((curline->line=(char *)malloc(len+1))==NULL) AllocMemFail();
strcpy(curline->line,Line);
RowChanged=FALSE;
}
/****************************** Cursor *********************************/
void Cursor(int flag)
{
int icolor,isave,x,y;
x=ieLeft+(T_CurCol-CurColPage*INDENTCOL)*8-1;
y=ieTop+(CurRow-CurRowPage*INDENTROW)*ROWHEI;
isave=getcolor();
if(flag)
icolor=iTextBoxColor;
else
icolor=iTextBoxBgColor;
setcolor(icolor);
line(x,y,x,y+11);
if(flag-TRUE>0)
StatusBar(flag-TRUE);
setcolor(isave);
}
/********************************** GetTab ******************************/
int FindTab(int startcol,int endcol,char * string)
{
int i,result=0;
if(endcol>=startcol)
if(startcol>=0)
{
for(i=startcol;i<=endcol && string[i];i++)
if(string[i]==9) result++;
}
else
{
for(i=0;string[i]==9;i++)
result++;
}
return result;
}
/**************************** ShowString ********************************/
void ShowString(int r,int c,char * string,int refresh)
{
int x,y,i,j,n,len;
char ctemp[PAGECOL+1];
x=ieLeft+c*8;
y=ieTop+r*ROWHEI+2;
settextjustify(0,2);
setcolor(iTextBoxColor);
if((i=CurColPage*INDENTCOL)>0)
i=i-FindTab(0,i,string)*(TabSize-1);
len=strlen(string);
j=0;
while(j+c< PAGECOL && i{
if(string[i]==9)
{
for(n=0;nctemp[j]='' '';
j--;
}
else
ctemp[j]=string[i];
i++,j++;
}
ctemp[j]=0;
outtextxy(x,y,ctemp);
if(strlen(ctemp)>1 && refresh>=0 && CLanguage)
FindKeyWord(r,c,ctemp,PAGECOL,refresh);
else
FindComment(r,c,ctemp);
}
/**************************** ShowText **********************************/
void ShowText(int r,struct fileline * temp)
{
int a;
r-=CurRowPage*INDENTROW;
while(r < PAGEROW && temp)
{
/*if(CurRowPage==8)
{
printf("%d,",r);
GetKey(&a,&a);
if(temp->line==NULL) printf("NULL");
}*/
ShowString(r,0,temp->line,FALSE);
r++;
temp=temp->next;
/*if(temp->line==NULL) printf("NULL");*/
}
/*if(CurRowPage==8)
{
printf("END Show TEXT 8");
GetKey(&a,&a);
printf("GETKEYEND");
}*/
}
/***************************** Clear ************************************/
void Clear(int r,int c)
{
int x,y;
x=ieLeft+(c-CurColPage*INDENTCOL)*8;
y=ieTop+(r-CurRowPage*INDENTROW)*ROWHEI;
setfillstyle(SOLID_FILL,iTextBoxBgColor);
bar(x,y,iMaxX-19,y+ROWHEI-1);
}
/**************************** ClearBox *********************************/
void ClearBox(int startrow)
{
int y;
y=ieTop+startrow*ROWHEI;
setfillstyle(SOLID_FILL,iTextBoxBgColor);
bar(ieLeft,y,ieRight,ieBottom);
}
/****************************** RefreshText ****************************/
void RefreshText(int top,int bottom)
{
int startrow,endrow;
struct fileline * temp;
startrow=(top-ieTop-3)/ROWHEI;
endrow=(bottom-ieTop-3)/ROWHEI+1;
setfillstyle(SOLID_FILL,iTextBoxBgColor);
bar(ieLeft,

top,ieRight,bottom);
if(RowChanged) ChangeString();
temp=PointerMove(startrow-(CurRow-CurRowPage*INDENTROW));
while(startrow{
ShowString(startrow,0,temp->line,FALSE);
startrow++;
temp=temp->next;
}
}
/**************************** ChangePage *******************************/
void ChangePage(int dir)
{
struct fileline * temp;
int a;
if(dir==RIGHT || dir==LEFT || dir==UP || dir==DOWN)
ClearBox(0);
switch(dir)
{
case RIGHT:
CurColPage++;
temp=PointerMove(-(CurRow-CurRowPage*INDENTROW));
ShowText(CurRowPage*INDENTROW,temp);
break;
case LEFT:
CurColPage--;
temp=PointerMove(-(CurRow-CurRowPage*INDENTROW));
ShowText(CurRowPage*INDENTROW,temp);
break;
case UP:
CurRowPage--;
temp=PointerMove(-INDENTROW+1);
ShowText(CurRow-INDENTROW+1,temp);
ScollBar(iMaxX-18,iTop+38,iMaxY-22-iTop-37,TRUE,CurRow-1,TotalRow,INDENTROW);
break;
case DOWN:
CurRowPage++;
if(CurRowPage>MaxRowPage)
MaxRowPage=CurRowPage;
temp=PointerMove(-SubRow);
ShowText(CurRow-SubRow,temp);
ScollBar(iMaxX-18,iTop+38,iMaxY-22-iTop-37,TRUE,CurRow,TotalRow,INDENTROW);
break;
case PAGEUP:
if(CurRowPage==0)
return;
CurRowPage--;
Cursor(FALSE);
curline=PointerMove(-INDENTROW);
CurRow-=INDENTROW;
ClearBox(0);
ShowText(CurRowPage*INDENTROW,PointerMove(CurRowPage*INDENTROW-CurRow));
ScollBar(iMaxX-18,iTop+38,iMaxY-22-iTop-37,TRUE,CurRow,TotalRow,INDENTROW);
Cursor(TRUE+3);
break;
case PAGEDOWN:
if(CurRow+INDENTROW>TotalRow)
return;
CurRowPage++;
Cursor(FALSE);
curline=PointerMove(INDENTROW);
CurRow+=INDENTROW;
ClearBox(0);
/*if(CurRowPage==8)
{
printf("ShowText");
GetKey(&a,&a);
}*/
temp=PointerMove(CurRowPage*INDENTROW-CurRow);
ShowText(CurRowPage*INDENTROW,temp);
/*printf("%d^^",CurRowPage);
if(CurRowPage==8)
{
printf("ScollBar");
GetKey(&a,&a);
}*/
ScollBar(iMaxX-18,iTop+38,iMaxY-22-iTop-37,TRUE,CurRow+1,TotalRow,INDENTROW);
/*if(CurRowPage==8)
{
printf("Cursor");
GetKey(&a,&a);
}*/
Cursor(TRUE+3);
break;
}
}
/********************************* GetWord **************************************/
int GetWord(char * word,int * startcol,char * string)
{
int isMacro=-1;
int c,len,i;
c=*startcol;
while(c>=0 && (isalnum(string[c]) || string[c]==''_'') || string[c]==''\'''' || string[c]==''\"'')
c--;
if(c<0)
c=0;
else
c+=1;
*startcol=c;
for(i=c;i < c+32 && (isalnum(string[i]) || string[i]==''_''|| string[i]==''\'''' || string[i]==''\"'') ;i++)
word[i-c]=string[i];
word[i-c]=0;
i=c-1;
while(i>=0 && (string[i]==''#'' || string[i]=='' '' || string[i]==9))
{
if(string[i]==''#'')
if(isMacro<0)
isMacro=i;
else
break;
i--;
}
if(i>=0)
isMacro=-1;
return isMacro;
}
/********************************* FindComment **********************************/
int FindComment(int row,int col,char *

string)
{
char *str="/*",temp;
int i,j,x,y,len;
int result,startcol;
y=ieTop+row*ROWHEI+2;
len=strlen(string);
result=FALSE;
if(isComment)
{
startcol=col;
strcpy(str,"*/");
}
setcolor(CommentColor);
for(i=col;i{
if(string[i]==str[0] && string[i+1]==str[1]) /* found */
{
if(isComment) /* Right Comment */
{
temp=string[i+2];
string[i+2]=0;
outtextxy(ieLeft+startcol*8,y,&string[startcol]);
string[i+2]=temp;
isComment=FALSE;
strcpy(str,"/*");
i++;
}
else /* Left Comment */
{
for(j=i;j>=0;j--)
if(string[j]==''\'''' || string[j]==''\"'')
break;
if(j<0)
{
isComment=TRUE;
strcpy(str,"*/");
startcol=i;
i++;
}
}
} /* end if found */
} /* end for */
if(isComment){
outtextxy(ieLeft+startcol*8,y,&string[startcol]);
result=TRUE;
}
else
result=FALSE;
return result;
}
/********************************* FindKeyWord **********************************/
void FindKeyWord(int row,int col,char * string,int times,int refresh)
{
int isMacro,startcol,i,x,y,Found,len;
char word[33],word2[2]="#";
char ch;
startcol=col;
len=strlen(string);
if(len<=0)
return;
y=ieTop+row*ROWHEI+2;
settextjustify(0,2);
while(times--)
{
Found=FALSE;
memset(word,0,33);
isMacro=GetWord(word,&startcol,string);
if(!word ||startcol>=len || startcol+strlen(word)>PAGECOL)
break;
x=ieLeft+startcol*8;
ch=word[0];
if(isMacro<0) /* KeyWord */
{
for(i=0;i<32;i++)
{
if(cKeyWord[i][0]>ch) break;
if(cKeyWord[i][0]if(!strcmp(word,cKeyWord[i])) /* found */
{
Found=TRUE;
break;
}
}
}
else /* Macro */
{
for(i=0;i<8;i++)
{
if(cMacro[i][0]>ch) break;
if(cMacro[i][0]if(!strcmp(word,cMacro[i])) /* found */
{
Found=TRUE;
break;
}
}
}
if(Found) /* found */
{
setcolor(KeyColor);
outtextxy(x,y,word);
if(isMacro>=0)
outtextxy(ieLeft+isMacro*8,y,word2);
}
else if(refresh)
{
setcolor(iTextBoxColor);
outtextxy(x,y,word);
if(isMacro>=0)
outtextxy(ieLeft+isMacro*8,y,word2);
}
if(times)
startcol+=strlen(word)+1;
}
FindComment(row,col,string);
}
/**************************** InsertChar ***************************************************/
void InsertChar(char ch)
{
int len,i;
len=strlen(Line);
if(len>=MAXCOL) return;
Cursor(FALSE);
Clear(CurRow,T_CurCol);
if(CurCol < len && Key_Ins) /* insert center */
{
for(i=len;i>CurCol;i--)
Line[i]=Line[i-1];
Line[CurCol]=ch;
Line[len+1]=0;
}
else
{ /* insert last */
Line[CurCol]=ch;
if(CurCol==len) Line[CurCol+1]=0;
}
CurCol++;
if(ch==9)
T_CurCol+=TabSize;
else
T_CurCol++;
RowChanged=TRUE;
TextChanged=TRUE;
if(T_CurCol>PAGECOL+CurColPage*INDENTCOL)
{
Change

String();
ChangePage(RIGHT);
}else
ShowString(CurRow-CurRowPage*INDENTROW,0,Line,TRUE);
Cursor(TRUE+3);
}
/********************************* DelChar ********************************/
void DelChar()
{
int len,i;
if(CurRow<=0 && CurCol<=0)
return;
Cursor(FALSE);
len=strlen(Line);
if(CurCol>=1)
{
CurCol--;
if(Line[CurCol]==9)
T_CurCol-=TabSize;
else
T_CurCol--;
for(i=CurCol;iLine[i]=Line[i+1];
Line[i]=0;
Clear(CurRow,T_CurCol);
ShowString(CurRow-CurRowPage*INDENTROW,0,Line,TRUE);
}
else if(CurCol==0)
{
Delete();
CurCol=strlen(curline->line);
if(len>0)
{
for(i=len-1;i>=0;i--) /* be likely to overflow */
Line[i+CurCol]=Line[i];
for(i=0;iLine[i]=curline->line[i];
Line[len+CurCol]=0;
}
else
strcpy(Line,curline->line);
CurRow--;
TotalRow--;
T_CurCol=MAXCOL;
SetCol(Line);
ShowString(CurRow-CurRowPage*INDENTROW,0,Line,TRUE);
ClearBox(CurRow-CurRowPage*INDENTROW+1);
ShowText(CurRow+1,curline->next);
}
RowChanged=TRUE;
TextChanged=TRUE;
Cursor(TRUE+3);
}
/******************************* DeleteChar ******************************/
void DeleteChar()
{
int len;
len=strlen(Line);
if(CurRow==TotalRow && CurCol==len) return;
if(CurCol{
Move(RIGHT);
DelChar();
return;
}
}
/******************************** NewLine ********************************/
void NewLine()
{
int tab,len,i=0;
Cursor(FALSE);
i=0;
free(curline->line);
if((curline->line=(char *)malloc(CurCol+1))==NULL) AllocMemFail();
while(i{
curline->line[i]=Line[i];
i++;
}
curline->line[i]=0;
Clear(CurRow,CurCol);
ShowString(CurRow-CurRowPage*INDENTROW,0,curline->line,TRUE);
/* next line */
len=strlen(Line);
tab=FindTab(-1,-1,Line);
i=tab;
while(CurCol+i&n
bsp;{
Line[i]=Line[CurCol+i-tab];
i++;
}
memset(&Line[i],0,MAXCOL-i);
Insert(Create(-1));
if(CurColPage>0)
{
CurColPage=1;
ChangePage(LEFT);
}
if((CurRow+1)>=PAGEROW+CurRowPage*INDENTROW)
ChangePage(DOWN);
if(CurRow{
ClearBox(CurRow-CurRowPage*INDENTROW+1);
ShowText(CurRow+2,curline->next);
}
TotalRow++;
CurRow++;
if(tab>0)
{
T_CurCol=tab*TabSize;
CurCol=tab;
}
else
{
T_CurCol=0;
CurCol=0;
}
ShowString(CurRow-CurRowPage*INDENTROW,0,Line,TRUE);
/*printf("%s,%s,",curline->line,Line);*/
Cursor(TRUE+3);
}
/******************************** SetCol *********************************/
void SetCol(char * string)
{
int tcol=0,len,i;
len=strlen(string);
for(i=0;i{
if(string[i]==9)
if(tcol+TabSize>T_CurCol)
break;
else
tcol+=TabSize;
else
tcol++;
}
CurCol=i;
T_CurCol=tcol;
}
/******************************* Move ************************************/
void Move(int dir)
{
int len;
struct fileline * temp;
unsigned char keystatus;
len=strl

en(Line);
Cursor(FALSE);
/* keystatus=GetKeyStatus();
if((keystatus & 3) >0){ Press Shift Key
printf("%d",keystatus);
} */
switch(dir)
{
case LEFT:
if(CurCol==0 && CurRow>0)
{
T_CurCol=MAXCOL;
goto MoveUp;
}
if(CurCol>0)
{
CurCol--;
if(Line[CurCol]==9) T_CurCol-=TabSize; else T_CurCol--;
}
if(CurColPage>0 && T_CurCol==CurColPage*INDENTCOL) ChangePage(LEFT);
break;
case RIGHT:
if(CurCol==len && CurRow{
T_CurCol=0;
goto MoveDown;
}
if(CurCol{
if(Line[CurCol]==9) T_CurCol+=TabSize; else T_CurCol++;
CurCol++;
}
if(T_CurCol>PAGECOL+CurColPage*INDENTCOL) ChangePage(RIGHT);
break;
case UP:
MoveUp:
if(CurRow<=0) return;
if(RowChanged)
ChangeString();
memset(Line,0,MAXCOL);
curline=curline->prev;
strcpy(Line,curline->line);
CurRow--;
SetCol(Line);
/*len=strlen(Line);
if(CurCol>len) CurCol=len;
T_CurCol=FindTab(0,CurCol,Line)*(TabSize-1)+CurCol;*/
if(T_CurCol/INDENTCOL!=CurColPage && CurColPage>0)
{
CurColPage=T_CurCol/INDENTCOL+1;
ChangePage(LEFT);
}
if(CurRowPage>0 && (CurRow+1)==CurRowPage*INDENTROW)
ChangePage(UP);
break;
case DOWN:
MoveDown:
if(CurRow>=TotalRow) return;
if(RowChanged)
ChangeString();
memset(Line,0,MAXCOL);
curline=curline->next;
strcpy(Line,curline->line);
SetCol(Line);
CurRow++;
if(T_CurCol/INDENTCOL!=CurColPage && CurColPage>0)
{
CurColPage=T_CurCol/INDENTCOL+1;
ChangePage(LEFT);
}
if(CurRow>=PAGEROW+CurRowPage*INDENTROW)
{
ClearBox(0);
CurRowPage++;
temp=PointerMove(-SubRow-1);
ShowText(CurRow-SubRow-1,temp);
ScollBar(iMaxX-18,iTop+38,iMaxY-22-iTop-37,TRUE,CurRow,TotalRow,INDENTROW);
}
break;
case HOME:
CurCol=0,T_CurCol=0;
if(CurColPage>0)
{
CurColPage=1;
ChangePage(LEFT);
}
break;
case END:
T_CurCol=MAXCOL;
SetCol(Line);
if(T_CurCol>PAGECOL+CurColPage*INDENTCOL)
{
CurColPage=(T_CurCol-PAGECOL)/INDENTCOL;
ChangePage(RIGHT);
}
break;
case CTRLHOME:
if(RowChanged)
ChangeString();
CurRow=0,CurCol=0,T_CurCol=0,curline=head;
if(CurRowPage>0 || CurColPage>0)
{
CurRowPage=0,CurColPage=0;
ClearBox(0);
ShowText(0,curline);
}
break;
case CTRLEND:
if(RowChanged)
ChangeString();
CurRow=TotalRow,CurCol=0,T_CurCol=0,curline=end;
if(CurRow>(CurRowPage+1)*INDENTROW || CurColPage>0)
{
CurRowPage=CurRow/INDENTROW;
CurColPage=0;
ClearBox(0);
ShowText(CurRowPage*INDENTROW,PointerMove(CurRowPage*INDENTROW-CurRow));
}
break;
}
Cursor(TRUE+3);
}
/******************************** MsgSaveFile ****************************/
int MsgSaveFile()
{
int l,t,r,b,save=FALSE;
int ah,al;
l=iMaxX/2-130,t=iMaxY/2-30,r=l+260,b=t+60;
MsgBox(l,t,r,b,"File not saved. Save?(Y/N)");
while(TRUE)
{
GetKey(&ah,&al);
if(al==89 || al==121)
{
sav

e=TRUE;
break;
}
if(al==78 || al==110)
break;
if(ah==1 && al==27)
{
save=-1;
break;
}
}
RefreshText(t,b);
return save;
}
/******************************** SaveFile *******************************/
int SaveFile()
{
FILE * fp;
struct fileline * temp;
int result=TRUE,retval=FALSE;
if(strlen(cFilePath)>1)
strcpy(cFileName,cFilePath);
else
result=FrmGetFileName(SAVEFILE);
if(result==TRUE)
{
fp=fopen(cFileName,"w");
if(fp!=NULL)
{
if(RowChanged)
ChangeString();
temp=head;
while(temp)
{
fprintf(fp,"%s\n",temp->line);
temp=temp->next;
}
strcpy(cFilePath,cFileName);
TextChanged=FALSE;
StatusBar(1);
retval=TRUE;
fclose(fp);
}
else /* con''t open file */
;
}
return retval;
}
/******************************** OpenFile *******************************/
void OpenFile()
{
FILE * fp;
int ah,al;
int result,len;
if(TextChanged)
{
result=MsgSaveFile();
if(result<0) return;
else if(result)
{
result=SaveFile();
if(!result) return;
}
}
result=FrmGetFileName(OPENFILE);
if(result==TRUE)
{
fp=fopen(cFileName,"r");
if(fp!=NULL)
{
Cursor(FALSE);
Free();
TotalRow=0,CurRow=0,CurCol=0,T_CurCol=0;
while(fgets(Line,MAXCOL,fp))
{
len=strlen(Line);
Line[len-1]=0;
Insert(Create(-1));
TotalRow++;
}
Line[0]=0;
Insert(Create(-1));
curline=head;
memset(Line,0,MAXCOL);
strcpy(Line,head->line);
RowChanged=FALSE,TextChanged=FALSE;
CurRowPage=0,CurColPage=0;
ScollBar(iMaxX-18,iTop+38,iMaxY-22-iTop-37,TRUE,CurRow+1,TotalRow,INDENTROW);
Cursor(TRUE+3);
strcpy(cFilePath,cFileName);
ClearBox(0);
ShowText(0,curline);
StatusBar(1);
fclose(fp);
}
else /* con''t open file */
;
}
}
/******************************** NewFile ********************************/
void NewFile()
{
int save;
if(TextChanged)
{
save=MsgSaveFile();
if (save<0)
return;
else if(save)
{
save=SaveFile();
if(!save) return;
}
}
Cursor(FALSE);
Free();
memset(Line,0,MAXCOL);
Insert(Create(-1));
CurRowPage=0,CurColPage=0;
CurRow=0,CurCol=0,T_CurCol=0,TotalRow=0;
RowChanged=FALSE,TextChanged=FALSE;
ScollBar(iMaxX-18,iTop+38,iMaxY-22-iTop-37,TRUE,CurRow+1,TotalRow,INDENTROW);
cFilePath[0]=0;
ClearBox(0);
StatusBar(1);
Cursor(TRUE+3);
}
/******************************* Begin ***********************************/
void Begin()
{
int al,ah;
int iDelay=0,Flag=TRUE;
struct time t;
/* new line */
Insert(Create(-1));
while (TRUE)
{
while (!kbhit())
{
delay(lDelay);
iDelay++;
if(iDelay > 5)
{
iDelay=0;
Cursor(Flag);
Flag=Flag*-1+1;
gettime(&t);
if(t.ti_min!=CurTime.ti_min || t.ti_hour!=CurTime.ti_hour)
{

-


/> CurTime=t;
StatusBar(2);
}
}
}
GetKey(&ah,&al);
if (ah==

1 && al==27) break; /* ESC */
if (ah==59 && al==0) /* F1 */
FrmAbout();
if (ah==49 && al==14) /* Ctrl+N */
NewFile();
if (ah==32 && al==4) /* Ctrl+D */
SaveFile();
if (ah==24 && al==15) /* Ctrl+O */
OpenFile();
if (ah==33 && al==0) /* Alt+F */
{
iCurMenu=0;
SelectMenu();
}
if (ah==18 && al==0) /* Alt+E */
{
iCurMenu=1;
SelectMenu();
}
if (ah==35 && al==0) /* Alt+H */
{
iCurMenu=2;
SelectMenu();
}
/* control key */
if(ah==14 && al==8) /* backspace */
DelChar();
if(ah==75 && al==0) /* Left */
Move(LEFT);
if(ah==77 && al==0) /* Right */
Move(RIGHT);
if(ah==72 && al==0) /* Up */
Move(UP);
if(ah==80 && al==0) /* Down */
Move(DOWN);
if(ah==71 && al==0) /* Home */
Move(HOME);
if(ah==79 && al==0) /* End */
Move(END);
if(ah==73 && al==0) /* PageUp */
ChangePage(PAGEUP);
if(ah==81 && al==0) /* PageDown */
ChangePage(PAGEDOWN);
if(ah==119 && al==0) /* Ctrl+Home */
Move(CTRLHOME);
if(ah==117 && al==0) /* Ctrl+End */
Move(CTRLEND);
if(ah==82 && al==0) /* Insert */
StatusBar(4);
if(ah==83 && al==0) /* Delete */
DeleteChar();
if(ah==28 && al==13) /* Enter */
NewLine();
/* input char */
if(al>=32 && al<=126 || al==9) /* a--z A--Z 1--9 ''/[]{}...... */
InsertChar(al);
} /* end while */
}
/*********************************** End **********************************/
void End()
{
Free();
closegraph();
}
/********************************* FrmMain ********************************/
void FrmMain()
{
int imLeft,imTop;
int i;
imLeft=iLeft+10,imTop=iTop+27;
OpenWindow(iLeft,iTop,iRight,iBottom,1,1,cAppName);
settextjustify(0,1);
setcolor(iForeColor);
/* Show Menu */
for (i=0;i<3;i++)
{
if (i)
imLeft+=strlen(cmMain[i-1])*8;
outtextxy(imLeft+i*10,imTop,cmMain[i]);
line(imLeft+i*10,imTop+4,imLeft+i*10+6,imTop+4);
}
/* Text Box */
TextBox(2,imTop+10,iMaxX-2,iMaxY-20);
/* ScollBar */
ScollBar(iMaxX-18,iTop+38,iMaxY-22-iTop-37,TRUE,1,1,INDENTROW);
/* StatusBar */
StatusBar(-1);
StatusBar(2); /* Show Time */
}
/*********************************** Refresh ******************************/
void Refresh()
{
struct fileline * temp;
FrmMain();
temp=PointerMove(-(CurRow-CurRowPage*INDENTROW));
ShowText(0,temp);
}
/******************************** main ************************************/
void main()
{
/*int ah,al,i;
for(i=0;i<5;i++)
{
GetKey(&ah,&al);
printf("%d,%d. ",ah,al);
}*/
Init();
FrmMain();
Begin();
End();
}