Controlando uma Impressora

Existe duas classes principais de impressora: as impressoras de linhas e as impressoras de página.

Impressoras de linha : Este tipo de impressora imprime os dados linha por linha iniciando pelo topo da página, as impressoras jato de tinta e matriciais são exemplos deste tipo de impressoras.

Impressoras de página : Este tipo de impressora recebem todos os dados destinados a uma página completa antes de fazer a impressão, as impressoras a laser são exemplos deste tipo de impressora.

Como padrão, as impressoras esperam receber um fluxo de texto que será impresso como se o texto estivesse sendo enviado para uma apresentação em tela, iniciando uma nova linha ao aparecerem códigos ASCII para retorno de cursor ( e avanço de linha), ou passando automaticamente à linha seguinte quando a linha impressa exceder a largura da página (somente a impressora matricial pula linha automaticamente ao exceder a largura da página).

Códigos especiais são enviados a uma impressora para definir as várias especificações de formato da página, esses códigos são transmitidos à impressora da mesma forma que os outros dados. A maior parte das especificações das impressoras é enviada na forma de seqüência de escape, onde um ou mais bytes de código se seguem ao caracter de escape ( 27 ASCII ), este caracter informa a impressora que os caracteres seguintes devem ser interpretados como se fossem comandos ao invés de serem tratados como forma de dados, e estes geralmente não possuem caracteres de finalização, pois a impressora “conhece” o comprimento de cada seqüência. Abaixo segue uma tabela com os códigos de caracteres de Escape. 

Códigos de Caracteres de Escape	
Código de escape	Valor ASCII	Descrição	
\a	0x07	Alarme (sino)	
\b	0x08	Retorno	
\t	0x09	Tab horizontal	
\n	0x0A	Alimenta linha	
\v	0x0B	Tab Vertical	
\f	0x0C	Alimenta folha	
\r	0x0D	Retorno de Cursor	
\”	0x22	Aspas(“)	
\´	0x27	Apóstrofo(´)	
\?	0x3F	Ponto de Interrogação (?)	
\\	0x5C	Barra invertida (\)	
\000	000	Valor octal	
\zHH	0xHH	Valor hexadecimal	

Para que se exibir uma mensagem ou mesmo o conteúdo de uma variável em tela (no monitor) se uitliza o comando gotoxy(coluna,linha)  que define a posição da coluna e da linha que se deseja exibir, enquanto que na impressora não existe um comando específico para posicionar no papel na posição desejada, por isso é necessário o uso dos códigos de caracteres de escape.

Para que se possa imprimir os resultados de um programa em C se utiliza a função de saída fprintf() juntamente com uma determinada constante que irá definir o local da impressão, conforme pode ser visto na tabela abaixo: 

Nome	Periférico	
		
stdin				standard input device 		(teclado)	
stdout			standard output device		(vídeo)	
stderr			standard error device 		(vídeo)	
stdaux			standard auxiliary device	(porta serial)	
stdprn			standard printing device	(impressora paralela)	
	
No caso para enviar dados a impressora se utiliza a constante stdprn. 

Para  imprimir uma mensagem na 3º linha com duas tabulações temos: 
include <stdio.h>
void main ()
{
fprintf(stdprn,“\r\n\n\t\t Este é um teste de uso da Impressora”);
}

Para  imprimir  uma variável do programa temos:
	
include <stdio.h>
include <conio.h>
void main ()
{
char nome[20];
int numero;
clrscr();
gotoxy(5,10);
printf(“Informe o nome da pessoa....:”); gets(nome);
gotoxy(5,12);
printf(“Informe um numero inteiro qualquer..:”); scanf(“%i”, &numero); 
fprintf(stdprn, “\r\n\n\t\tA pessoa se chama %s”, nome);
fprintf(stdprn, “\r\n\t\tO número digitado foi %i”, numero );
getch();	
}
	
Para imprimir dados que estão armazenados em arquivos, é necessária a leitura dos dados do arquivo para em seguida enviá-los à impressora.

O exemplo abaixo cria um arquivo que irá armazenar três variáveis: a primeira contendo valor inteiro, a Segunda um valor float e a última uma string. Em seguida as informações são gravadas para posteriormente serem recuperadas para impressão.

#include <stdio.h>
#include <conio.h>

struct teste
{
int i;
char c;
float f;
}teste_imp;

void gravar_dados ( );
void imprimir_dados ( );

void main(void)
{
gravar_dados();
imprimir_dados();
}

void gravar_dados()  
{
FILE *stream;
stream = fopen("DUMMY.FIL", "w+");
int numero_i=100;
float numero_f=100.50;
char caracter='C';
fprintf(stream, "%d %c %f", numero_i, caracter, numero_f);
fclose(stream);
}

void imprimir_dados()
{
stream=fopen("DUMMY.FIL","r");
fscanf(stream,"%i",&teste_imp.i);
fscanf(stream,"%s",&teste_imp.c);
fscanf(stream,"%f",&teste_imp.f);
clrscr();
printf("\n%i" ,teste_imp.i);
printf("\n\n%c",teste_imp.c);
printf("\n\n%.2f",teste_imp.f);
fprintf(stdprn, "\r%d  %c  %f", teste_imp.i, teste_imp.c, teste_imp.f);
fclose(stream);
getch();
}

Obs:- A função fprintf() envia dados somente para a porta LPT1, sendo assim caso a impressora a ser utilizada esteja configurada à outra porta paralela, é necessário que seja aberta como se fosse um arquivo. Isto será ilustrado no exemplo a seguir que envia os dados para a porta LPT2.

include <stdio.h>
include <conio.h>
FILE *teste_imp;
void main ()
{
teste_imp = fopen(“LPT2”,“w”)
fprintf(teste_imp,“\r\n\n\t\tEste é um teste de uso da Impressora”);
getch();	
}

Para se enviar dados de variáveis ou ler dados de arquivos e imprimi-los o processo é o mesmo, deve-se abrir a impressora como se fosse um arquivo.

Nos exemplos dados a impressão dos textos utilizam a fonte e tamanho padrão, pode ser utilizado também outros formatos definindo o tipo das letras como: enfatizada, elite, condensada, subscrita, superescrita, carta (NLQ), itálica e bold.

Os formatos apresentados a seguir fazem a mudança do modo de impressão, somente para impressoras matriciais.

Códigos de formatação de fonte para impressoras matriciais	
			
Código da letra	Tipo da letra	Resultado da Impressão	
			
15	Condensada	Resultado ?	
52	Itálica	Resultado	
64	Default	Resultado ?	
69	Enfatizada	Resultado ?	
71	Bold	Resultado ?	
77	Elite	Resultado ? 	
83          1	subscrita	Resultado	
83          0	Superescrita	Resultado	
120        1	Carta (NQL)	Resultado ? 	

	
Tamanho da página	
	
Impressora	Linhas	Colunas	
			
Matricial	64	Até 132	
Laser	64	80	
Jato de tinta	60	80	

Para que seja possível mudar o formato da letra é necessário enviar os códigos da letra para a impressora como demonstrado no exemplo abaixo: 
	// altera a fonte para o tipo de letra condensada.
	void letra_condensada();
{
	impressao(27);impressao(15);
}
	
// altera a fonte para o tipo de letra itálica.
	void letra_italica();
{
	impressao(27);impressao(52);
}

	// altera a fonte para o tipo de letra default.
	void letra_default();
{
	impressao(27);impressao(64);
}

	// altera a fonte para o tipo de letra enfatizada.
	void letra_enfatizada();
{
	impressao(27);impressao(69);
}

	// altera a fonte para o tipo de letra bold.
	void letra_bold();
{
	impressao(27);impressao(71);
}

	// altera a fonte para o tipo de letra elite.
	void letra_elite();
{
	impressao(27);impressao(77);
}

	// altera a fonte para o tipo de letra subscrita.
	void letra_subscrita();
{
	impressao(27);impressao(83); impressao(1);
}

	// altera a fonte para o tipo de letra superescrita.
	void letra_superescrita();
{
	impressao(27);impressao(83); impressao(0);
}

	// altera a fonte para o tipo de letra carta (NQL).
	void letra_carta();
{
	impressao(27);impressao(120); impressao(1);
}

Neste  caso é definida uma função chamada impressao, que receberá um valor do  tipo char que será enviado logo em seguida à impressora.

void impressao(char ch)
{
	biosprint(0,ch,0);
}

A função biosprint() é uma função de interface com a BIOS que exige o arquivo de cabeçalho bios.h ( aplica-se apenas a compiladores C baseados em DOS) e possui três parâmetros:
Forma geral:
 biosprint(int cmd, int abyte, int port);

Onde cmd especifica a função da impressora, podendo ser :

Valor	Significado	
0	Imprimir o caracter passado	
1	Inicializar porta de comunicação da impressora	
2	Devolve o status da impressora	

abyte é o caracter a ser impresso
port especifica a porta de comunicação a ser usada sendo 0 para LPT1, 1 para LPT2,etc...

Esta função  é extremamente simples, ela apenas recebe um caracter como parâmetro e chama a função biosprint () passando para esta o valor de ch que corresponderá ao tipo de letra que vai ser impressa.

A função biosprint()  está sendo utilizada para enviar dados a impressora que se encontra conectada a porta paralela LPT1, está função recebe o caracter enviado pelo programa e o direciona a porta paralela, no caso LPT1.

No exemplo dado o valor 0 para cmd  significa o que se quer é imprimir  caracteres, o valor ch que é o código para que seja efetuada a mudança da fonte e o valor 0 para port, o que significa que queremos utilizar a porta paralela LPT1.

O programa abaixo consiste em dar a opção ao usuário de armazenar em um arquivo dados dos alunos como:R.A., Nome do aluno, Curso, Semestre (respeitando o limite de 50 registros). Além de permitir o cadastro dos alunos o programa permite que seja impresso um relatório podendo escolher a impressora e o tipo de letra dependendo da impressora.

#include <bios.h>
#include <string.h>
#include <conio.h>]
#include <stdio.h>
#include <dos.h>
#include <ctype.h>

// Estrutura dos Registros  

struct campos
{
  char ra[10],nome_aluno[31],curso[11],semestre[3];
}reg[50];

// Protótipos das funções utilizadas  \\

void insere			(void);	// inserir novos registros
int  altera			(void);	// alterar registros existentes
int  exclui			(void);	// exclui registros
void escolhe		(void);	// menu de escolha de tipo de letra
void imprime_ma	(void);	// imprime relatório imp. matricial
void imprime_hp		(void);	// imprime relatório imp. Jato de tinta
void imprime_la		(void);	// imprime relatório imp. laser
void visualiza		(void);	// visualiza conteúdo
void imp			(char ch);	// recebe e envia dados a função biosprint
void l_enf			(void);	// muda fonte para enfatizada
void l_eli			(void);	// muda fonte para elite
void l_con			(void);	// muda fonte para condensada
void l_sub			(void);	// muda fonte para subescrita
void l_sup			(void);	// muda fonte para superescrita
void l_nlq			(void);	// muda fonte para tipo de letra carta (NQL)
void l_ita			(void);	// muda fonte para itálico
void l_bol			(void);	// muda fonte para bolde
int  grava			(void);	// grava no arquivo os registros
int  carrega			(void);	// carrega registros armazenados
void espaco		(char palavra[], int valor, int posicao);  // pula espaço durante impressão

int atual=-1;

// função principal 

void main ()
{
  char opc;
  carrega();
  do
  {
    textcolor(15);
    clrscr();
    textcolor(10);
    gotoxy(15,2);    cprintf("Exemplo simples do uso de Impressora e Arquivo");
    gotoxy(13,3);    cprintf("-----------------------------------------------------");
    printf("\n\n\t\t 1  --  Inserir Registro");
    printf("\n\n\t\t 2  --  Alterar Registro");
    printf("\n\n\t\t 3  --  Excluir Registro");
    printf("\n\n\t\t 4  --  Visualizar Impressão");
    printf("\n\n\t\t 5  --  Imprimir Relatório de Registro");
    printf("\n\n\t\t 6  --  Gravar Dados no disco");
    gotoxy(17,17);    cprintf(" 7  --  Sair");
    gotoxy(13,19);    cprintf("-----------------------------------------------------");
    gotoxy(30,21);    printf("Opção [    ]");
    gotoxy(38,21);    opc=getchar();
    switch(opc)
    {
       case '1' :  insere();    break;
       case '2' :  altera();    break;
       case '3' :  exclui();    break;
       case '4' :  visualiza(); break;
       case '5' :  {
		     do
		     {
		       textcolor(15);
		       clrscr();
		       textcolor(10);
		       gotoxy(14,2)  cprintf("Escolha a impressora desejada e que esteja configurada");                      
                          gotoxy(11,3); cprintf("----------------------------------------------------------");
		       printf("\n\n\t\t 1  --  Impressora Matricial");
		       printf("\n\n\t\t 2  --  Impressora a Laser");
		       printf("\n\n\t\t 3  --  Impressora HP");
                          printf("\n\n\t\t 4  --  Cancelar Impressão");
		       gotoxy(11,13);   cprintf("----------------------------------------------------------");
                          gotoxy(30,19);   printf("Opção [    ]");
              gotoxy(38,19);   opc=getchar();
              switch (opc)
             {
                 case '1' : escolhe(); break;
                 case '2' : imprime_la();    break;
                 case '3' : imprime_hp();  break;
             }
     }while(opc !='4');
   } break;
     case '6' :  grava();     break;
   }
  }while (opc !='7');
}

// sub menu do menu de modo de impressão em matricial //

void escolhe()
{
 char opc;
 do
 {
   getchar();
   textcolor(15);
   clrscr();
   textcolor(10);
   gotoxy(28,2);   cprintf("Escolha do tipo de letra");
   gotoxy(13,3);   cprintf("-----------------------------------------------------");
   printf("\n\n\t\t  1  -- Default");
   printf("\n\t\t  2  -- Enfatizado");
   printf("\n\t\t  3  -- Elite");
   printf("\n\t\t  4  -- Condensado");
   printf("\n\t\t  5  -- Subscrito");
   printf("\n\t\t  6  -- Superescrito");
   printf("\n\t\t  7  -- Qualidade Carta (NLQ)");
   printf("\n\t\t  8  -- Itálico");
   printf("\n\t\t  9  -- Bold");
   printf("\n\t\t  0  -- Cancelar impressão");
   gotoxy(13,16);   cprintf("-----------------------------------------------------");
   gotoxy(30,18);   printf("Opção [    ]");
   gotoxy(38,18);
   opc=getchar();
   switch(opc)
   {
     case '1' : imprime_ma(); break;
     case '2' : l_enf(); imprime_ma(); break;
     case '3' : l_eli(); imprime_ma(); break;
     case '4' : l_con(); imprime_ma(); break;
     case '5' : l_sub(); imprime_ma(); break;
     case '6' : l_sup(); imprime_ma(); break;
     case '7' : l_nlq(); imprime_ma(); break;
     case '8' : l_ita(); imprime_ma(); break;
     case '9' : l_bol(); imprime_ma(); break;
    }
 }while (opc != '0');
}

// função que carrega registros do arquivo p/ memória //

int carrega()
{
  FILE *arq;
  if ((arq = fopen("ALUNOS.TXT", "r")) == NULL)
    return(0);
  do
  {
    atual+=1;
    fscanf(arq, "%s", &reg[atual].ra);
    fscanf(arq, "%s", &reg[atual].nome_aluno);
    fscanf(arq, "%s", &reg[atual].curso);
    fscanf(arq, "%s", &reg[atual].semestre);
  }while( !feof(arq));  // faça enquanto não for final de arquivo
  fclose(arq);
  return (0);
}

// função que grava os registros no arquivo //

int grava()
{
  int percorre=-1;
  FILE *arq;
  if ((arq = fopen("ALUNOS.TXT", "w")) == NULL)
  {
    printf("\n\nProblemas com o arquivo de trabalho!");
    getche();
    return(0);
  }
  do
  {
     percorre+=1;
     fprintf(arq,"\n%s",reg[percorre].ra);
     fprintf(arq,"\n%s",reg[percorre].nome_aluno);
     fprintf(arq,"\n%s",reg[percorre].curso);
     fprintf(arq,"\n%s",reg[percorre].semestre);
  }while(percorre != atual);
  fclose(arq);
  return(0);
}

// função p/ inserir registros no vetor //

void insere()
{
  int confere;
  atual+=1;
  getchar();
  textcolor(15);
  clrscr();
  textcolor(9);
  gotoxy(30,2);  cprintf("Inserção de Registros");
  gotoxy(15,3);  cprintf("----------------------------------------------------");
  gotoxy(15,15);  cprintf("----------------------------------------------------");
  do
  {
    gotoxy(43,7);    printf("                  ");
    gotoxy(20,7);    printf("Ra do aluno.......[09]:");
    gets(reg[atual].ra);
    confere=strlen(reg[atual].ra);
  }while (confere >= 10);
  do
  {
    gotoxy(43,9);    printf("                                    ");
    gotoxy(20,9);    printf("Nome do aluno.....[30]:");
    gets(reg[atual].nome_aluno);
    confere=strlen(reg[atual].nome_aluno);
  }while (confere >= 31);
  do
  {
    gotoxy(43,11);    printf("                           ");
    gotoxy(20,11);    printf("Curso do aluno....[10]:");
    gets(reg[atual].curso);
    confere=strlen(reg[atual].curso);
  }while (confere >= 11);
  do
  {
    gotoxy(43,13);    printf("                  ");
    gotoxy(20,13);    printf("Semestre atual....[02]:");
    gets(reg[atual].semestre);
    confere=strlen(reg[atual].semestre);
  }while (confere >= 3);
}

// função p/ alterar os registros do vetor //

int altera( )
{
  char registro[9]="00000000",conf;
  char ra[9],nome[30],curso[10],semestre[2];
  int pesquisa=0,confere;
  getchar();
  textcolor(15);
  clrscr();
  textcolor(12);
  gotoxy(30,2);  cprintf("Alteração de Registros");
  gotoxy(15,3);  cprintf("----------------------------------------------------");
  if (atual == -1)
  {
    textcolor(12);
    gotoxy(20,14);    cprintf("********************************************");
    gotoxy(20,15);    cprintf("**  Não existe Registro Cadastrados ainda **");
    gotoxy(20,16);    cprintf("********************************************");
    getch();
    return(0);
  }
  gotoxy(20,5);  printf("Informe o RA a ser alterado...: "); gets(registro);
  do
{
    if (strcmp(registro,reg[pesquisa].ra)==0)
    {
      gotoxy(20,9);        cprintf("Ra do aluno.......: %s",reg[pesquisa].ra);
      gotoxy(20,10);      cprintf("Nome do aluno.....: %s",reg[pesquisa].nome_aluno);
      gotoxy(20,11);      cprintf("Curso do aluno....: %s",reg[pesquisa].curso);
      gotoxy(20,12);      cprintf("Semestre atual....: %s",reg[pesquisa].semestre);
      textcolor(9);
      gotoxy(15,14);      cprintf("--------------- Informe novo conteúdo --------------");
      do
      {
	gotoxy(38,16);	printf("                  ");
	gotoxy(15,16);	printf("Ra do aluno.......[09]:");
	scanf("%s",&ra);
	confere=strlen(ra);
      }while (confere >= 10);
      do
      {
	gotoxy(38,17);	printf("                                    ");
	gotoxy(15,17);	printf("Nome do aluno.....[30]:");
	scanf("%s",&nome);
	confere=strlen(nome);
      }while (confere >= 31);
      do
      {
	gotoxy(38,18);	printf("                           ");
	gotoxy(15,18);	printf("Curso do aluno....[10]:");
	scanf("%s",&curso);
	confere=strlen(curso);
      }while (confere >= 11);
      do
      {
	gotoxy(38,19);	printf("                  ");
	gotoxy(15,19);	printf("Semestre atual....[02]:");
	scanf("%s",&semestre);
	confere=strlen(semestre);
      }while (confere >= 3);
      gotoxy(15,21);      printf("-----------------------------------------------------");
      do
      {
	gotoxy(20,22)	cprintf("Confirma Alteração <S/N> ?");
	conf=getchar();
      }while( (toupper(conf) != 'S') && (toupper(conf) != 'N'));      if(toupper(conf) == 'S')
      
strcpy(reg[pesquisa].ra,ra);
	strcpy(reg[pesquisa].nome_aluno,nome);
	strcpy(reg[pesquisa].curso,curso);
	strcpy(reg[pesquisa].semestre,semestre);
	gotoxy(13,23);	printf("Alteração efetuada com sucesso... tecle algo p/ cont.");
         getch();
      }
      return(0);
    }
    pesquisa+=1;
  }while(pesquisa <= atual);
  gotoxy(20,14);  cprintf("*******************************");
  gotoxy(20,15);  cprintf("**  Registro não encontrado  **");
  gotoxy(20,16);  cprintf("*******************************");
  getch();
  return(0);
}

// função p/ excluir registros //

int exclui( )
{
  char registro[9]="00000000",conf;
  int pesquisa=0,prox;
  getchar();
  clrscr();
  textcolor(12);
  gotoxy(30,2);  cprintf("Exclusão de Registros");
  gotoxy(15,3);  cprintf("----------------------------------------------------");
  if(atual == -1)
  {
    textcolor(12);
    gotoxy(20,14);    cprintf("********************************************");
    gotoxy(20,15);    cprintf("**  Não existe Registro Cadastrados ainda **");
    gotoxy(20,16);    cprintf("********************************************");
    getch();
    return(0);
  }
  gotoxy(20,5);  printf("Informe o RA a ser Excluído...: "); gets(registro);
  do
{
    if (strcmp(registro,reg[pesquisa].ra)==0)
    {
      textcolor(12);
      gotoxy(15,7);      cprintf("*****************  Registro atual  *****************");
      gotoxy(20,9);      cprintf("Ra do aluno.......: %s",reg[pesquisa].ra);
      gotoxy(20,10);      cprintf("Nome do aluno.....: %s",reg[pesquisa].nome_aluno);
      gotoxy(20,11);      cprintf("Curso do aluno....: %s",reg[pesquisa].curso);
      gotoxy(20,12);      cprintf("Semestre atual....: %s",reg[pesquisa].semestre);
      gotoxy(15,16);      cprintf("*****************  Registro atual  *****************");
      do
      {
	gotoxy(25,18);	printf("Confirma Exclusão ??? < S/N >");
	conf=getchar();
      }while( (toupper(conf) != 'S') && (toupper(conf) != 'N'));

      if(toupper(conf) == 'N')
      return(0);
      atual-=1;
      prox=pesquisa+1;
      do
      {
	strcpy(reg[pesquisa].ra,reg[prox].ra);
	strcpy(reg[pesquisa].nome_aluno,reg[prox].nome_aluno);
	strcpy(reg[pesquisa].curso,reg[prox].curso);
	strcpy(reg[pesquisa].semestre,reg[prox].semestre);
	pesquisa+=1;
	prox+=1;
      }while(pesquisa <= atual);
      gotoxy(18,20);      printf("---------- Elemento excluído ---------");
      gotoxy(18,21);      printf("**************************************");
      getch();
      return(0);
    }
    pesquisa+=1;
  }while(pesquisa != atual);
  gotoxy(20,14);  cprintf("*******************************");
  gotoxy(20,15);  cprintf("**  Registro não encontrado  **");
  gotoxy(20,16);  cprintf("*******************************");
  getch();
  return(0);
}

// função p/ visualizar todos os registros do vetor //

void visualiza( )
{
  int pesquisa=0,line;
  getchar();
  clrscr();
  textcolor(12);
  gotoxy(30,2);  cprintf("Visualização de Registros");
  gotoxy(15,3);  cprintf("----------------------------------------------------");
  if(atual == -1)
  {
    textcolor(12);
    gotoxy(20,14);    cprintf("********************************************");
    gotoxy(20,15);    cprintf("**  Não existe Registro Cadastrados ainda **");
    gotoxy(20,16);    cprintf("********************************************");
    getch();
  }
  do
  {
    line=1;
    clrscr();
    textcolor(9);
    gotoxy(2,line);cprintf("----------------------------- Registros alocados -----------------------------");
    textcolor(14);
    do
    {
      line+=1;
      gotoxy(2,line);        cprintf("RA.:%s",reg[pesquisa].ra);
      gotoxy(19,line);      cprintf("Nome.:%s",reg[pesquisa].nome_aluno);
      gotoxy(55,line);      cprintf("Curso.:%s",reg[pesquisa].curso);
      gotoxy(70,line);      cprintf("Sem.:%s",reg[pesquisa].semestre);
      pesquisa+=1;
    }while( (pesquisa <= atual) && (line <= 21) );
    if(line >= 21)
    {
      textcolor(9);
      gotoxy(2,23);      cprintf("-----------------------------------------------------------------------------");
      gotoxy(25,24);      cprintf("Pressione enter p/ continuar a visualização");
      getch();
      clrscr();
    }
    else
    {
      gotoxy(2,line+2); cprintf("-----------------------------------------------------------------------------");
      printf("\n\t\t\tfinal do relatório");
      getch();
    }
  }while(pesquisa <= atual);
}

// função para fazer impressão em impressoras jato de tinta //

void imprime_hp()
{
  int pesquisa=0;
  do
  {
    int line=2;
    fprintf(stdprn,"\r----------------------Relatório de Registros alocados -----------------------------");
    textcolor(14);
    do
    {
      line+=2;
      fprintf(stdprn,"\n\n\rRA.:%s",reg[pesquisa].ra);
      espaco(reg[pesquisa].ra,15,4);
      fprintf(stdprn,"Nome.:%s",reg[pesquisa].nome_aluno);
      espaco(reg[pesquisa].nome_aluno,51,20);
      fprintf(stdprn,"Curso.:%s",reg[pesquisa].curso);
      espaco(reg[pesquisa].curso,69,58);
      fprintf(stdprn,"Sem.:%s",reg[pesquisa].semestre);
      pesquisa+=1;
    }while( (pesquisa <= atual) && (line <= 56) );
    if(line >= 56)
    {
       fprintf(stdprn,"\r\n---------------------------------------------------------------------------->>>>");
      fprintf(stdprn,"\r\n\t\t Formulário continua");
      fprintf(stdprn,"\f");
    }
    else
    {
      fprintf(stdprn,"\r\n-------------------------------------------------------------------------------");
      fprintf(stdprn,"\r\n\t\t\tFinal do Relatório");
    }
  }while(pesquisa <= atual);
  printf("\nEnviando p/ Impressora");
  delay(800);
}

// função para fazer impressão em impressoras laser //

void imprime_la()
{
  int pesquisa=0;
  do
  {
    int line=2;
    fprintf(stdprn,"\r----------------------Relatório de Registros alocados -----------------------------");
    textcolor(14);
    do
    {
      line+=2;
      fprintf(stdprn,"\n\n\rRA.:%s",reg[pesquisa].ra);
      espaco(reg[pesquisa].ra,15,4);
      fprintf(stdprn,"Nome.:%s",reg[pesquisa].nome_aluno);
      espaco(reg[pesquisa].nome_aluno,51,20);
      fprintf(stdprn,"Curso.:%s",reg[pesquisa].curso);
      espaco(reg[pesquisa].curso,69,58);
      fprintf(stdprn,"Sem.:%s",reg[pesquisa].semestre);
      pesquisa+=1;
    }while( (pesquisa <= atual) && (line <= 60) );
    if(line >= 56)
    {
      fprintf(stdprn,"\r\n--------------------------------------------------------------------------->>>>");
      fprintf(stdprn,"\r\n\t\t Formulário continua");
      fprintf(stdprn,"\f");
    }
    else
    {
      fprintf(stdprn,"\r\n-------------------------------------------------------------------------------");
      fprintf(stdprn,"\r\n\t\t\tFinal do Relatório");
    }
  }while(pesquisa <= atual);
  printf("\nEnviando p/ Impressora");
  delay(800);
}
// função para fazer impressão em impressoras matriciais //

void imprime_ma()
{
  int pesquisa=0;
  do
  {
    int line=2;
    fprintf(stdprn,"\r----------------------Relatório de Registros alocados ----------------------------")
    textcolor(14);
    do
    {
      line+=2;
      fprintf(stdprn,"\n\n\rRA.:%s",reg[pesquisa].ra);
      espaco(reg[pesquisa].ra,15,4);
      fprintf(stdprn,"Nome.:%s",reg[pesquisa].nome_aluno);
      espaco(reg[pesquisa].nome_aluno,51,20);
      fprintf(stdprn,"Curso.:%s",reg[pesquisa].curso);
      espaco(reg[pesquisa].curso,69,58);
      fprintf(stdprn,"Sem.:%s",reg[pesquisa].semestre);
      pesquisa+=1;
    }while( (pesquisa <= atual) && (line <= 60) );
    if(line >= 56)
   {
      fprintf(stdprn,"\r\n--------------------------------------------------------------------------->>>>");
      fprintf(stdprn,"\r\n\t\t Formulário continua");
      fprintf(stdprn,"\f");
    }
    else
   {
      fprintf(stdprn,"\r\n-------------------------------------------------------------------------------");
      fprintf(stdprn,"\r\n\t\t\tFinal do Relatório");
    }
  }while(pesquisa <= atual);
  printf("\nEnviando p/ Impressora");
  delay(800);
  imp(27);imp(64); // recupera o formato da letra default
}

/* função abaixo é utilizada para deixar espaços em branco no relatório de tal forma que o valor calculado irá retornar o número de colunas preenchidas até determinada string */ 

void espaco( char palavra[], int posicao, int valor)
{
  int espaco=0,tamanho=0;
  tamanho=strlen(palavra);
  espaco=posicao-(valor+tamanho);
  do
  {
    fprintf(stdprn," ");
    espaco-=1;
  }while (espaco != 0);
}

// função que irá receber os códigos para que seja efetuada a mudança da fonte. 
imp(char ch)
{
 biosprint(0,ch,0);
}
// segue abaixo as funções que determinam a fonte utilizada na impressão, só para  impressoras //matriciais

void l_enf()
{
 imp(27);imp(69);
}
void l_eli()
{
 imp(270);imp(77);
}

void l_con()
{
 imp(27);imp(15);
}

void l_sub()
{
 imp(27);imp(83);imp(1);
}

void l_sup()
{
 imp(27);imp(83);imp(0);
}
void l_nlq()
{
 imp(27);imp(120);imp(1);
}
void l_ita()
{
 imp(27);imp(52);
}
void l_bol()
{
 imp(27);imp(71);
}