É um script simples que eu fiz como trabalho para a matéria LTP1.

Faz o cadastro de cursos e de alunos, organizando-os por ordem alfabética usando busca binária ou quicksort caso o índice de ordenação seja perdido!!

Possui alguns probleminhas que eu não consegui resolver, como a tecla backspace que não funciona (não sei porque!!)

Para compilar use: gcc "arquivo.c" -o "nome_desejado" -lncurses, a biblioteca ncurses é necessária!!

• Download trab
• Enviar nova versão

Esconder código-fonte

/*Autor: Hudson Orsine Assumpção*/
/*Data: 21/09/2006*/
/*Linguagem: C (padrão linux)*/
/*Função: Este programa tem a finalidade de gerenciar um banco de dados simples, através de inserção, alteração,*/
/*remoção, pesquisa e listagem dos cadastros existentes de alunos e de cursos. Cada aluno deve pertencer a apenas*/
/* um curso e um curso pode possuir vários alunos, o que consiste em uma relação 1:N*/
#include <stdio.h>  /*Declaração das bibliotecas usadas nesse programa*/
#include <stdlib.h>
#include <curses.h>
                  /*Definição de palavras com valores constantes que tornam mais fácil a compreensão do código*/
#define ENTER 10       
#define ESCAPE 27
#define NACHOU 1
#define JAEXISTE 2
#define SONUM 3
#define EXCLUI 4
#define EXCLUIDO 5
#define NEXCLUIDO 6
#define SUCESSO 7
#define NCURSO 8
#define APAGUE 9
#define ALTERACAO 11

struct nascimento{  /*Registro responsável pela data de nascimento, contendo 3 campos inteiros.*/
  int dia[2],mes[2],ano[4];
};

struct endereco{   /*Registro responsável pelo endereço completo do aluno.*/
   char rua[50],bairro[30],cidade[20],cep[8],estado[3],numero[5];
};

struct dados{     /*Registro responsável pelos demais dados do aluno, nota-se que os dois registros anteriores*/
   char nome[50],identidade[13],curso[25];  /*estão presente nesse registro maior.*/
   struct nascimento datanasc;   
   struct endereco end;      
   char cpf[12];
   short int status;
};

struct dados_curso{ /*Registro responsável pelos dados do curso*/
   unsigned short int codigo[6];
   unsigned short int status;
   char nome[25],dep[50],coord[50],quantp[3],predio[3];
};

struct ord{   /*Registro usado no vetor de ordenação de alunos*/
   int pos_aluno,pos_cur;
};

void carrega_vetor(int tipo);              /*Declaração das funções usadas neste programa*/ 
void salva_vetor(void);
int busca_binaria(int tamanho,char dado[50],int tipo);
int pega_string (WINDOW *campo,char *string,int tam);
void pega_data_nas (WINDOW **campo,int *dia,int *mes,int *ano);
void pega_codigo(WINDOW **campo,unsigned short int codigo[]);
int pega_cpf (WINDOW **campo,char *cpf);
void exibe_cpf(WINDOW *campo,char cpf[]);
int cadastra_aluno(WINDOW **screen,struct ord *aux2);
int cadastra_curso(WINDOW **screen,int *aux2);
void abre(void);
int pesquisa_cpf(char *valor);
int altera_aluno(WINDOW **screen,struct ord *aux2);
int altera_curso(WINDOW **screen,int *aux2);
int exclui_aluno(WINDOW **screen,struct ord *aux2);
int exclui_curso(WINDOW **screen,int *aux2);
void lista_aluno(WINDOW *campos);
int lista_aluno_curso (WINDOW *campos);
void lista_curso(WINDOW *campos);
void criabarrasuperior(WINDOW *barrasup);
WINDOW **menuf2(WINDOW **opcoes);
WINDOW **menuf1(WINDOW **opcoes);
void deleta_tela(WINDOW **espacos);
void deleta_menu(WINDOW **opcoes,int cont);
void ativa_ncurses(void);
int scroll_menu_f1(WINDOW **items,WINDOW *mensagem);
int scroll_menu_f2(WINDOW **items,WINDOW *mensagem);
WINDOW **tela_aluno(WINDOW **campos);
WINDOW **tela_curso(WINDOW **campos);
WINDOW *tela_lista (WINDOW *itens);
WINDOW **tela_pesquisa (WINDOW **campos);
void tela_erro(WINDOW *erro,int mensagem);

struct ord vet_alunos[1024];  /*Declaração do vetor de ordenação de alunos*/
int pos=-1,poscur=-1,vet_cursos[1024];  /*As duas primeiras variáveis guarda a posição do vetor da última entrada*/
FILE *alunos,*cursos,*ordem_alunos,*ordem_cursos; /*vet_curso é o vetor de ordenação dos cursos*/
/*Acima a declaração dos ponteiros de arquivos usados neste programa*/

void carrega_vetor(int tipo){    /*Função responsável por carregar os vetores de ordenação*/
   if (tipo==0){
      int cont;
      if ((ordem_alunos=fopen("ordem_alunos.bvq","rb+"))==NULL){
         for (cont=0;cont<=1023;cont++){
            vet_alunos[cont].pos_aluno=-1;
            vet_alunos[cont].pos_cur=-1;
         }
      }
      else{
         rewind(ordem_alunos);         
         for (cont=0;cont<=1023;cont++)
            fread(&vet_alunos[cont],sizeof(vet_alunos[0]),1,ordem_alunos);
      }
   }
   else{
      int cont;
      if ((ordem_cursos=fopen("ordem_cursos.bvq","rb+"))==NULL){         
         for (cont=0;cont<=1023;cont++)
            vet_cursos[cont]=-1;         
      }
      else{
         rewind(ordem_cursos);
         cont=0;
         while (!feof(ordem_cursos)){
            fread(&vet_cursos[cont],sizeof(int),1,ordem_cursos);
            cont++;
         }
      }
   }
}

void salva_vetor(void){  /*Função responsável por salvar os vetores de ordenação em arquivos*/
   int cont;
   if ((ordem_alunos=fopen("ordem_alunos.bvq","wb"))==NULL){
      printf("impossível criar arquivo de ordenação para alunos!!");
      exit(1);
   }
   else{
      for (cont=0;cont<=1023;cont++)
         fwrite(&vet_alunos[cont],sizeof(vet_alunos[0]),1,ordem_alunos);
   }
   fclose(ordem_alunos);
   if ((ordem_cursos=fopen("ordem_cursos.bvq","wb"))==NULL){
      printf("impossível criar arquivo de ordenação para cursos!!");
      exit(1);
   }
   else{
      for (cont=0;cont<=1023;cont++)
         fwrite(&vet_cursos[cont],sizeof(int),1,ordem_cursos);
   }
   fclose(ordem_cursos);
}   

   
int busca_binaria(int tamanho,char dado[50],int tipo){ /*Função responsável por realizar as buscas binárias nos*/
   if (!tipo){                                         /*dois vetores, dependendo do valor passado em tipo*/
      struct dados aux;
      int inicio=0,fim=tamanho,meio;
      while (inicio<=fim){
         meio=(inicio+fim)/2;
         fseek(alunos,vet_alunos[meio].pos_aluno*sizeof(aux),SEEK_SET);
         fread(&aux,sizeof(aux),1,alunos);
         if (strcmp(dado,aux.nome)==0)
            return(meio);
         else
            if (strcmp(dado,aux.nome)>0)
               inicio=meio+1;
            else
               fim=meio-1;
      }
      if (strcmp(dado,aux.nome)>0)
         return(meio+1);
      else
         return(meio);
   }
   else{
      struct dados_curso aux;
      int inicio=0,fim=tamanho,meio;
      while (inicio<=fim){
         meio=(inicio+fim)/2;         
         fseek(cursos,vet_cursos[meio]*sizeof(aux),SEEK_SET);
         fread(&aux,sizeof(aux),1,cursos);
         if (strcmp(dado,aux.nome)==0)
            return(meio);
         else
            if (strcmp(dado,aux.nome)>0)
               inicio=meio+1;
         else
            fim=meio-1;
      }
      if (strcmp(dado,aux.nome)>0)
         return(meio+1);
      else
         return(meio);
   }
}      
   
int pega_string (WINDOW *campo,char *string,int tam){ /*Esse função é responsável por ler as strings e tratá-las da*/
   short int cont;                                 /*maneira especificada*/
   int key;
   wmove(campo,0,0);
   wrefresh(campo);
   curs_set(1);
   keypad(campo,TRUE);
   for (cont=0;cont<=tam-1;cont++){
      key=getch();
      if(key==KEY_BACKSPACE && cont>0){         
         werase(campo);
         wrefresh(campo);
         for (key=0;key<cont;key++)
            mvwprintw(campo,0,key,"%c",string[key]);
         cont--;
      }
      else{
         if (key==ENTER)
            break;
         if (key==ESCAPE){
            curs_set(0);         
            return(0);
         }
         if (cont==0 || cont-1==' ')
            key=toupper(key);
         else
            key=tolower(key);
         string[cont]=key;
         mvwprintw(campo,0,cont,"%c",string[cont]);
      }
      wrefresh(campo);
   }
   string[cont]='{FONTE}';
   curs_set(0);
   return(1);
}  
      
void pega_data_nas (WINDOW **campo,int *dia,int *mes,int *ano){ /*Função responsável por tratar os valores inseri-*/
   short int cont,valor;                                    /*dos nos vetores responsáveis pela data de nascimento*/
   WINDOW *msg;   
   noecho();
   for (cont=0;cont<=1;cont++){
      valor=getch();
      if (valor<48 || valor>57){
         tela_erro(msg,SONUM);
         getch();
         delwin(msg);
         touchwin(campo[0]);
         wrefresh(campo[0]);
         cont--;
      }
      dia[cont]=valor-48;
      wmove(campo[11],0,cont);
      wprintw(campo[11],"%d",dia[cont]);
      wrefresh(campo[11]);
   }   
   for (cont=0;cont<=1;cont++){
      valor=getch();
      if (valor<48 || valor>57){
         tela_erro(msg,SONUM);
         getch();
         delwin(msg);
         touchwin(campo[0]);
         wrefresh(campo[0]);
         cont--;
      }
      mes[cont]=valor-48;
      wmove(campo[12],0,cont);
      wprintw(campo[12],"%d",mes[cont]);
      wrefresh(campo[12]);
   }
   for (cont=0;cont<=3;cont++){
      valor=getch();
      if (valor<48 || valor>57){
         tela_erro(msg,SONUM);
         getch();
         delwin(msg);
         touchwin(campo[0]);
         wrefresh(campo[0]);
         cont--;
      }
      ano[cont]=valor-48;
      wmove(campo[13],0,cont);
      wprintw(campo[13],"%d",ano[cont]);
      wrefresh(campo[13]);
   }
   curs_set(0);         
}      

void pega_codigo(WINDOW **campo,unsigned short int codigo[]){
   register short int cont;
   WINDOW *msg;
   int valor;
   for (cont=0;cont<=6;cont++){
      valor=getch();
      if (valor<48 || valor>57){
         tela_erro(msg,SONUM);
         getch();
         delwin(msg);
         touchwin(campo[0]);
         wrefresh(campo[0]);
         cont--;
      }
      codigo[cont]=valor-48;
      wmove(campo[1],0,cont);
      wprintw(campo[1],"%d",codigo[cont]);
      wrefresh(campo[1]);
   }
}

int pega_cpf (WINDOW **campo,char *cpf){   /*Função responsável por ler os valores referentes ao cpf*/
   register short int cont;
   unsigned int valor;
   WINDOW *msg;
   wmove(campo[1],0,0);
   wrefresh(campo[1]);
   curs_set(1);
   for (cont=0;cont<=10;cont++){
      valor=getch(); 
      if (valor==ESCAPE){
         curs_set(0);
         return(0);
      }
      if (valor<48 || valor>57){
         tela_erro(msg,SONUM);
         getch();
         delwin(msg);
         touchwin(campo[0]);
         wrefresh(campo[0]);
         cont--;         
      }
      else{
         cpf[cont]=valor;
         if (cont<3){
            wmove(campo[1],0,cont);
            wprintw(campo[1],"%c",cpf[cont]);
            wrefresh(campo[1]);
         }
         else
            if (cont<6){
               wmove(campo[1],0,cont+1);
               wprintw(campo[1],"%c",cpf[cont]);
               wrefresh(campo[1]);
            }            
            else
               if (cont<9){
                  wmove(campo[1],0,cont+2);
                  wprintw(campo[1],"%c",cpf[cont]);
                  wrefresh(campo[1]);
               }
               else{
                  wmove(campo[1],0,cont+3);
                  wprintw(campo[1],"%c",cpf[cont]);               
                  wrefresh(campo[1]);
               }
      }
   }
   cpf[11]='{FONTE}';
   curs_set(0);
   return(1);
}

void exibe_cpf(WINDOW *campo,char cpf[]){
   int cont;
   for (cont=0;cont<=10;cont++){
      if (cont<3){
         wmove(campo,0,cont);
         wprintw(campo,"%c",cpf[cont]);        
      }
      else
         if (cont<6){
            wmove(campo,0,cont+1);
            wprintw(campo,"%c",cpf[cont]);         
         }            
         else
            if (cont<9){
               wmove(campo,0,cont+2);
               wprintw(campo,"%c",cpf[cont]);            
            }
            else{
               wmove(campo,0,cont+3);
               wprintw(campo,"%c",cpf[cont]);
            }
   }
   wrefresh(campo);
}

void abre(void){  /* Abre os arquivos alunos.bvq e cursos.bvq*/
   if((alunos=fopen("alunos.bvq","rb+"))==0)
      alunos=fopen("alunos.bvq","wb+");
   if((cursos=fopen("cursos.bvq","rb+"))==0)
      cursos=fopen("cursos.bvq","wb+");
}

int cadastra_aluno(WINDOW **screen,struct ord *aux2){ /*Cadastra um novo aluno*/
   int acao,cont,k;
   struct dados aux;
   struct dados_curso auxcur;
   WINDOW *meserro;   
   screen=tela_aluno(screen);
   mvwaddstr(screen[0],1,25,"NOVO CADASTRO DE ALUNO");
   wrefresh(screen[0]);
   if (vet_cursos[0]==-1){
      tela_erro(meserro,NCURSO);
      getch();
      delwin(meserro);      
      deleta_tela(screen);
      return(0);
   }
   do{      
      if (!(pega_cpf(screen,aux.cpf))){
         deleta_tela(screen);
         return(0);
      }
      if (cont=pesquisa_cpf(aux.cpf)){
         tela_erro(meserro,JAEXISTE);
         getch();
         delwin(meserro);
         touchwin(screen[0]);
         wrefresh(screen[0]);
      }
   }while (cont);   
   if (!(pega_string(screen[2],aux.identidade,13))){
        deleta_tela(screen);
        return(0);
   }   
   if (!(pega_string(screen[3],aux.nome,50))){
      deleta_tela(screen);
      return(0);
   }
   if (!(pega_string(screen[4],aux.end.rua,50))){
      deleta_tela(screen);
      return(0);
   }
   if (!(pega_string(screen[5],aux.end.numero,5))){
      deleta_tela(screen);
      return(0);
   }   
   if (!(pega_string(screen[6],aux.end.bairro,30))){
      deleta_tela(screen);
      return(0);
   }   
   if (!(pega_string(screen[7],aux.end.cidade,20))){
      deleta_tela(screen);
      return(0);
   }
   if (!(pega_string(screen[8],aux.end.estado,2))){
      deleta_tela(screen);
      return(0);
   }
   if (!(pega_string(screen[9],aux.end.cep,8))){
      deleta_tela(screen);
      return(0);
   }
   do{
      if (!(pega_string(screen[10],aux.curso,25))){
         deleta_tela(screen);
         return(0);
      }
      k=busca_binaria(poscur,aux.curso,1);
      fseek(cursos,vet_cursos[k]*sizeof(auxcur),SEEK_SET);
      fread(&auxcur,sizeof(auxcur),1,cursos);
      if (strcmp(aux.curso,auxcur.nome)){
         tela_erro(meserro,NACHOU);
         getch();
         delwin(meserro);
         touchwin(screen[0]);
         wrefresh(screen[0]);
      }
      else
         break;        
   }while (1); 
   curs_set(1);    
   pega_data_nas(screen,aux.datanasc.dia,aux.datanasc.mes,aux.datanasc.ano);
   aux.status=1;
   fseek(alunos,0,SEEK_END);
   fwrite(&aux,sizeof(aux),1,alunos);
   if (aux2[0].pos_aluno!=-1){
      cont=busca_binaria(pos,aux.nome,0);
      for (acao=pos+1;acao>cont;acao--){
         aux2[acao].pos_aluno=aux2[acao-1].pos_aluno;
         aux2[acao].pos_cur=aux2[acao-1].pos_cur;
      }
      fseek(alunos,0,SEEK_END);      
      aux2[cont].pos_aluno=(ftell(alunos)/sizeof(aux))-1;
      aux2[cont].pos_cur=vet_cursos[k];
   }
   else{      
      aux2[0].pos_aluno=(ftell(alunos)/sizeof(aux))-1;
      aux2[0].pos_cur=vet_cursos[k];
   }      
   curs_set(0);   
   tela_erro(meserro,SUCESSO);
   getch();
   delwin(meserro);
   deleta_tela(screen);
   return(1);
}

int cadastra_curso(WINDOW **screen,int *aux2){ /*Cadastra um novo curso*/
   int acao,cont;
   struct dados_curso aux,auxp;
   WINDOW *meserro;   
   screen=tela_curso(screen);
   mvwaddstr(screen[0],1,25,"NOVO CADASTRO DE CURSO");
   wrefresh(screen[0]);
   noecho();
   pega_codigo(screen,aux.codigo);   
   if (!(pega_string(screen[2],aux.predio,3))){
      deleta_tela(screen);
      return(0);
   }
   do{
      if (!(pega_string(screen[3],aux.nome,25))){
         deleta_tela(screen);
         return(0);
      }
      if (aux2[0]!=-1){         
         cont=busca_binaria(poscur,aux.nome,1);
         fseek(cursos,cont*sizeof(aux),SEEK_SET);         
         fread(&auxp,sizeof(auxp),1,cursos);         
         if (strcmp(auxp.nome,aux.nome)==0){
            tela_erro(meserro,JAEXISTE);
            getch();
            delwin(meserro);
         }
         else
            break;
      }
      else
         break;
   }while (1);         
   if (!(pega_string(screen[4],aux.quantp,3))){
      deleta_tela(screen);
      return(0);
   }
   if (!(pega_string(screen[5],aux.dep,50))){
      deleta_tela(screen);
      return(0);
   }   
   if (!(pega_string(screen[6],aux.coord,50))){
      deleta_tela(screen);
      return(0); 
   }  
   aux.status=1;
   fseek(cursos,0,SEEK_END);
   fwrite(&aux,sizeof(aux),1,cursos);   
   if (aux2[0]!=-1){            
      for (acao=poscur+1;acao>cont;acao--){
         aux2[acao]=aux2[acao-1];         
      }      
      fseek(cursos,0,SEEK_END);      
      aux2[cont]=(ftell(cursos)/sizeof(aux))-1;
   }
   else{            
      aux2[0]=(ftell(cursos)/sizeof(aux))-1;
   }
   curs_set(0);   
   tela_erro(meserro,SUCESSO);
   getch();
   delwin(meserro);
   deleta_tela(screen);
   return(1);  
}

int pesquisa_cpf (char *valor){     /*Função responsável pela pesquisa de cpf existente*/
   int cont;
   struct dados aux;   
   for (cont=0;vet_alunos[cont].pos_aluno!=-1;cont++){
      fseek(alunos,cont*sizeof(aux),SEEK_SET);
      fread(&aux,sizeof(aux),1,alunos);
      if (!(strcmp(valor,aux.cpf))){
         fseek(alunos,-1*sizeof(aux),SEEK_CUR);
         return(1);
      }
   }
   return(0);  
}

int altera_aluno(WINDOW **screen,struct ord *aux2){   /*Função responsável por alterar o cadastro de um aluno*/
   struct dados aux,aux3;   
   int i,k,contador,posarq,cont;
   WINDOW *meserro;
   char pesq[50];
   screen=tela_aluno(screen);
   mvwaddstr(screen[0],1,20,"ALTERACAO DE CADASTRO DE ALUNO");
   wrefresh(screen[0]);   
   for (;;){
      if (!(pega_string(screen[3],pesq,50))){
         deleta_tela(screen);
         return(0);
      }
      i=busca_binaria(pos,pesq,0);      
      fseek(alunos,aux2[i].pos_aluno*sizeof(aux),SEEK_SET);
      fread(&aux,sizeof(aux),1,alunos);
      if (strcmp(aux.nome,pesq)!=0){
         tela_erro(meserro,NACHOU);
         getch();
         delwin(meserro);
         touchwin(screen[0]);
         wrefresh(screen[0]);
      }
      else
         break;
  }
  posarq=aux2[i].pos_aluno;
  werase(screen[3]);
  exibe_cpf(screen[1],aux.cpf);  
  waddstr(screen[2],aux.identidade);
  waddstr(screen[3],aux.nome);
  waddstr(screen[4],aux.end.rua);
  waddstr(screen[5],aux.end.numero);
  waddstr(screen[6],aux.end.bairro);
  waddstr(screen[7],aux.end.cidade);
  waddstr(screen[8],aux.end.estado);
  waddstr(screen[9],aux.end.cep);
  waddstr(screen[10],aux.curso);  
  wprintw(screen[11],"%d%d",aux.datanasc.dia[0],aux.datanasc.dia[1]);
  wprintw(screen[12],"%d%d",aux.datanasc.mes[0],aux.datanasc.mes[1]);
  wprintw(screen[13],"%d%d%d%d",aux.datanasc.ano[0],aux.datanasc.ano[1],aux.datanasc.ano[2],aux.datanasc.ano[3]);
  for (k=2;k<=13;k++)
     wrefresh(screen[k]);  
  if (!(pega_string(screen[2],aux3.identidade,13))){
     deleta_tela(screen);
     return(0);
  }
  else
     if (aux3.identidade[0]!='{FONTE}')
        strcpy(aux.identidade,aux3.identidade);
  if (!(pega_string(screen[3],aux3.nome,50))){
     deleta_tela(screen);
     return(0);
  }
  else
     if (aux3.nome[0]!='{FONTE}'){         
         strcpy(aux.nome,aux3.nome);       
     }         
  if (!(pega_string(screen[4],aux3.end.rua,50))){
     deleta_tela(screen);
     return(0);
  }
  else
     if (aux3.end.rua[0]!='{FONTE}')
        strcpy(aux.end.rua,aux3.end.rua);
  if (!(pega_string(screen[5],aux3.end.numero,5))){
     deleta_tela(screen);
     return(0);
  }
  else
     if (aux3.end.numero[0]!='{FONTE}')
        strcpy(aux.end.numero,aux3.end.numero);
  if (!(pega_string(screen[6],aux3.end.bairro,30))){
     deleta_tela(screen);
     return(0);
  }
  else
     if (aux3.end.bairro[0]!='{FONTE}')
        strcpy(aux.end.bairro,aux3.end.bairro);
  if (!(pega_string(screen[7],aux3.end.cidade,20))){
     deleta_tela(screen);
     return(0);
  }
  else
     if (aux3.end.cidade[0]!='{FONTE}')
        strcpy(aux.end.cidade,aux3.end.cidade);
  if (!(pega_string(screen[8],aux3.end.estado,2))){
     deleta_tela(screen);
     return(0);
  }
  else
     if (aux3.end.estado[0]!='{FONTE}')
        strcpy(aux.end.estado,aux3.end.estado);
  if (!(pega_string(screen[9],aux3.end.cep,8))){
     deleta_tela(screen);
     return(0);
  }
  else
     if (aux3.end.cep[0]!='{FONTE}')
        strcpy(aux.end.cep,aux3.end.cep);
  if (!(pega_string(screen[10],aux3.curso,25))){
     deleta_tela(screen);
     return(0);
  }
  else
     if (aux3.curso[0]!='{FONTE}')
        strcpy(aux.curso,aux3.curso);  
  curs_set(1);
  pega_data_nas(screen,aux.datanasc.dia,aux.datanasc.mes,aux.datanasc.ano);  
  wrefresh(screen[0]);
   if (aux3.nome[0]!='{FONTE}'){
      k=busca_binaria(pos,aux3.nome,0);      
      if (k<i){
         for (contador=i;contador>k;contador--){
            aux2[contador].pos_aluno=aux2[contador-1].pos_aluno;
            aux2[contador].pos_cur=aux2[contador-1].pos_cur;
         }               
         aux2[k].pos_aluno=posarq;
         aux2[k].pos_cur=poscur;          
      }
      else
         if (k>i){
            for (contador=i;contador<k-1;contador++){
               aux2[contador].pos_aluno=aux2[contador+1].pos_aluno;
               aux2[contador].pos_cur=aux2[contador+1].pos_cur;
            }
            aux2[k-1].pos_aluno=posarq;
            aux2[k-1].pos_cur=poscur;                             
         }
   }
  fseek(alunos,posarq*sizeof(aux),SEEK_SET);
  fwrite(&aux,sizeof(aux),1,alunos);
  tela_erro(meserro,SUCESSO);
  getch();
  delwin(meserro);
  deleta_tela(screen);
}

int altera_curso(WINDOW **screen,int *aux2){   /*Função responsável por alterar o cadastro de um curso*/
   struct dados_curso aux,aux3;   
   int i,k,contador,posarq;
   WINDOW *meserro;
   char pesq[25];
   screen=tela_curso(screen);
   mvwaddstr(screen[0],1,20,"ALTERACAO DE CADASTRO DO CURSO");
   wrefresh(screen[0]);
   if (aux2[0]==-1){
      tela_erro(meserro,NACHOU);
      getch();
      delwin(meserro);
      deleta_tela(screen);
      return(0);
   } 
   for (;;){
      if (!(pega_string(screen[3],pesq,25))){
         deleta_tela(screen);
         return(0);
      }
      i=busca_binaria(poscur,pesq,1);
      fseek(cursos,aux2[i]*sizeof(aux),SEEK_SET);
      fread(&aux,sizeof(aux),1,cursos);
      if (strcmp(aux.nome,pesq)!=0){
         tela_erro(meserro,NACHOU);
         getch();
         delwin(meserro);
         touchwin(screen[0]);
         wrefresh(screen[0]);
      }
      else
         break;
   }
   posarq=aux2[i];
   werase(screen[3]);
   for (contador=0;contador<=6;contador++)
      wprintw(screen[1],"%d",aux.codigo[contador]);
   waddstr(screen[2],aux.predio);
   waddstr(screen[3],aux.nome);
   waddstr(screen[4],aux.quantp);
   waddstr(screen[5],aux.dep);
   waddstr(screen[6],aux.coord);   
   for (k=1;k<=6;k++)
      wrefresh(screen[k]); 
   wscanw(screen[1],"%[0-9]6lu",aux3.codigo); 
   if (!(pega_string(screen[2],aux3.predio,3))){
      deleta_tela(screen);
      return(0);
   }
   else
      if (aux3.predio[0]!='{FONTE}')
         strcpy(aux.predio,aux3.predio);
   if (!(pega_string(screen[3],aux3.nome,25))){
      deleta_tela(screen);
      return(0);
   }
   else{
      if (aux3.nome[0]!='{FONTE}'){
         if(strcmp(aux.nome,aux3.nome)){
            do{
               tela_erro(meserro,ALTERACAO);
               k=getch();
               if (k=='n' || k=='N'){
                  delwin(meserro);
                  deleta_tela(screen);
                  return(0);
               }
               else
                  if (k=='s' || k=='S'){
                     delwin(meserro);
                     touchwin(screen[0]);
                     wrefresh(screen[0]);
                  }
            }while (k!='n' && k!='N' && k!='s' && k!='S');
            strcpy(aux.nome,aux3.nome);       
         }
      }
   }
   if (!(pega_string(screen[4],aux3.quantp,3))){
         deleta_tela(screen);
         return(0);
      }
      else
         if (aux3.quantp[0]!='{FONTE}')
            strcpy(aux.quantp,aux3.quantp);
      if (!(pega_string(screen[5],aux3.dep,50))){
         deleta_tela(screen);
         return(0);
      }
      else
         if (aux3.dep[0]!='{FONTE}')
            strcpy(aux.dep,aux3.dep);
      if (!(pega_string(screen[6],aux3.coord,50))){
         deleta_tela(screen);
         return(0);
      }
      else
         if (aux3.coord[0]!='{FONTE}')
            strcpy(aux.coord,aux3.coord);      
      wrefresh(screen[0]);
      if (aux3.nome[0]!='{FONTE}'){
         k=busca_binaria(poscur,aux3.nome,1);
         if (k<i){
            for (contador=i;contador>k;contador--){
               aux2[contador]=aux2[contador-1];            
            }                  
            aux2[k]=posarq;            
         }
         else
            if (k>i){
               for (contador=i;contador<k-1;contador++){
                  aux2[contador]=aux2[contador+1]; 
               }                        
               aux2[k-1]=posarq;                
            }
      }
      fseek(cursos,posarq*sizeof(aux),SEEK_SET);
      fwrite(&aux,sizeof(aux),1,cursos);
      tela_erro(meserro,SUCESSO);
      getch();
      delwin(meserro);
      deleta_tela(screen);
}

int exclui_aluno(WINDOW **screen,struct ord *aux2){ /*Função responsável pela exclusão do cadastro de um aluno*/
   struct dados aux;   
   int i,k;
   WINDOW *meserro;
   char pesq[50],opcao;
   screen=tela_aluno(screen);
   mvwaddstr(screen[0],1,20,"EXCLUSAO DE CADASTRO DE ALUNO");
   wrefresh(screen[0]);   
   for (;;){
      if (!(pega_string(screen[3],pesq,50))){
         deleta_tela(screen);
         return(0);
      }
      i=busca_binaria(pos,pesq,0);
      fseek(alunos,aux2[i].pos_aluno*sizeof(aux),SEEK_SET);
      fread(&aux,sizeof(aux),1,alunos);
      if (strcmp(aux.nome,pesq)!=0){
         tela_erro(meserro,NACHOU);
         getch();
         delwin(meserro);
         touchwin(screen[0]);
         wrefresh(screen[0]);
      }
      else
         break;
   }
   werase(screen[3]);
   waddstr(screen[2],aux.identidade);
   waddstr(screen[3],aux.nome);
   waddstr(screen[4],aux.end.rua);
   waddstr(screen[5],aux.end.numero);
   waddstr(screen[6],aux.end.bairro);
   waddstr(screen[7],aux.end.cidade);
   waddstr(screen[8],aux.end.estado);
   waddstr(screen[9],aux.end.cep);
   waddstr(screen[10],aux.curso);
   wprintw(screen[11],"%d%d",aux.datanasc.dia[0],aux.datanasc.dia[1]);
   wprintw(screen[12],"%d%d",aux.datanasc.mes[0],aux.datanasc.mes[1]);
   wprintw(screen[13],"%d%d%d%d",aux.datanasc.ano[0],aux.datanasc.ano[1],aux.datanasc.ano[2],aux.datanasc.ano[3]);   
   for (k=2;k<=13;k++)
      wrefresh(screen[k]);      
   tela_erro(meserro,EXCLUI);
   noecho();
   do{
      opcao=getch();
   }while (opcao!='s' && opcao!='S' && opcao!='n' && opcao!='N');
   if (opcao=='s' || opcao=='S'){
      for (k=i;k<=pos;k++){
         aux2[k].pos_aluno=aux2[k+1].pos_aluno;
         aux2[k].pos_cur=aux2[k+1].pos_cur;
      }
      aux.status=0;
      fseek(alunos,-1*sizeof(aux),SEEK_CUR);
      fwrite(&aux,sizeof(aux),1,alunos);    
      tela_erro(meserro,EXCLUIDO);
   }
   else
      tela_erro(meserro,NEXCLUIDO);
   getch();   
   deleta_tela(screen);
   delwin(meserro);
   return(1);
}

int exclui_curso(WINDOW **screen,int *aux2){ /*Função responsável pela exclusão de um curso*/
   struct dados_curso aux;   
   int i,k;
   WINDOW *meserro;
   char pesq[25],opcao;
   screen=tela_curso(screen);
   mvwaddstr(screen[0],1,20,"EXCLUSAO DE CADASTRO DE CURSO");
   wrefresh(screen[0]);
   if (aux2[0]==-1){
      tela_erro(meserro,NACHOU);
      getch();
      delwin(meserro);
      deleta_tela(screen);
      return(0);
   }   
   for (;;){
      if (!(pega_string(screen[3],pesq,25))){
         deleta_tela(screen);
         return(0);
      }
      i=busca_binaria(poscur,pesq,1);
      fseek(cursos,aux2[i]*sizeof(aux),SEEK_SET);
      fread(&aux,sizeof(aux),1,cursos);
      if (strcmp(aux.nome,pesq)!=0){
         tela_erro(meserro,NACHOU);
         getch();
         delwin(meserro);
         touchwin(screen[0]);
         wrefresh(screen[0]);
      }
      else
         break;
   }
   werase(screen[3]);
   for (k=0;k<=6;k++)
      wprintw(screen[1],"%d",aux.codigo[k]);   
   waddstr(screen[2],aux.predio);
   waddstr(screen[3],aux.nome);
   waddstr(screen[4],aux.quantp);
   waddstr(screen[5],aux.dep);
   waddstr(screen[6],aux.coord);
   for (k=1;k<=6;k++)
      wrefresh(screen[k]);
   for (k=0;vet_alunos[k].pos_aluno!=-1;k++){ /*Garante que nenhum curso será apagado se possuir alunos cadastrados*/
      if (vet_alunos[k].pos_aluno==aux2[i]){  /*nele.*/
         tela_erro(meserro,APAGUE);
         getch();   
         deleta_tela(screen);
         delwin(meserro);
         return(0);
      }
   }        
   tela_erro(meserro,EXCLUI);
   noecho();
   do{
      opcao=getch();
   }while (opcao!='s' && opcao!='S' && opcao!='n' && opcao!='N');
   if (opcao=='s' || opcao=='S'){
      for (k=i;k<=poscur;k++){
         aux2[k]=aux2[k+1];         
      }
      aux.status=0;
      fseek(cursos,-1*sizeof(aux),SEEK_CUR);
      fwrite(&aux,sizeof(aux),1,cursos);    
      tela_erro(meserro,EXCLUIDO);
   }
   else
      tela_erro(meserro,NEXCLUIDO);
   getch();   
   deleta_tela(screen);
   delwin(meserro);
   return(1);
}

void lista_aluno(WINDOW *campos){       /*Função que lista todos os registros de um alunos*/
   struct dados aux;
   struct dados_curso auxcur;
   int cont=3,conta;        
   campos=tela_lista(campos);
   mvwaddstr(campos,1,15,"NOME");
   mvwaddstr(campos,1,50,"CURSO");
   for(conta=0;vet_alunos[conta].pos_aluno!=-1;conta++){      
      fseek(alunos,vet_alunos[conta].pos_aluno*sizeof(aux),SEEK_SET);
      fread(&aux,sizeof(aux),1,alunos);
      fseek(cursos,vet_alunos[conta].pos_cur*sizeof(auxcur),SEEK_SET);
      fread(&auxcur,sizeof(auxcur),1,cursos);      
      mvwaddstr(campos,cont,2,aux.nome);
      mvwaddstr(campos,cont,45,auxcur.nome);      
      if (cont==16){
         mvwaddstr(campos,cont+2,2,"Pressione uma tecla para continuar...");
         wrefresh(campos);
         getch();
         werase(campos);
         box(campos,ACS_VLINE,ACS_HLINE);
         mvwaddstr(campos,1,15,"NOME");
         mvwaddstr(campos,1,50,"CURSO");
         cont=3;
      }
      else
         cont++;      
   }   
   wrefresh(campos);
   delwin(campos);   
   getch();
}   

int lista_aluno_curso (WINDOW *campos){ /*Função que lista os alunos de determinado curso*/
   char pesq[25];
   int i, cont=5,conta;;
   struct dados_curso aux;
   struct dados auxalu;
   WINDOW **item,*meserro;  
   item=tela_pesquisa(item); 
   wrefresh(item[0]);  
   do{
      if (!(pega_string(item[1],pesq,25))){
         deleta_tela(item);
         return(0);
      }
      i=busca_binaria(poscur,pesq,1);
      fseek(cursos,vet_cursos[i]*sizeof(aux),SEEK_SET);
      fread(&aux,sizeof(aux),1,cursos);
      if (strcmp(aux.nome,pesq)!=0){
         tela_erro(meserro,NACHOU);
         getch();
         delwin(meserro);
         touchwin(item[0]);
         wrefresh(item[0]);
      }
      else
         break;
   }while (1);
   campos=tela_lista(campos);
   mvwprintw(campos,1,20,"CURSO: %s",aux.nome);
   mvwaddstr(campos,3,7,"CPF");
   mvwaddstr(campos,3,25,"NOME DO ALUNO");
   for(conta=0;vet_alunos[conta].pos_aluno!=-1;conta++){      
      fseek(alunos,vet_alunos[conta].pos_aluno*sizeof(auxalu),SEEK_SET);
      fread(&auxalu,sizeof(auxalu),1,alunos);      
      if (vet_alunos[conta].pos_cur==vet_cursos[i]){
         mvwaddstr(campos,cont,2,auxalu.cpf);      
         mvwaddstr(campos,cont,20,auxalu.nome);
         if (cont==16){
            mvwaddstr(campos,cont+2,2,"Pressione uma tecla para continuar...");
            wrefresh(campos);
            getch();
            werase(campos);
            box(campos,ACS_VLINE,ACS_HLINE);
            mvwprintw(campos,1,20,"CURSO: %s",aux.nome);
            mvwaddstr(campos,3,7,"CPF");
            mvwaddstr(campos,3,25,"NOME DO ALUNO");
            cont=5;
         }
         else
            cont++;
      }         
   }   
   wrefresh(campos);
   delwin(campos);   
   getch();
}  
         
void lista_curso(WINDOW *campos){       /*Função que lista todos os cursos cadastrados*/
   struct dados_curso aux;
   int cont=3,conta,k;   
   campos=tela_lista(campos);
   mvwaddstr(campos,1,7,"CÓDIGO");
   mvwaddstr(campos,1,25,"NOME DO CURSO");
   for(conta=0;vet_cursos[conta]!=-1;conta++){      
      fseek(cursos,vet_cursos[conta]*sizeof(aux),SEEK_SET);
      fread(&aux,sizeof(aux),1,cursos);
      for (k=0;k<=6;k++)
         mvwprintw(campos,cont,k+2,"%d",aux.codigo[k]);      
      mvwaddstr(campos,cont,20,aux.nome);
      if (cont==16){
         mvwaddstr(campos,cont+2,2,"Pressione uma tecla para continuar...");
         wrefresh(campos);
         getch();
         werase(campos);
         box(campos,ACS_VLINE,ACS_HLINE);
         mvwaddstr(campos,1,7,"CÓDIGO");
         mvwaddstr(campos,1,25,"NOME DO CURSO");
         cont=3;
      }
      else
         cont++;     
   }   
   wrefresh(campos);
   delwin(campos);   
   getch();
}   

void deleta_tela(WINDOW **espacos){ /*responsável por deletar as telas de gerenciamento de alunos e cursos*/
   register short int i;
   for (i=0;i<=13;i++)
      delwin(espacos[i]);
   free(espacos);
}

void deleta_menu(WINDOW **opcoes,int cont){ /*responsável por deletar as telas dos menus*/
   register short int i;
   for (i=0;i<=cont;i++)
      delwin(opcoes[i]);
   free(opcoes);
}

WINDOW **menuf2(WINDOW **opcoes){  /*Cria o menu F2*/
   register short int i;
   opcoes=(WINDOW **)malloc(5*sizeof(WINDOW *));   
   opcoes[0]=newwin(6,13,1,13);
   wbkgd(opcoes[0],COLOR_PAIR(2));
   box(opcoes[0],ACS_VLINE,ACS_HLINE);
   for (i=1;i<=4;i++){
      opcoes[i]=subwin(opcoes[0],1,11,i+1,14);
      wbkgd(opcoes[i],COLOR_PAIR(2));
   }
   waddstr(opcoes[1]," CADASTRAR");
   waddstr(opcoes[2]," ALTERAR");
   waddstr(opcoes[3]," EXCLUIR");
   waddstr(opcoes[4]," LISTAR C");   
   wrefresh(opcoes[0]);
   return(opcoes);
}

WINDOW **menuf1(WINDOW **opcoes){ /*cria o menu F1*/
   register short int i;
   opcoes=(WINDOW **)malloc(6*sizeof(WINDOW *));   
   opcoes[0]=newwin(7,13,1,0);
   wbkgd(opcoes[0],COLOR_PAIR(2));
   box(opcoes[0],ACS_VLINE,ACS_HLINE);
   for (i=1;i<=5;i++){
      opcoes[i]=subwin(opcoes[0],1,11,i+1,1);
      wbkgd(opcoes[i],COLOR_PAIR(2));
   }
   waddstr(opcoes[1]," CADASTRAR");
   waddstr(opcoes[2]," ALTERAR");
   waddstr(opcoes[3]," EXCLUIR");
   waddstr(opcoes[4]," LISTAR A");
   waddstr(opcoes[5]," LISTAR AC");
   wrefresh(opcoes[0]);
   return(opcoes);
}

void criabarrasuperior(WINDOW *barrasup){ /*Cria o menu superior*/
   wbkgd(barrasup,COLOR_PAIR(2));
   waddstr(barrasup," ALUNO "); 
   wattron(barrasup,COLOR_PAIR(4));
   waddstr(barrasup,"(F1) ");
   wattroff(barrasup,COLOR_PAIR(4));
   waddstr(barrasup," CURSO");
   wattron(barrasup,COLOR_PAIR(4));
   waddstr(barrasup," (F2)");
   wattroff(barrasup,COLOR_PAIR(4));
   waddstr(barrasup,"    SAIR");
   wattron(barrasup,COLOR_PAIR(4));
   waddstr(barrasup," (F3)");
   wattroff(barrasup,COLOR_PAIR(4));
   
}

void ativa_ncurses(void){ /*Ativa biblioteca ncurses e define as diretrizes gráficas do programa*/
   initscr();
   start_color();
   init_pair(1,COLOR_WHITE,COLOR_BLUE);
   init_pair(2,COLOR_BLUE,COLOR_WHITE);
   init_pair(3,COLOR_YELLOW,COLOR_RED);
   init_pair(4,COLOR_RED,COLOR_WHITE);
   init_pair(5,COLOR_BLACK,COLOR_WHITE);
   init_pair(6,COLOR_WHITE,COLOR_BLACK);
   init_pair(7,COLOR_WHITE,COLOR_RED);
   curs_set(0); 
   noecho(); 
   keypad(stdscr,TRUE); 
}         

WINDOW **tela_aluno(WINDOW **campos){ /*Cria tela de gerenciamento de alunos*/
   register short int i;
   campos=(WINDOW **)malloc(14*sizeof(WINDOW *));
   campos[0]=newwin(20,75,2,2);
   wbkgd(campos[0],COLOR_PAIR(5));
   box(campos[0],ACS_VLINE,ACS_HLINE);
   campos[1]=subwin(campos[0],1,15,6,12);
   campos[2]=subwin(campos[0],1,14,6,49);
   campos[3]=subwin(campos[0],1,51,8,12);
   campos[4]=subwin(campos[0],1,51,10,12);
   campos[5]=subwin(campos[0],1,6,10,68);
   campos[6]=subwin(campos[0],1,31,12,12);
   campos[7]=subwin(campos[0],1,21,14,12);
   campos[8]=subwin(campos[0],1,3,14,45);
   campos[9]=subwin(campos[0],1,9,14,55);                         
   campos[10]=subwin(campos[0],1,25,16,12);   
   campos[11]=subwin(campos[0],1,3,16,54);
   campos[12]=subwin(campos[0],1,3,16,58);
   campos[13]=subwin(campos[0],1,5,16,62);
   for (i=1;i<=14;i++)
      wbkgd(campos[i],COLOR_PAIR(6));   
   mvwaddstr(campos[0],4,2,"CPF:");
   mvwaddstr(campos[0],4,35,"IDENTIDADE:");
   mvwaddstr(campos[0],6,2,"NOME:");
   mvwaddstr(campos[0],8,2,"RUA:");
   mvwaddstr(campos[0],8,62,"NUM:");
   mvwaddstr(campos[0],10,2,"BAIRRO:");
   mvwaddstr(campos[0],12,2,"CIDADE:");
   mvwaddstr(campos[0],12,35,"ESTADO:");
   mvwaddstr(campos[0],12,48,"CEP:");
   mvwaddstr(campos[0],14,2,"CURSO:");   
   mvwaddstr(campos[0],14,40,"NASCIMENTO:");
   mvwaddstr(campos[0],14,55,"/");
   mvwaddstr(campos[0],14,59,"/");
   mvwaddstr(campos[1],0,0,"   .   .   -");
   wrefresh(campos[0]);
   return(campos);   
}

WINDOW **tela_curso(WINDOW **campos){ /*Cria tela de gerenciamento de cursos*/
   register short int i;
   campos=(WINDOW **)malloc(7*sizeof(WINDOW *));
   campos[0]=newwin(20,75,2,2);
   wbkgd(campos[0],COLOR_PAIR(5));
   box(campos[0],ACS_VLINE,ACS_HLINE);
   campos[1]=subwin(campos[0],1,6,6,18);
   campos[2]=subwin(campos[0],1,3,6,49);
   campos[3]=subwin(campos[0],1,25,8,18);
   campos[4]=subwin(campos[0],1,2,8,65);
   campos[5]=subwin(campos[0],1,51,10,18);
   campos[6]=subwin(campos[0],1,51,12,18);      
   for (i=1;i<=6;i++)
      wbkgd(campos[i],COLOR_PAIR(6));   
   mvwaddstr(campos[0],4,2,"CÓDIGO:");
   mvwaddstr(campos[0],4,35,"PRÉDIO:");
   mvwaddstr(campos[0],6,2,"NOME:");
   mvwaddstr(campos[0],6,45,"QUANT. PERÍODOS:");
   mvwaddstr(campos[0],8,2,"DEPARTAMENTO:");
   mvwaddstr(campos[0],10,2,"COORDENADOR:");      
   return(campos);   
}

WINDOW *tela_lista (WINDOW *itens){ /*Cria tela para listagem dos cadastros*/
   register short int i;
   itens=newwin(20,75,2,2);
   wbkgd(itens,COLOR_PAIR(4));
   box(itens,ACS_VLINE,ACS_HLINE);   
   wrefresh(itens);
   return(itens);
}

WINDOW **tela_pesquisa (WINDOW **campos){ /*Cria tela de pesquisa de curso*/
   register short int i;
   campos=(WINDOW **)malloc(2*sizeof(WINDOW *));
   campos[0]=newwin(6,75,7,2);
   wbkgd(campos[0],COLOR_PAIR(5));
   box(campos[0],ACS_VLINE,ACS_HLINE);
   campos[1]=subwin(campos[0],1,25,10,20);   
   wbkgd(campos[1],COLOR_PAIR(6));   
   mvwaddstr(campos[0],2,2,"A QUAL CURSO OS ALUNOS QUE VOCÊ DESEJA LISTAR PERTENCEM?");   
   return(campos);   
}
   
void tela_erro(WINDOW *erro,int mensagem){ /*Cria tela de advertência*/
   erro=newwin(6,30,9,25);
   wbkgd(erro,COLOR_PAIR(7));
   box(erro,ACS_VLINE,ACS_HLINE);
   switch (mensagem){
      case NACHOU : mvwaddstr(erro,2,2,"REGISTRO NAO ENCONTRADO!!");
      break;
      case JAEXISTE : mvwaddstr(erro,2,6,"CPF JÁ EXISTENTE!");
      mvwaddstr(erro,3,1,"IMPOSSIVEL EFETUAR CADASTRO!");
      break;
      case SONUM : mvwaddstr(erro,2,4,"DIGITE APENAS NUMEROS!");
      break;
      case EXCLUI : mvwaddstr(erro,2,2,"DESEJA REALMENTE EXCLUIR?");
      mvwaddstr(erro,3,2,"(s/n)");
      break;
      case EXCLUIDO : mvwaddstr(erro,2,2,"ITEM EXCLUIDO COM SUCESSO!");
      break;
      case NEXCLUIDO : mvwaddstr(erro,2,6,"OPERACAO DE EXCLUSÃO");
      mvwaddstr(erro,3,12,"CANCELADA");
      break;
      case SUCESSO : mvwaddstr(erro,2,6,"OPERACAO REALIZADA");
      mvwaddstr(erro,3,9,"COM SUCESSO!");
      break;
      case NCURSO : mvwaddstr(erro,2,6,"IMPOSSÍVEL EFETUAR");
      mvwaddstr(erro,3,11,"CADASTRO!");
      break;
      case APAGUE : mvwaddstr(erro,2,3,"APAGUE TODOS OS ALUNOS");
      mvwaddstr(erro,3,2,"PERTENCENTES A ESTE CURSO");
      mvwaddstr(erro,4,10,"PRIMEIRO!");
      break;
      case ALTERACAO : mvwaddstr(erro,1,4,"AS ALTERAÇÕES FEITAS");
      mvwaddstr(erro,2,2,"AFETARÃO TODOS OS ALUNOS");
      mvwaddstr(erro,3,3,"INSCRITOS NESSE CURSO!");
      mvwaddstr(erro,4,2,"DESEJA CONTINUAR? (s/n)");
      break;
      default : mvwaddstr(erro,3,2,"ERRO DESCONHECIDO!");
   }
   curs_set(0);   
   wrefresh(erro);   
}
      
int scroll_menu_f1(WINDOW **items,WINDOW *mensagem){ /*responsável pela movimentação do cursor no menu F1*/
   int key,selected=-1;
   while (1) {
      key=getch();      
      if (key==KEY_DOWN || key==KEY_UP) {
         wbkgd(items[selected+1],COLOR_PAIR(2));
         wnoutrefresh(items[selected+1]);
         if (key==KEY_DOWN){
            selected=(selected+1) % 5;
         } else {
            selected=(selected+5-1) % 5;
         }
         switch (selected){
            case 0 : werase(mensagem);
            waddstr(mensagem,"Efetua o cadastro de um novo aluno.");
            wrefresh(mensagem);
            break;
            case 1 : werase(mensagem);
            waddstr(mensagem,"Altera o cadastro de um aluno existente.");
            wrefresh(mensagem);
            break;
            case 2 : werase(mensagem);
            waddstr(mensagem,"Exclui o cadastro de um aluno existente.");
            wrefresh(mensagem);
            break;
            case 3 : werase(mensagem);
            waddstr(mensagem,"Lista todos os alunos cadastrados.");
            wrefresh(mensagem);
            break;
            case 4 : werase(mensagem);
            waddstr(mensagem,"Lista os alunos cadastrados em determinado curso.");
            break;
         }            
         wbkgd(items[selected+1],COLOR_PAIR(1));
         wnoutrefresh(mensagem);
         wnoutrefresh(items[selected+1]);
         doupdate();
      } else if (key==ESCAPE) {
         return -1;
      }
      else if (key==ENTER) {
         return selected;
      }
   }
}

int scroll_menu_f2(WINDOW **items,WINDOW *mensagem){ /*Responsável pela movimentação do cursor no menu F2*/
   int key;
   int selected=-1;
   while (1) {
      key=getch();      
      if (key==KEY_DOWN || key==KEY_UP) {
         wbkgd(items[selected+1],COLOR_PAIR(2));
         wnoutrefresh(items[selected+1]);
         if (key==KEY_DOWN){
            selected=(selected+1)%4;
         } else {
            selected=(selected+4-1)%4;
         }
         switch (selected){
            case 0 : werase(mensagem);
            waddstr(mensagem,"Efetua o cadastro de um novo curso.");
            wrefresh(mensagem);
            break;
            case 1 : werase(mensagem);
            waddstr(mensagem,"Altera o cadastro de um curso existente.");
            wrefresh(mensagem);
            break;
            case 2 : werase(mensagem);
            waddstr(mensagem,"Exclui o cadastro de um curso existente.");
            wrefresh(mensagem);
            break;
            case 3 : werase(mensagem);
            waddstr(mensagem,"Lista os cursos cadastrados.");
            wrefresh(mensagem);
            break;            
         }            
         wbkgd(items[selected+1],COLOR_PAIR(1));
         wnoutrefresh(mensagem);
         wnoutrefresh(items[selected+1]);
         doupdate();
      } else if (key==ESCAPE) {
         return -1;
      }
      else if (key==ENTER) {
         return selected;
      }
   }
}

void quicksort(int begin, int end,int opcao) { /*Responsável por ordenar os registros quando o arquivo de ordenação*/
   if (!opcao){                                /*é perdido*/
      struct dados aux;
      if (end - begin > 1) {
         char pivot[50]; 
         int l = begin + 1;
         int r = end,k;
         fseek(alunos,vet_alunos[begin].pos_aluno*sizeof(aux),SEEK_SET);
         fread(&aux,sizeof(aux),1,alunos);
         strcpy(pivot,aux.nome);
         while(l < r) {
            fseek(alunos,vet_alunos[l].pos_aluno*sizeof(aux),SEEK_SET);
            fread(&aux,sizeof(aux),1,alunos);
            if (strcmp(aux.nome,pivot)<=0) {
               l++;
            } else {
               r--;
               k=vet_alunos[l].pos_aluno;
               vet_alunos[l].pos_aluno=vet_alunos[r].pos_aluno;
               vet_alunos[r].pos_aluno=k;
               k=vet_alunos[l].pos_cur;
               vet_alunos[l].pos_cur=vet_alunos[r].pos_cur;
               vet_alunos[r].pos_cur=k;               
            }
         }
         l--;
         k=vet_alunos[begin].pos_aluno;
         vet_alunos[begin].pos_aluno=vet_alunos[l].pos_aluno;
         vet_alunos[l].pos_aluno=k; 
         k=vet_alunos[begin].pos_cur;
         vet_alunos[begin].pos_cur=vet_alunos[l].pos_cur;
         vet_alunos[l].pos_cur=k;
         quicksort(begin,l,0);
         quicksort(r,end,0);  
      }
   }
   else{
      struct dados_curso aux;
      if (end - begin > 1) {
         char pivot[25]; 
         int l = begin + 1;
         int r = end,k;
         fseek(cursos,vet_cursos[begin]*sizeof(aux),SEEK_SET);
         fread(&aux,sizeof(aux),1,cursos);
         strcpy(pivot,aux.nome);
         while(l < r) {
            fseek(cursos,vet_cursos[l]*sizeof(aux),SEEK_SET);
            fread(&aux,sizeof(aux),1,cursos);
            if (strcmp(aux.nome,pivot)<=0) {
               l++;
            } else {
               r--;
               k=vet_cursos[l];
               vet_cursos[l]=vet_cursos[r];
               vet_cursos[r]=k;               
            }
         }
         l--;
         k=vet_cursos[begin];
         vet_cursos[begin]=vet_cursos[l];
         vet_cursos[l]=k;          
         quicksort(begin,l,1);
         quicksort(r,end,1);  
      }
   }          
}

int main(void){  /*Função princial do programa*/
   unsigned int key;    
   WINDOW *menubar,*messagebar;
   abre();   
   carrega_vetor(0);   
   carrega_vetor(1);
   key=0;
   while (vet_alunos[key].pos_aluno!=-1){      
      pos++;
      key++;
   }
   key=0;
   while (vet_cursos[key]!=-1){      
      poscur++;
      key++;
   }
   fseek(cursos,0,SEEK_END);
   if ((key=ftell(cursos)/sizeof(struct dados_curso)!=0) && poscur==-1){
      struct dados_curso temp;
      int contador=0;            
      fseek(cursos,0,SEEK_SET);
      fread(&temp,sizeof(temp),1,cursos);
      key=-1;      
      while (!feof(cursos)){
         if (temp.status==1){
            key++;
            vet_cursos[key]=contador;                        
         }
         contador++;
         fread(&temp,sizeof(temp),1,cursos);
      }      
      quicksort(0,key+1,1);
   }
   fseek(alunos,0,SEEK_END);
   if ((key=ftell(alunos)/sizeof(struct dados)!=0) && pos==-1){
      struct dados temp;
      int contador=0;            
      fseek(alunos,0,SEEK_SET);
      fread(&temp,sizeof(temp),1,alunos);
      key=-1;      
      while (!feof(alunos)){
         if (temp.status==1){            
            key++;                         
            vet_alunos[key].pos_aluno=contador;
            vet_alunos[key].pos_cur=vet_cursos[busca_binaria(poscur,temp.curso,1)];            
         }
         contador++;
         fread(&temp,sizeof(temp),1,alunos);
      }      
      quicksort(0,key+1,0);
   }
   ativa_ncurses();    
   bkgd(COLOR_PAIR(1));
   menubar=subwin(stdscr,1,80,0,0);
   messagebar=subwin(stdscr,1,80,24,0);
   wbkgd(messagebar,COLOR_PAIR(2));
   criabarrasuperior(menubar);
   refresh();
   do {
      int selected_item;
      WINDOW **menu_items,**tela,*listacad;
      key=getch();
      werase(messagebar);
      wrefresh(messagebar);
      if (key==KEY_F(1)) {
         menu_items=menuf1(menu_items);
         selected_item=scroll_menu_f1(menu_items,messagebar);
         deleta_menu(menu_items,4);
         switch (selected_item){
            case -1 : werase(messagebar);
            wprintw(messagebar,"Escolha uma opcao.");
            break;
            case 0 : pos+=cadastra_aluno(tela,vet_alunos);            
            break;
            case 1 : altera_aluno(tela,vet_alunos);
            break;
            case 2 : pos-=exclui_aluno(tela,vet_alunos);            
            break;
            case 3 : lista_aluno(listacad);
            break;
            case 4 : lista_aluno_curso(listacad);
            break;
         }
         touchwin(stdscr);
         refresh();
      }
      if (key==KEY_F(2)){
         menu_items=menuf2(menu_items);
         selected_item=scroll_menu_f2(menu_items,messagebar);
         deleta_menu(menu_items,5);
         switch (selected_item){
            case -1 : werase(messagebar);
            wprintw(messagebar,"Escolha uma opcao.");
            break;
            case 0 : poscur+=cadastra_curso(tela,vet_cursos);
            break;
            case 1 : altera_curso(tela,vet_cursos);
            break;
            case 2 : pos-=exclui_curso(tela,vet_cursos);
            break;
            case 3 : lista_curso(listacad);
            break;            
         }
         touchwin(stdscr);
         refresh();
      }         
   }while (key!=KEY_F(3));    
   delwin(menubar);
   delwin(messagebar);
   endwin();
   fclose(alunos);
   salva_vetor();   
   return(0);   
}

read_pg_conf

Listar arquivos e diretórios com suas propriedades

Compactando arquivos de log *.txt

Comandos de um Shell

BRT - Bulk Renaming Tool