RESPUESTA A LA PREGUNTA 1050 - C/VisualC
http://www.lawebdelprogramador.com


#include <stdio.h>
#include <conio.h>
#include <string.h>
#include <graphics.h>
#include <stdlib.h>
#include <dir.h>
#include <dos.h>
#include <alloc.h>
#include <sys\stat.h>
#include <time.h>
#define true 1
#define false 0

int pantalla_escrita=false; /* variable booleam que cuando
			      esta en 0 significa que no se ha
			      escrito nada en la pantallla y
			      cuando camnia a 1 ya esta escrita*/
int ARCHIVO_GUARDADO=false; /* variable que se utiliza para saber si se*/
			    /* ha abierto un archivo*/
int linea=0; /*se utiliza para que me imprima solo 17 lineas en la pantalla*/

int puntero_archivo=0;

int activar_guardar=false;
int activar_pegar=false;
int arriba,abajo,modifico_linea=false,enter=1,actualx,actualy,columna_pegar,fila_pegar,c;
long final_archivo,pegar_hora=false;
int linea1_editor=1,linea_llena=false;
char archivo_guardar[700][80]; /* es un vector de punteros que me contiene las
				direcciones de las cadenas del archivo*/

FILE *p;
struct lista {
       char nombre[25];
       int letra;
       int fondo;
       struct lista *antes, *siguiente;
  }*archivo,*editar,*listar,*cargar,*aux;

char nombre[50]; /* se utiliza para saber en que parte se encuentra el
		    archivo cuando se busca con el editor*/

void ventana_sombra (int yini, int xini, int yfin, int xfin, int color);
void desactiva_ventana_sombra (int yini, int xini, int yfin, int xfin, int color);
void ventana (int yini, int xini, int yfin, int xfin, int color);
void imprimir_menu(int num_menu);
char mostrar_sub_menu( int num_menu, int cant_menu);
char entrar_sub_menu (char *p);
void cuadro (int xini,int yini, int xfin, int yfin);
void cuadro_editor (int xini,int yini, int xfin, int yfin);
void nuevo_archivo(void);
void nombre_archivo(char *p);
void protextor_pantalla(void);
char editor (void);
int buscar_archivo(char *nomcomp);
void pegar_texto(int columna,int fila, int inicio, int fin);
void sombrear_texto(int inicio, int fin, int cursory, int cursorx);
void quitar_sombreado_texto(int inicio, int fin, int cursory, int cursorx);
void restaurar_linea_menu(int inicio, int final);
int guardar_archivo(char *nomcop);
void imprimir_propiedades_archivo(int columna, int fila, char *nombre);
void hora (void);

main (void)
{
  char tecla;

  archivo = malloc (sizeof(struct lista));
  strcpy(archivo->nombre, "ARCHIVO");
  archivo->letra= 0;
  archivo->fondo= LIGHTGRAY;

  editar = malloc(sizeof(struct lista));
  strcpy(editar->nombre,"EDICION");
  editar->letra=0;
  editar->fondo=LIGHTGRAY;

  cargar = malloc(sizeof(struct lista));
  strcpy(cargar->nombre, "CARGAR");
  cargar->letra= 0;
  cargar->fondo=LIGHTGRAY;

  archivo->antes = cargar;
  archivo->siguiente = editar;

  editar->antes = archivo;
  editar->siguiente = cargar;

  cargar->antes = editar;
  cargar->siguiente = archivo;

  listar=archivo;
  textmode (C80);
  textbackground(1);
  clrscr();

for (;;) {

   imprimir_menu(3); /* imprime el menu el cual posee 3 opciones*/
   tecla = editor();
   do {
     switch (tecla) {
     case '\x1E': listar->letra = 0;
		  listar->fondo=7;
		  listar = archivo;
		  listar->letra = 15;
		  listar->fondo = 0;
		  break;
     case '\x12': listar->letra=0;
		  listar->fondo=7;
		  listar=editar;
		  listar->letra=15;
		  listar->fondo=0;
		  break;
     case '\x0':  listar->letra=0;
                  listar->fondo=7;
		  listar=cargar ;
		  listar->letra=15;
		  listar->fondo=0;
		  break;
   }

     imprimir_menu(3);
     tecla = entrar_sub_menu(listar->nombre); /* imprime el sub menu
						 dependiendo de donde alla
						 quedado el apuntador*/
     if (tecla== '\x1B' || tecla=='\r') {
	listar->letra=0;
	listar->fondo=7;
     }
     switch (tecla) {
     case 'M' :
	       listar->letra = 0;
	       listar->fondo = 7;
	       listar = listar->siguiente;
	       listar->letra = 15;
	       listar->fondo = 0;
	       break;
     case 'K': listar->letra = 0;
	       listar->fondo = 7;
	       listar = listar->antes;
	       listar->letra = 15;
	       listar->fondo = 0;
	       break;
     }

   } while (tecla!='\x1B' && tecla!='\r');

}
}
/****************************EDITOR***********************************/
char editor (void)
{
 char tecla1;
 int x,i,j;
 static char cadena[150];

 if (pantalla_escrita==0) {
   nuevo_archivo();
   imprimir_propiedades_archivo(c,linea,nombre);
 }
 else {
   window(3,3,78,20);
   textcolor(14);
  textbackground(1);
  strnset(cadena,'',strlen(cadena));
  strcpy(cadena,archivo_guardar[linea]);
 }
 if (pantalla_escrita==0) gotoxy(1,1);
 else gotoxy(actualx,actualy);

 for (;;) {
   leer_letra:
   actualx=wherey();
   actualy=wherex();
   imprimir_propiedades_archivo(c,linea,nombre);
   gotoxy(actualy,actualx);
   tecla1 = getch();
   if (tecla1==0) {/* si la tecla es una tecla de funcion*/
       tecla1 = getch();
   if (tecla1=='.')   /* si la tecla de funcion se combierte en un punto se*/
       tecla1='\x0';  /* cambia su contenido para que no haya problemas con*/
		      /* el punto*/
   }
   /* para que la tecla pueda ser impresa tiene que ser diferente de la tecla de
      Esc='\x1B', espacio='\b', enter='\r', Ctrl+B='\x2', Ctrl+k='\v', Ctrl+P='\x10'*/
   else
   if (tecla1!='\x1B' && tecla1!='\b' && tecla1!='\r' && tecla1!='\x2' &&
	     tecla1!='\v' && tecla1!='\x10') {
	 putch(tecla1);
	 if (linea_llena==true)
	   modifico_linea=true;
	 else
	   modifico_linea=false;
	 activar_guardar=true;
	 cadena[c]=tecla1; /* se guarda cada una letra en el vector*/
	 c++; /* se incrementa la columna porque se escribio una letra*/
	 tecla1='<>'; /*cambia el contenido de la variable tecla*/
         pantalla_escrita=1;
   }
   switch (tecla1) {
       case '\x1E':
       case '\x12':
       case '\x0':actualx= wherex();
		  actualy= wherey();
		  return (tecla1);
       case 'M': if (wherex()<=strlen(archivo_guardar[linea])) {
		      c++;  /* se incrementa la columna porque se movio con las flechas*/
                      gotoxy(wherex()+1,wherey());
		 }
		 break;
       case 'K': if (wherex()!=1) {
		    c--;  /* se decrementa la columna porque se movio con la flecha*/
                    gotoxy(wherex()-1,wherey());
		 }
		 break;
      case '\r': gotoxy(1,wherey());putch('\n\r');
                 if (modifico_linea==true) {
		     cadena[c]='\n';
                     if (strcmp(cadena,archivo_guardar[linea])) {
			  memccpy(archivo_guardar[linea],cadena,'\n',90);
			  modifico_linea=false;
			  linea++;
                          strnset(cadena,'',strlen(cadena));
			  strcpy(cadena,archivo_guardar[linea]);
			  if (linea==enter) {
			     linea_llena=false;
			  }
			  goto leer_letra;
		      }
		  }
		   cadena[c]='\n';
		   memccpy(archivo_guardar[linea],cadena,'\n',90);
		   linea++;  /*se incrementa a uno la variable fila  para
			      que se pueda mover por la matriz para asignarle
			      la direccion de otra cadena cuando se escriba*/
		   if (ARCHIVO_GUARDADO && wherey()==enter)
			 enter++;
		   else
			 enter++;
		   strnset(cadena,'',strlen(cadena));
		   c=0;
		 break;
       case 'H': if (modifico_linea==true) {
		     cadena[c]='\n';
		       if (strcmp(cadena,archivo_guardar[linea])) {
			  memccpy(archivo_guardar[linea],cadena,'\n',80);
			  modifico_linea=false;
			  if (linea!=1)
			      linea--;
			  strnset(cadena,'',strlen(cadena));
			  strcpy(cadena,archivo_guardar[linea]);
                          gotoxy(wherex(), wherey()-1);
			  goto leer_letra;
		       }
		   }
		   if (linea1_editor>1 && wherey()==1 && linea!=1) {
			 linea1_editor--;
			 gotoxy(1,wherey());
			 insline();
			 gotoxy(1,wherey());
			 for (j=0,i=linea1_editor;archivo_guardar[i][j]!='\n'&&j<=73;j++) {
			   if (archivo_guardar[i][j]!='\n' && archivo_guardar[i][j]!='\x0')
			     if (archivo_guardar[i][j]=='\t')
				  putch('  ');
			     else
				  putch(archivo_guardar[i][j]);
			 }
			 putch('\n\r');
			 if (linea!=1) {
			   linea--;
			   strnset(cadena,'',strlen(cadena));
			   strcpy(cadena,archivo_guardar[linea]);
			   gotoxy(wherex(),wherey()-1);
			   goto leer_letra;
			 }
		   }
		   if (linea!=1) {
		      linea--;
		      strnset(cadena,'',strlen(cadena));
		      strcpy(cadena,archivo_guardar[linea]);
		      gotoxy(wherex(), wherey()-1);
		      linea_llena=true;
		   }
		   break;
       case 'P': if (linea<=enter) {
		   if (wherey()>=18) {
		       linea1_editor++;
		       gotoxy(1,wherey());putch('\n\r');
		       insline();
		       for (j=0,i=linea1_editor+17;archivo_guardar[i][j]!='\n' && j<=73;j++) {
			  if (archivo_guardar[i][j]!='\n' && archivo_guardar[i][j]!='\x0')
			    if (archivo_guardar[i][j]=='\r')
				putch('  ');
			    else
				putch(archivo_guardar[i][j]);
		       }
		       linea++;
                       strnset(cadena,'',strlen(cadena));
		       strcpy(cadena,archivo_guardar[linea]);
		       goto leer_letra;
		   }
		   if (modifico_linea==true) {
		     cadena[c]='\n';
                     if (strcmp(cadena,archivo_guardar[linea])) {
			  memccpy(archivo_guardar[linea],cadena,'\n',80);
                          strnset(cadena,'',strlen(cadena));
			  modifico_linea=false;
			     linea++;
			  strcpy(cadena,archivo_guardar[linea]);
			  gotoxy(wherex(),wherey()+1);
			  if (linea==enter) {
			     linea_llena=false;
			  }
			  goto leer_letra;
		       }
		   }
		    if (linea<enter) {
		       linea++;
		       strnset(cadena,'',strlen(cadena));
		       strcpy(cadena,archivo_guardar[linea]);
		       gotoxy(wherex(), wherey()+1);
		       linea_llena=true;
		    }
		    if (linea==enter) {
			linea_llena=false;
		    }
		 }
		 break;
       case '\b': if (wherex()==1) {
		       linea--;
                       strnset(cadena,'',strlen(cadena));
		       strcpy(cadena,archivo_guardar[linea]);
                       delline();
		       gotoxy(strlen(cadena),wherey()-1);
		       c=strlen(cadena)+1;
		  }
		  else {
		     gotoxy(wherex()-1, wherey()); printf(" ");
		     gotoxy(wherex()-1,wherey());
		     c--;
		     cadena[c]='';
		  }
		  break;
       case 'G': gotoxy(1, wherey()); /*tecla inicio*/
		 c=0;
		 break;
       case 'O': c=strlen(cadena); /*tecla fin*/
		 gotoxy(c,wherey());
		 cadena[c-1]=' ';
		 break;
       case '\v':  arriba=linea;
		   columna_pegar=wherex();
                   fila_pegar=wherey();
		   break;
       case '\x2': abajo=linea;
		   sombrear_texto(arriba,abajo,columna_pegar,fila_pegar);
		   activar_pegar=true;
		   break;
       case '\x10':if (activar_pegar) {
		     actualx=wherey();
		     actualy=wherex();
		     pegar_texto(actualy,actualx,arriba,abajo);
		     quitar_sombreado_texto(arriba, abajo, columna_pegar,fila_pegar);
		     gotoxy(actualy,actualx);
		     linea=actualx;
		     strnset(cadena,'',strlen(cadena));
		     strcpy(cadena,archivo_guardar[linea]);
		     activar_guardar=true;
		   }
		   break;
    }
 }
}

/***************************IMPRIMIR MENU*****************************/
void imprimir_menu (int num_menu)
{
 int n=2,i,color1,color2;

 ventana(1,1,80,1,LIGHTGRAY);
 clrscr();
 aux = archivo;
 for (i=1; i<=num_menu; i++) {
    color1 = aux->letra;
    color2 = aux->fondo;
    textcolor(color1);
    textbackground(color2);
    gotoxy(n,1); cprintf(aux->nombre);
    textcolor(RED);
    gotoxy(n,1); cprintf("%c",aux->nombre[0]);
    n+=10;
    aux=aux->siguiente;
 }
}

/***************************ENTRAR_SUB_MENU***************************/
char entrar_sub_menu (char *p)
{
 char opcion;
 int i,color1,color2;

 switch (p[0]) {
  case 'A': ventana_sombra(2,2,23,7,LIGHTGRAY);
	    cuadro (1,1,6,21);
	    ventana(3,3,21,6,LIGHTGRAY)	;
	    opcion = mostrar_sub_menu (1,4);
	    desactiva_ventana_sombra(2,2,23,8,1);
	    textcolor(15);
	    clreol();
	    gotoxy(1,1); printf("ÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ EDITOR");
	    if (pantalla_escrita==1)
		restaurar_linea_menu(linea1_editor,linea1_editor+17);
	    break;
  case 'E': ventana_sombra (12,2,38,4,LIGHTGRAY);
	    cuadro (1,1,3,27);
	    ventana(13,3,28,3,LIGHTGRAY);
	    opcion = mostrar_sub_menu (2,1);
	    if (opcion!='\n') {
	       desactiva_ventana_sombra(12,2,38,4,1);
	       textcolor(15);
	       clreol();
	       gotoxy(1,1); printf("ÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ EDITOR");
	       if (pantalla_escrita==1)
		    restaurar_linea_menu(linea1_editor,linea1_editor+5);
	    }
	    break;
  case 'C': ventana_sombra (21,2,40,5,LIGHTGRAY);
	    cuadro(1,1,4,20);
	    ventana(22,3,39,4,LIGHTGRAY);
	    opcion = mostrar_sub_menu (3,2);
	    desactiva_ventana_sombra(21,2,40,5,1);
            textcolor(15);
	    clreol();
	    gotoxy(1,1); printf("ÍÍÍÍÍÍÍÍÍÍÍÍÍ EDITOR ");
	    if (pantalla_escrita==1 || pegar_hora) {
		if (pegar_hora) {
		  hora();
		  pegar_hora=false;
		  pantalla_escrita=true;
		  activar_guardar=true;;
                  restaurar_linea_menu(linea1_editor,linea1_editor+5);
		  break;
		}
		restaurar_linea_menu(linea1_editor,linea1_editor+5);
	    }
 }
 return (opcion);
}

/***************************MOSTRAR_SUB_MENU**************************/
char mostrar_sub_menu (int num_menu, int cant_menu)
{
  struct lista *a_abrir,*a_crear,*a_guardar,*a_cerrar,*e_pegar,
	       *c_hora,*c_pro_pantalla;
  struct lista *aux3,*apuntador,*recorrer;
  int i,n;
  char opcion,resp;

  switch (num_menu) {
      case 1: /* Creando los submenu*/
	      a_abrir=malloc (sizeof(struct lista));
	      strcpy(a_abrir->nombre,"Abrir Archivo");
	      a_abrir->letra = 15;
	      a_abrir->fondo = 0;

	      a_crear=malloc (sizeof(struct lista));
	      strcpy(a_crear->nombre,"Nuevo Archivo");
	      a_crear->letra = 0;
	      a_crear->fondo = 7;

	      a_guardar=malloc (sizeof(struct lista));
	      strcpy(a_guardar->nombre,"Guardar Archivo");
	      if (activar_guardar==false) {
		 a_guardar->letra = 8;
	      }
	      else
		 a_guardar->letra = 0;
                 a_guardar->fondo = 7;

	      a_cerrar=malloc (sizeof(struct lista));
	      strcpy(a_cerrar->nombre,"Salir");
	      a_cerrar->letra = 0;
	      a_cerrar->fondo = 7;

	      /* Enlazando los submenu*/
	      a_abrir->antes= a_cerrar;
	      a_abrir->siguiente = a_crear;

	      a_crear->antes = a_abrir;
	      a_crear->siguiente = a_guardar;

	      a_guardar->antes = a_crear;
	      a_guardar->siguiente = a_cerrar;

	      a_cerrar->antes = a_guardar;
	      a_cerrar->siguiente = a_abrir;
	      apuntador = a_abrir;
	      recorrer = a_abrir;
	      break;

      case 2: /* Creando los submenu*/
	      e_pegar=malloc (sizeof(struct lista));
	      strcpy(e_pegar->nombre,"Pegar [Ctrl+P]");
	      if (activar_pegar==false) {
		 e_pegar->letra = 8;
	      }
	      else  {
		 e_pegar->letra = 15;
	      }
	      e_pegar->fondo = 7;

	      e_pegar->antes = e_pegar;
	      e_pegar->siguiente = e_pegar;
	      apuntador = e_pegar;
	      recorrer = e_pegar;
	      break;

      case 3: /* Creando los submenu*/
	      c_hora=malloc (sizeof(struct lista));
	      strcpy(c_hora->nombre,"Hora");
	      c_hora->letra = 15;
	      c_hora->fondo = 0;

	      c_pro_pantalla=malloc (sizeof(struct lista));
	      strcpy(c_pro_pantalla->nombre,"Montar Pantalla");
	      c_pro_pantalla->letra = 0;
	      c_pro_pantalla->fondo = 7;

	      /* Enlazando los submenu*/
	      c_hora->antes= c_pro_pantalla;
	      c_hora->siguiente = c_pro_pantalla;

	      c_pro_pantalla->antes = c_hora;
	      c_pro_pantalla->siguiente = c_hora;
	      apuntador = c_hora;
	      recorrer= c_hora;
	      break;
   }
do {
 n=1;
 textbackground(7);
 clrscr();
 aux3 = apuntador;
 for (i=1; i<=cant_menu; i++) {
    textcolor(aux3->letra);
    textbackground(aux3->fondo);
    gotoxy(2,n); cprintf(aux3->nombre);
    n++;
    aux3=aux3->siguiente;
 }
 opcion = getch();
 if (opcion ==0)
       opcion = getch();
 switch (opcion) {
     case 'P': if (strcmp(recorrer->nombre,"Pegar [Ctrl+P]")) {
		  recorrer->letra = 0;
		  recorrer->fondo = 7;
		  recorrer = recorrer->siguiente;
		  if (recorrer->letra==8) {
		    recorrer=recorrer->siguiente;
		  }
		   recorrer->letra = 15;
		   recorrer->fondo = 0;
	       } else {
                 if (recorrer->letra!=8) {
		   recorrer->letra=15;
		   recorrer->fondo=0;
		 }
	       }
	       break;
     case 'H': if (strcmp(recorrer->nombre,"Pegar [Ctrl+P]")) {
		 recorrer->letra = 0;
		 recorrer->fondo = 7;
		 recorrer = recorrer->antes;
                 if (recorrer->letra==8) {
		  recorrer=recorrer->antes;
		 }
		 recorrer->letra = 15;
		 recorrer->fondo = 0;
	       } else {
		 if (recorrer->letra!=8) {
		   recorrer->letra=15;
		   recorrer->fondo=0;
		 }
	       }
	       break;
}
} while (opcion!='\r' && opcion!='M' && opcion!='K' && opcion!='\x1B' &&
	 opcion!='\x1E' && opcion!='\x12' && opcion!='.') ;
 /* \x1B, es el codigo que representa a la tecla escape*/

  if (opcion=='\r') {
     switch(recorrer->nombre[0]) {
	  case 'N': if (activar_guardar) {
			ventana(5,5,60,7,LIGHTGRAY);
			cuadro(1,1,3,56);
			textcolor(0);
			gotoxy(20,1);cprintf("GUARDAR ARCHVO");
			gotoxy(2,2); cprintf("Guardar los Cambios hechos en %s (S/N): ",nombre);
			do {
			  resp =getch();
			} while (resp!='s' && resp!='S' && resp!='n' && resp!='N');
			if ((resp=='s' || resp=='S') && ARCHIVO_GUARDADO) {
                            guardar_archivo(nombre);
			} else if(resp=='s' || resp=='S') {
				  nombre_archivo("GUARDAR ARCHIVO");
				  strcpy(nombre,"Archivo1");
				}
		     }
		    nuevo_archivo();
		    break;
	  case 'A': if (activar_guardar) {
			ventana(5,5,60,7,LIGHTGRAY);
			cuadro(1,1,3,56);
			textcolor(0);
			gotoxy(20,1);cprintf("GUARDAR ARCHVO");
			gotoxy(2,2); cprintf("Guardar los Cambios hechos en %s (S/N): ",nombre);
			do {
			  resp =getch();
			} while (resp!='s' && resp!='S' && resp!='n' && resp!='N');
			if ((resp=='s' || resp=='S') && ARCHIVO_GUARDADO) {
                            guardar_archivo(nombre);
			    strcpy(nombre,"Archivo1");
			} else if(resp=='s' || resp=='S') {
				  nombre_archivo("GUARDAR ARCHIVO");
				  strcpy(nombre,"Archivo1");
				}
		     }
		    nombre_archivo("ABRIR ARCHIVO");
		    break;
	  case 'G': if (guardar_archivo && strcmp(nombre,"Archivo1"))
			guardar_archivo(nombre);
		    else
			nombre_archivo("GUARDAR ARCHIVO");
		    break;
	  case 'S': exit(0);
		    break;
	  case 'P': desactiva_ventana_sombra(16,2,40,5,1);
		    textcolor(15);
		    gotoxy(1,1); printf("ÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ EDITOR");
		    restaurar_linea_menu(linea1_editor,4);
                    pegar_texto(actualy,actualx,arriba,abajo);
		    quitar_sombreado_texto(arriba, abajo, columna_pegar,fila_pegar);
		    gotoxy(actualy,actualx);
		    activar_pegar=false;
		    break;
	  case 'H': pegar_hora=true;
		    break;
	  case 'M': protextor_pantalla();
		     break;
     }
  }
 return (opcion);
}

/***************************RESTAURAR_LINEA_MENU**********************/
void restaurar_linea_menu(int inicio, int final)
{
 register int j,i;
 textcolor(14);
 textbackground(1);
 window(3,3,78,20);
 clreol();
 i=inicio;
 while (i<=final) {
   for (j=0;archivo_guardar[i][j]!='\n'&&j<=73;j++) {
	if (archivo_guardar[i][j]=='\t')
	     putch(' ');
	else {
	 putch(archivo_guardar[i][j]);
	}
         if (archivo_guardar[i][j]=='\x0')
	     goto salir;
   }
   i++;
   if (i<=final)
      gotoxy(1,wherey()+1);
 }
 salir:;
}
/***************************SOMBREAR_TEXTO********************************/
void sombrear_texto(int inicio, int fin,int cursory,int cursorx)
{
 int i,j;
 gotoxy(cursory,cursorx);
 textcolor(1);
 textbackground(LIGHTGRAY);
 i=inicio;
 while (i<=fin) {
    for (j=0;archivo_guardar[i][j]!='\n' && j<=73;j++) {
       if (archivo_guardar[i][j]!='\n' && archivo_guardar[i][j]!='\x0')
	  putch(archivo_guardar[i][j]);
     }
     putch('\n\r');
     gotoxy(1,wherey());
     i++;
 }
 gotoxy(strlen(archivo_guardar[i-1]),wherey()-1);
 textcolor(14);
 textbackground(1);
}

/***************************QUITAR_SOMBREADO_TEXTO********************************/
void quitar_sombreado_texto(int inicio, int fin, int cursory, int cursorx)
{
  int i,j;
 gotoxy(cursory,cursorx);
 textcolor(14);
 textbackground(1);
 i=inicio;
 while (i<=fin) {
    for (j=0;archivo_guardar[i][j]!='\n' && j<=73;j++) {
       if (archivo_guardar[i][j]!='\n' && archivo_guardar[i][j]!='\x0')
	  putch(archivo_guardar[i][j]);
     }
     putch('\n\r');
     gotoxy(1,wherey());
     i++;
 }
}

/***************************PEGAR_TEXTO********************************/
void pegar_texto(int columna,int fila, int inicio, int fin) {
int i,j;

 gotoxy(columna,fila);
 i=inicio;
 while (i<=fin) {
    for (j=0;archivo_guardar[i][j]!='\n' && j<=73;j++) {
       if (archivo_guardar[i][j]!='\n' && archivo_guardar[i][j]!='\x0')
	  putch(archivo_guardar[i][j]);
     }
     memccpy(archivo_guardar[linea],archivo_guardar[i],'\n',90);
     linea++;
     enter++;
     putch('\n\r');
     gotoxy(1,wherey());
     i++;
 }
 linea--;
 enter--;
 gotoxy(strlen(archivo_guardar[i-1]),wherey()-1);
}

/***************************VENTANA_SOMBRA*****************************/
void ventana_sombra (int yini,int xini,int yfin,int xfin,int color)
{
  window (yini+1,xini+1,yfin+1,xfin+1);
  textbackground(0);
  clrscr();
  window (yini,xini,yfin,xfin);
  textbackground(color);
  clrscr();
}

/***************************DESACTIVA_VENTANA_SOMBRA***********************/
void desactiva_ventana_sombra (int yini,int xini,int yfin,int xfin,int color)
{
  window (yini+1,xini+1,yfin+1,xfin+1);
  textbackground(1);
  clrscr();
  window (yini,xini,yfin,xfin);
  textbackground(color);
  clrscr();
}

/***************************VENTANA************************************/
void ventana (int yini,int xini,int yfin,int xfin,int color)
{
  window (yini,xini,yfin,xfin);
  textbackground(color);
  clrscr();
}
/***************************CUADRO_EDITOR*****************************/
void cuadro_editor (int xini,int yini, int xfin, int yfin)
{
 int i;

 textcolor (15);
 highvideo();
 clrscr();
 for (i=xini; i<=yfin; i++)  {
    gotoxy(i,xini); printf("Í");
    gotoxy(i,xfin); printf("Í");
 }

 for (i=yini; i<xfin; i++)  {
    gotoxy(yini,i); printf("º");
    gotoxy(yfin,i); printf("º");
 }
 gotoxy(xini,yini); printf("É");
 gotoxy(yfin,xini); printf("»");
 gotoxy(yini,xfin); printf("È");
 gotoxy(yfin,xfin); printf("?");

 for (i=xini;i<=yfin; i++)  {
    gotoxy(i,xfin-3); printf("Í");
 }
 gotoxy(xini,xfin-3); printf("Ì");
 gotoxy(yfin,xfin-3); printf("¹");

}
/***************************CUADRO***************************************/
void cuadro (int xini,int yini, int xfin, int yfin)
{
 int i;
 textcolor (RED);
 clrscr();
 for (i=xini; i<=yfin; i++)  {
    gotoxy(i,xini); printf("Ä");
    gotoxy(i,xfin); printf("Ä");
 }

 for (i=yini; i<xfin; i++)  {
    gotoxy(yini,i); printf("³");
    gotoxy(yfin,i); printf("³");
 }
 gotoxy(xini,yini); printf("Ú");
 gotoxy(yfin,xini); printf("¿");
 gotoxy(yini,xfin); printf("À");
 gotoxy(yfin,xfin); printf("Ù");

}
/***************************NUEVO_ARCHIVO********************************/
void nuevo_archivo (void)
{
  static int i=1;
  int h;
  char resp;

  textbackground(1);
  window(1,2,80,24);
  if (i==1) {
     cuadro_editor(1,1,23,79);
     i++;
  }
  window(3,3,78,20);
  textcolor(14);
  textbackground(1);
  clrscr();
  pantalla_escrita= 0;
  puntero_archivo=0;
  ARCHIVO_GUARDADO=0;
  activar_guardar=false;
  activar_pegar=false;
  linea1_editor=1;
  enter=1;
  modifico_linea=false;
  linea_llena=false;
  strnset(nombre,'',strlen(nombre));
  strcpy(nombre,"Archivo1");
  c=0;
  delay(65535);
  ARCHIVO_GUARDADO=false;
    for (h=0; h<19; h++) {
       strnset(archivo_guardar[h],'',strlen(archivo_guardar[h]));
    }
  imprimir_propiedades_archivo(c,linea,nombre);
  linea=1;
}

/***************************NOMBRE_ARCHIVO*******************************/
void nombre_archivo (char *p)
{
 char tecla2,aux_nombre[50];

 int longitud=0,c=1,i,encontrado=false;

do {
 ventana_sombra(10,7,70,11,7);
 cuadro(1,1,5,60);
 textcolor(0);
 clreol();
 gotoxy(25,1); cprintf(p);
 gotoxy(3,3); cprintf("Direccion: ");
 ventana(22,9,58,9,3);
 /* borro el contenido del vector nombre, para que se pueda abrir
     correctamente el nuevo archivo, si el usuario lo desea*/
 strnset(aux_nombre,'',strlen(aux_nombre));

 do {
    gotoxy(c,1);tecla2=getch();
    if (tecla2=='\x1B') {
      goto salir;
    }
    if (tecla2==0 || tecla2=='\b') {
	 if (tecla2!='\b')
	    tecla2= getch();
       switch (tecla2) {
	 case 'M': if (wherex()<=longitud) {
		       gotoxy(wherex()+1,1);
		       c++;
		       longitud++;
		   }
		   break;
	 case 'K': gotoxy(wherex()-1,1);
		   c--;
		   break;
	 case '\b': gotoxy(wherex()-1, wherey()); printf(" ");
		    gotoxy(wherex()-1,wherey());
		      if (wherex()<=longitud) {
			 longitud--;
			 c--;
		      }
		    break;
	 case 'G': gotoxy(1, wherey()); /*tecla inicio*/
		   c=1;
		   break;
	 case 'O': gotoxy(longitud+1,wherey()); /*tecla fin*/
		   c=longitud+1;
		   break;
       }
    } else {
	gotoxy(c,1);putch(tecla2);
	aux_nombre[c-1]=tecla2;
	longitud++;
	c++;
      }
 } while (tecla2!='\r');
  aux_nombre[longitud-1] = ' ';
  /* borro el contenido del vector nombre, para que se pueda abrir
     correctamente el nuevo archivo, si el usuario lo desea*/
  strnset(nombre,'',strlen(nombre));

 switch (tecla2) {
   case '\x1B': desactiva_ventana_sombra(10,7,70,19,1);
		break;
   case '\r':   if (p[0]=='A') {
		  ARCHIVO_GUARDADO=false;
		  encontrado=buscar_archivo (aux_nombre);
		} else {
		  ARCHIVO_GUARDADO=false;
		  encontrado=guardar_archivo(aux_nombre);
		}
		break;
 }
  if (encontrado)
    strcpy(nombre,aux_nombre);
} while(encontrado==false);
 salir:
    imprimir_propiedades_archivo(c+1,linea,nombre);
    desactiva_ventana_sombra(10,7,70,11,1);
}

/***************************BUSCAR_ARCHIVO*******************************/
int buscar_archivo(char *nomcop)
{
 char cadena[150];

 int i;

 if ((p=fopen(nomcop,"r"))==NULL) {
    ventana(10,7,70,11,LIGHTGRAY);
    cuadro(1,1,5,60);
    textcolor(RED);
    gotoxy(20,1); cprintf("ERROR AL ABRIR EL ARCHIVO");
    gotoxy(3,3); cprintf("No se Puede Abrir el Archivo, Asegurece que exista");
    getch();
    return false;
 }
 else {
   final_archivo=fileno(p);
   final_archivo=filelength(final_archivo);
   nuevo_archivo();
   enter=0;
   ARCHIVO_GUARDADO=true;
   textbackground(1);
   window(1,2,80,24);
   cuadro_editor (1,1,23,79);
   gotoxy(34,1); printf(" EDITOR ");
   window(3,3,78,20);
   textcolor(14);
   textbackground(1);
   do {
     enter++;
     fgets(archivo_guardar[enter],80,p);
    } while (archivo_guardar[enter][0]!='\x0' && ftell(p)<=final_archivo);
 }
 linea=1;
 enter--;
 linea1_editor = 1;
 fclose(p);
 pantalla_escrita=1;
 return true;
}

/***************************GUARDAR_ARCHIVO******************************/
int guardar_archivo(char *nomcop)
{
 int f=1;

 if ((p=fopen(nomcop,"w"))==NULL) {
    ventana(10,7,70,11,LIGHTGRAY);
    textcolor(14);
    gotoxy(20,1); cprintf("ERROR AL ABRIR EL ARCHIVO");
    gotoxy(3,3); cprintf("No se Puede Guardar Archivo, Asegurece que la Ruta este bien");
    getch();
    return false;
 } else {
    activar_guardar=false;
    ARCHIVO_GUARDADO=true;
    do {
     fprintf(p,"%s",archivo_guardar[f]);
     if (f==linea)
	break;
     f++;
    } while (archivo_guardar[f][0]!='\x0');
     fclose(p);
     imprimir_propiedades_archivo(c+1,linea,nombre);
     return true;
 }

}

/***************************IMPRIMIR_PROPIEDAES_ARCHIVO***************************/
void imprimir_propiedades_archivo(int columna, int fila, char *nombre)
{
 struct stat propiedades_archivo;

 window(2,22,78,23);
 gotoxy(1,1); printf("  COLM       FILA                       NOMBRE ARCHIVO");
 gotoxy(1,2);insline();
 gotoxy(1,2); printf("    %d        %d                            %s",columna+1,fila,nombre);
 window(3,3,78,20);
}

/***************************PROTEXTOR_PANTALLA***************************/
void protextor_pantalla(void)
{
 int controlador = DETECT,modo=VGALO;
 int yini,xini,yfin,xfin,i;

 initgraph(&controlador,&modo,"");
 textbackground(0);
 do {
    textcolor(random(15));
    randomize();
    yini=random(640);
    xini=random(640);
    yfin=random(640);
    xfin=random(640);

    textcolor(random(15));
    rectangle(yini,xini,yfin,xfin);

    textcolor(random(15));
    rectangle(xini,yini,xfin,yfin);

    for (i=0; i<9999; i++);

 } while (!kbhit());

 closegraph();
 pantalla_escrita=0;
}

void hora (void)
{
 time_t t;
 char *p;

 t= time(NULL);
 window(3,3,78,20);
 p=ctime(&t);
 strcpy(archivo_guardar[linea],p);
}

Benjamin chavez
bfchub@gmail.com