C/LLAVE
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

First commit 10/06/1992

Browse Source
This commit is contained in:
José David Guillén
2021-09-08 21:27:06 +02:00
commit b4ad5f43f2
13 changed files with 2039 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

758
LLAVE.CPP Normal file
View File

@ -0,0 +1,758 @@
#define SEC_OPTAR 2
#define ENCUADRE 3
#include <math.h>
#include <io.h>
#include <dos.h>
#include <time.h>
#include <stdio.h>
#include <conio.h>
#include <alloc.h>
#include <string.h>
#include <stdlib.h>
#include <graphics.h>
#include "..\libs\make_bot\make_bot.h" // Fuciones de MAKE_BOTON
#define PULSO_QUE_CABEN 48
#define ANCHO_PULSO 12
#define ALTO_PULSO 12
extern void ponicono(int x,int y,char matriz[18][18], char pos);
extern char flecha [18] [18];
typedef struct
{
int x, y; // Coordenadas iniciales de muestreo
char ndigitos; // n<>mero de digitos a mostrar
char AX, AY; // factor de espaciado
char C1, C2, C3; // colores de fondo, texto, borde
// Datos privados y uso interno exclusivamente
unsigned int Flen; // longitud de la frase actual
char BitByte; // bit del byte por el que va en el recorrido
char currByte; // byte actual dentro de la frase
} p_Ampliada;
#define OFF 0
#define ON 1
#ifdef __cplusplus
#define __CPPARGS ...
#else
#define __CPPARGS
#endif
#define INTR 0X1C /* The clock tick interrupt */
char count = 0, intvect = OFF, IntVect = OFF;
extern int Optar( int optar, ...);
void AnulaInterrupcion(void);
void interrupt handler(__CPPARGS);
void interrupt ( *oldhandler)(__CPPARGS);
char *ptr_char;
void DibujaPulsos( long comienzo, char bit, char far *Datos, int x, int y, char color, long TotalPulsos );
void LeeFuentes(char *file);
void Fuente_Amplia( char *Frase, p_Ampliada far *FA );
void DibujaFondo(void);
void DibujaSeparadores( int X1, int Y1, int X2, int Y2, char color );
void Error( int code, char *MensajeError );
void BorraPantalla(void);
void ComienzaRutina(void);
extern char file_browser( char *comodin_name, char *texto1, char Cargar_Salvar );
long InicioPulso[6][2];
void CargarOnda( char *file, char far *Datos, char Ventana );
void SalvarOnda( char *file, char far *Datos, char Ventana );
char far *Datos[2];
int TiempoEspera = 5, DIR_LPT = 0x378, ANGULO = 0;
int main( int argc, char *argv[] )
{
int i;
long j;
char buffer[4][80] = { "Jos<EFBFBD> David Guill<6C>n || _-<2D>FuTuRe ViSiOn<4F>-_ || 1996 (c)",
" ",
" e-mail: Jose-David.Guillen@cs.us.es ",
" " };
if ( argc == 2 )
{
TiempoEspera = atoi(argv[1]);
if ( TiempoEspera < 0 || TiempoEspera > 1000 )
TiempoEspera = 5;
}
if ( argc == 3 )
{
DIR_LPT = atoi( argv[2] );
if ( DIR_LPT < 0 )
DIR_LPT = 0x379;
}
if ( argc == 4 )
{
ANGULO = atoi( argv[3] );
if ( ANGULO < 0 )
ANGULO = 0;
}
if ( atexit( AnulaInterrupcion ) != 0 )
intvect = OFF;
else
intvect = ON;
True_Push = ON; PunteroRaton = 1;
Initialize( 9, 2 ); // Inicializa el Modo Gr<47>fico
inicializa_raton_grafico( 0, 0, 639, 479 );
setrgbpalette(EGA_WHITE, 56, 58, 59 );
setrgbpalette(EGA_LIGHTGRAY, 30, 37, 43 );
setrgbpalette(EGA_DARKGRAY, 24, 27, 30 );
if ( carga_botones( "llave.img" ) != OK ) Error( 0x03, "Make Boton, no pudo cargar los botones" );
if ( ( Datos[0] = (char far *)farcalloc( 100000, sizeof(char) ) ) == NULL )
{
Optar( 0, "ERROR DE MEMORIA", "Memoria insuficiente", "para la primera forma", "de onda.", NULL );
closegraph();
return -1;
}
if ( ( Datos[1] = (char far *)farcalloc( 100000, sizeof(char) ) ) == NULL )
{
farfree( Datos[0] );
Optar( 0, "ERROR DE MEMORIA", "Memoria insuficiente", "para la segunda forma", "de onda.", NULL );
closegraph();
return -1;
}
_fmemcpy( Datos[0], &i, 50000 );
if ( intvect == ON )
{
// save the old interrupt vector
oldhandler = getvect(INTR);
// install the new interrupt handler
setvect(INTR, handler);
IntVect = ON;
}
if ( ( ptr_char = ( char *)malloc( sizeof(char)*4096 ) ) == NULL )
Error( 0x06, "Error inicializando Memoria, fuentes" );
LeeFuentes("llave.fnt");
DibujaFondo();
ComienzaRutina();
BorraPantalla();
free( ptr_char );
AnulaInterrupcion();
closegraph();
printf( "\n%s", buffer[0] );
printf( "\n%s", buffer[1] );
printf( "\n%s", buffer[2] );
printf( "\n%s", buffer[3] );
farfree( Datos[0] );
farfree( Datos[1] );
return 0;
}
void ComienzaRutina(void)
{
int ok, BPush, VentanaActiva, i, j;
long DLectura;
char buffer[280];
// Temporal hasta que existan datos reales...
/*
Datos[0] = (char *)&ok;
Datos[1] = (char *)&ok;
*/
VentanaActiva = 0;
for ( j = 0; j < 2; j++ )
for ( i = 0; i < 5; i++ )
InicioPulso[i][j] = 0;
InicioPulso[5][0] = 100000;
InicioPulso[5][1] = 100000;
DibujaSeparadores( 63, 27, 630, 193, EGA_RED );
DibujaSeparadores( 63, 27 + 250, 630, 193 + 250, EGA_RED );
// Borramos los pulsos anteriores, y los desplazamos
for ( j = 0; j < 5; j ++ )
{
DibujaPulsos( InicioPulso[j][0], 0x01 << j, Datos[0], 63, 42 + 30*j + 0, EGA_GREEN, InicioPulso[5][0] );
DibujaPulsos( InicioPulso[j][1], 0x01 << j, Datos[1], 63, 42 + 30*j + 250, EGA_GREEN, InicioPulso[5][1] );
}
// Flecha hacia arriba
ponicono( 20, 225, flecha, 2 );
ok = 0;
do {
// Actualiza todos los puntos
setfillstyle( SOLID_FILL, EGA_BLACK );
setcolor( EGA_WHITE );
for ( i = 0; i < 2; i++ )
for ( j = 0; j < 5; j++ )
{
bar( 12, 42+31*j + 250*i, 52, 53+31*j + 250*i );
sprintf( buffer, "%7ld", InicioPulso[j][i] );
outtextxy( 12, 41 + 31*j + 250*i, buffer );
}
BPush = Comprueba_Secuencia( 1, NULL );
switch( BPush )
{
case -2:
case -1:
case -0:
while( kbhit() ) getch();
break;
// Salir
case 1:
ok = 1;
break;
// Cambio de Ventana
case 2:
VentanaActiva = !VentanaActiva;
// Flecha hacia arriba
ponicono( 20, 225, flecha, VentanaActiva == 0 ? 2 : 4 );
break;
// Desplazamiento de ondas (IZQUIERDA )
case 3:
case 4:
case 5:
case 6:
case 7:
InicioPulso[BPush-3][VentanaActiva] --;
if ( InicioPulso[BPush-3][VentanaActiva] < 0 )
{
InicioPulso[BPush-3][VentanaActiva] = 0;
} else {
// Borramos la onda anterior
DibujaPulsos( InicioPulso[BPush-3][VentanaActiva] + 1, 0x01 << (BPush - 3), Datos[VentanaActiva], 63, 42 + 30*(BPush-3) + ( VentanaActiva ? 250 : 0 ), EGA_BLACK, InicioPulso[5][VentanaActiva] );
// Dibujamos la nueva onda
DibujaPulsos( InicioPulso[BPush-3][VentanaActiva], 0x01 << (BPush - 3), Datos[VentanaActiva], 63, 42 + 30*(BPush-3) + ( VentanaActiva ? 250 : 0 ), EGA_GREEN, InicioPulso[5][VentanaActiva] );
}
break;
// Desplazamiento de ondas (DERECHA)
case 8:
case 9:
case 10:
case 11:
case 12:
InicioPulso[BPush-8][VentanaActiva] ++;
if ( InicioPulso[BPush-8][VentanaActiva] > InicioPulso[5][VentanaActiva] )
{
InicioPulso[BPush-8][VentanaActiva] --;
} else {
// Borramos la onda anterior
DibujaPulsos( InicioPulso[BPush-8][VentanaActiva] - 1, 0x01 << (BPush - 8), Datos[VentanaActiva], 63, 42 + 30*(BPush-8) + (VentanaActiva ? 250 : 0), EGA_BLACK, InicioPulso[5][VentanaActiva] );
// Dibujamos la nueva onda
DibujaPulsos( InicioPulso[BPush-8][VentanaActiva], 0x01 << (BPush - 8), Datos[VentanaActiva], 63, 42 + 30*(BPush-8) + (VentanaActiva ? 250 : 0), EGA_GREEN, InicioPulso[5][VentanaActiva] );
}
break;
// Desplazamiento de pulsos TODAS (IZQUIERDA)
case 13:
// Borramos los pulsos anteriores, y los desplazamos
for ( j = 0; j < 5; j ++ )
{
DibujaPulsos( InicioPulso[j][VentanaActiva], 0x01 << j, Datos[VentanaActiva], 63, 42 + 30*j + ( VentanaActiva ? 250 : 0 ), EGA_BLACK, InicioPulso[5][VentanaActiva] );
InicioPulso[j][VentanaActiva]--;
if ( InicioPulso[j][VentanaActiva] < 0 )
InicioPulso[j][VentanaActiva] = 0;
}
DibujaSeparadores( 63, 27 + (VentanaActiva ? 250 : 0 ), 630, 193 + (VentanaActiva ? 250 : 0 ), EGA_RED );
// Dibujamos los nuevos pulsos.
for ( j = 0; j < 5; j ++ )
DibujaPulsos( InicioPulso[j][VentanaActiva], 0x01 << j, Datos[VentanaActiva], 63, 42 + 30*j + ( VentanaActiva ? 250 : 0 ), EGA_GREEN, InicioPulso[5][VentanaActiva] );
break;
// Reset de todos los pulsos
case 14:
// Borramos los pulsos anteriores, y los reseteamos
for ( j = 0; j < 5; j ++ )
{
DibujaPulsos( InicioPulso[j][VentanaActiva], 0x01 << j, Datos[VentanaActiva], 63, 42 + 30*j + ( VentanaActiva ? 250 : 0 ), EGA_BLACK, InicioPulso[5][VentanaActiva] );
InicioPulso[j][VentanaActiva] = 0;
}
DibujaSeparadores( 63, 27 + (VentanaActiva ? 250 : 0 ), 630, 193 + (VentanaActiva ? 250 : 0 ), EGA_RED );
// Dibujamos los nuevos pulsos.
for ( j = 0; j < 5; j ++ )
DibujaPulsos( InicioPulso[j][VentanaActiva], 0x01 << j, Datos[VentanaActiva], 63, 42 + 30*j + ( VentanaActiva ? 250 : 0 ), EGA_GREEN, InicioPulso[5][VentanaActiva] );
break;
// Al final de todos los pulso
case 15:
// Borramos los pulsos anteriores, nos colocamos al final
for ( j = 0; j < 5; j ++ )
{
DibujaPulsos( InicioPulso[j][VentanaActiva], 0x01 << j, Datos[VentanaActiva], 63, 42 + 30*j + ( VentanaActiva ? 250 : 0 ), EGA_BLACK, InicioPulso[5][VentanaActiva] );
InicioPulso[j][VentanaActiva] = InicioPulso[5][VentanaActiva] - PULSO_QUE_CABEN;
}
DibujaSeparadores( 63, 27 + (VentanaActiva ? 250 : 0 ), 630, 193 + (VentanaActiva ? 250 : 0 ), EGA_RED );
// Dibujamos los nuevos pulsos.
for ( j = 0; j < 5; j ++ )
DibujaPulsos( InicioPulso[j][VentanaActiva], 0x01 << j, Datos[VentanaActiva], 63, 42 + 30*j + ( VentanaActiva ? 250 : 0 ), EGA_GREEN, InicioPulso[5][VentanaActiva] );
break;
// Desplazamiento de pulsoso TODOS (Derecha)
case 16:
// Borramos los pulsos anteriores, y los desplazamos
for ( j = 0; j < 5; j ++ )
{
DibujaPulsos( InicioPulso[j][VentanaActiva], 0x01 << j, Datos[VentanaActiva], 63, 42 + 30*j + ( VentanaActiva ? 250 : 0 ), EGA_BLACK, InicioPulso[5][VentanaActiva] );
InicioPulso[j][VentanaActiva]++;
if ( InicioPulso[j][VentanaActiva] > InicioPulso[5][VentanaActiva] )
InicioPulso[j][VentanaActiva]--;
}
DibujaSeparadores( 63, 27 + (VentanaActiva ? 250 : 0 ), 630, 193 + (VentanaActiva ? 250 : 0 ), EGA_RED );
// Dibujamos los nuevos pulsos.
for ( j = 0; j < 5; j ++ )
DibujaPulsos( InicioPulso[j][VentanaActiva], 0x01 << j, Datos[VentanaActiva], 63, 42 + 30*j + ( VentanaActiva ? 250 : 0 ), EGA_GREEN, InicioPulso[5][VentanaActiva] );
break;
// CARGAR
case 17:
for ( j = 0; j < 5; j ++ )
{
DibujaPulsos( InicioPulso[j][0], 0x01 << j, Datos[0], 63, 42 + 30*j + 0, EGA_BLACK, InicioPulso[5][0] );
DibujaPulsos( InicioPulso[j][1], 0x01 << j, Datos[1], 63, 42 + 30*j + 250, EGA_BLACK, InicioPulso[5][1] );
}
strcpy( buffer, "*.llv" );
if ( file_browser( buffer, "Cargar Archivo", 0 ) )
CargarOnda( buffer, Datos[VentanaActiva], VentanaActiva );
DibujaSeparadores( 63, 27, 630, 193, EGA_RED );
DibujaSeparadores( 63, 27 + 250, 630, 193 + 250, EGA_RED );
for ( j = 0; j < 5; j ++ )
{
DibujaPulsos( InicioPulso[j][0], 0x01 << j, Datos[0], 63, 42 + 30*j + 0, EGA_BLACK, InicioPulso[5][0] );
DibujaPulsos( InicioPulso[j][1], 0x01 << j, Datos[1], 63, 42 + 30*j + 250, EGA_BLACK, InicioPulso[5][1] );
}
break;
// SALVAR
case 18:
strcpy( buffer, "*.llv" );
if ( file_browser( buffer, "Salvar Archivo", 1 ) )
SalvarOnda( buffer, Datos[VentanaActiva], VentanaActiva );
break;
// LEER ONDA
case 19:
for ( j = 0; j < 5; j ++ )
{
DibujaPulsos( InicioPulso[j][0], 0x01 << j, Datos[0], 63, 42 + 30*j + 0, EGA_BLACK, InicioPulso[5][0] );
DibujaPulsos( InicioPulso[j][1], 0x01 << j, Datos[1], 63, 42 + 30*j + 250, EGA_BLACK, InicioPulso[5][1] );
}
Optar( 0, "Lectura de Onda", "Prepare el chisme, y", "pulse una tecla cuando este", "preparado...", NULL );
Optar( ENCUADRE, "Leyendo Onda", "Presione una cualquier", "tecla para interrumpir el", "proceso...", NULL );
outportb( DIR_LPT + 0, 0xFF );
outportb( DIR_LPT + 1, 0x01 );
// Comienza lectura
for ( DLectura=0; DLectura < InicioPulso[5][VentanaActiva] && !kbhit(); DLectura++ )
{
Datos[VentanaActiva][DLectura] = inportb( DIR_LPT );
sin( ANGULO );
delay(TiempoEspera);
}
while( kbhit() ) getch();
Optar( ENCUADRE, NULL );
DibujaSeparadores( 63, 27, 630, 193, EGA_RED );
DibujaSeparadores( 63, 27 + 250, 630, 193 + 250, EGA_RED );
// Borramos los pulsos anteriores, y los desplazamos
for ( j = 0; j < 5; j ++ )
{
DibujaPulsos( InicioPulso[j][0], 0x01 << j, Datos[0], 63, 42 + 30*j + 0, EGA_GREEN, InicioPulso[5][0] );
DibujaPulsos( InicioPulso[j][1], 0x01 << j, Datos[1], 63, 42 + 30*j + 250, EGA_GREEN, InicioPulso[5][1] );
}
break;
}
}while ( !ok );
}
void CargarOnda( char *file, char far *Datos, char Ventana )
{
FILE *file_in;
int i;
char buffer[80];
struct CABECERA
{
long DPulsos[6];
} Cabecera;
if ( ( file_in = fopen( file, "rb" ) ) != NULL )
{
fread( &Cabecera, sizeof( CABECERA ), 1, file_in );
farfree( Datos );
if ( ( Datos = (char far *)farmalloc( sizeof(char)*Cabecera.DPulsos[5] ) ) == NULL )
{
sprintf( buffer, "longitud %ld bytes.", (long)(sizeof(char)*Cabecera.DPulsos[5]) );
Optar( 0, "ATENCION !!!", "No hay suficiente memoria", "no pude cargar el pulso", buffer, NULL );
for ( i = 0; i < 6; i++ )
Cabecera.DPulsos[i] = 0;
} else {
fseek( file_in, sizeof( CABECERA ), SEEK_SET );
fread( Datos, sizeof(char), Cabecera.DPulsos[5], file_in );
}
for ( i = 0; i < 6; i++ )
InicioPulso[i][Ventana] = Cabecera.DPulsos[i];
fclose(file_in);
}
}
void SalvarOnda( char *file, char far *Datos, char Ventana )
{
FILE *file_out;
int i;
struct CABECERA
{
long DPulsos[6];
} Cabecera;
if ( ( file_out = fopen( file, "wb" ) ) != NULL )
{
for ( i = 0; i < 6; i++ )
Cabecera.DPulsos[i] = InicioPulso[i][Ventana];
fwrite( &Cabecera, sizeof( CABECERA ), 1, file_out );
fseek( file_out, sizeof( CABECERA ), SEEK_SET );
fwrite( Datos, sizeof(char), Cabecera.DPulsos[5], file_out );
fclose(file_out);
}
}
void BorraPantalla(void)
{
int CLS;
setcolor( 0 );
randomize();
switch( random(4)+1 )
{
case 1:
for ( CLS = 0; CLS < 640; CLS+=2 )
{
line( CLS, 0, CLS, 479 );
line( 639-CLS, 0, 639-CLS, 479 );
delay( 10 );
}
break;
case 2:
for ( CLS = 0; CLS < 480; CLS+=2 )
{
line( 0, CLS, 639, CLS );
line( 0, 479-CLS, 639, 479-CLS );
delay( 10 );
}
break;
case 3:
for ( CLS = 0; CLS < 640*2; CLS+=2 )
{
line( 639-CLS, 0, 639 , CLS );
line( CLS, 479, 0, 480-CLS );
delay( 10 );
}
break;
case 4:
for ( CLS = 0; CLS < 640*2; CLS+=2 )
{
line( CLS, 0, 0, CLS );
line( 640-CLS, 479, 639, 480-CLS );
delay( 10 );
}
break;
}
}
void DibujaPulsos( long comienzo, char And_bit, char far *Datos, int x, int y, char color, long TotalPulsos )
{
long Pulso;
// seleccionamos el color de usuario
setcolor( color );
y += ALTO_PULSO + 5;
// moveto( x, y + ( comienzo > 0 ? ( ( Datos[comienzo-1] & And_bit ) ? ALTO_PULSO : 0 ) : 0 ) );
moveto( x, y - ( comienzo > 0 ? ( ( Datos[comienzo] & And_bit ) ? ALTO_PULSO : 0 ) : 0 ) );
for ( Pulso = comienzo; Pulso < ( comienzo + PULSO_QUE_CABEN ) & Pulso < TotalPulsos; Pulso++, x+=ANCHO_PULSO )
{
lineto( x, y - ( ( Datos[Pulso] & And_bit ) ? ALTO_PULSO : 0 ) );
lineto( x, y - ( ( Datos[Pulso+1] & And_bit ) ? ALTO_PULSO : 0 ) );
}
}
void DibujaSeparadores( int X1, int Y1, int X2, int Y2, char color )
{
setcolor( color );
setlinestyle( CENTER_LINE, 0, NORM_WIDTH );
for ( ; X1 < X2; X1 += ANCHO_PULSO )
line( X1, Y1, X1, Y2 );
setlinestyle( SOLID_LINE, 0, NORM_WIDTH );
}
void DibujaFondo(void)
{
FILE *fp;
int alto, ancho; unsigned char byte; int contador; char BitMap[40][40];
int x, y, vez = -1;
if ( ( fp = fopen ( "1.PCX", "rb" ) ) != NULL )
{
// Saltamos la cabecera
fseek( fp, 128, SEEK_SET );
for(alto=0; alto<32; alto++)
{
for(ancho=0; ancho<32; )
{
byte=getc(fp);
if(byte<=0xC0)
{
if ( vez == -1 ) vez = byte;
BitMap[ancho%32][alto%32] = byte;
ancho++;
}
else
{
contador=byte&0x3F; byte=getc(fp);
for(; contador>0; contador--)
{
BitMap[ancho%32][alto%32] = byte;
ancho++;
}
}
}
}
// Rellenamos la pantalla con un fondo atractivo...
setfillstyle( SOLID_FILL, vez ); bar( 0, 0, 640, 480 );
for ( ancho = 0; ancho < 32; ancho++ )
for ( y = 0; y < 480; y+=35 )
for ( alto = 0; alto < 32; alto++ )
for ( x = 0; x < 640; x+=35 )
putpixel( x + ancho, y + alto, BitMap[ancho][alto] );
fclose( fp );
} else {
// Rellenamos la pantalla con un fondo atractivo...
setcolor( 1 );
setfillstyle( LTBKSLASH_FILL, 1 ); bar( 0, 0, 640, 480 );
}
Imprime_Estaticos( 10, "llave.img" );
/*
setfillstyle( SOLID_FILL, EGA_GREEN );
setcolor( 11 );
rectangle( 58, 23, 632, 197 );
*/
// & 58, 23, 632, 197, 0, 56, 63, 2, 2
// & 58, 273, 632, 447, 0, 56, 63, 2, 2
}
void AnulaInterrupcion(void)
{
/* reset the old interrupt handler */
if ( intvect == ON )
setvect(INTR, oldhandler);
intvect = OFF;
}
/***************************************************************************\
|* *|
|* INT CLK *|
|* *|
|* Descripci<63>n: *|
|* interrupci<63>n para el parpadeo de los led's *|
|* *|
|* Entradas: (indeterminadas) *|
|* *|
|* *|
|* *|
|* Salidas: (ninguna) *|
|* *|
\***************************************************************************/
void interrupt handler(__CPPARGS)
{
/* increase the global counter */
if ( IntVect == ON )
{
count = (count++)%16;
if ( count == 1 )
{
setpalette( 11, EGA_GREEN );
setpalette( 13, EGA_LIGHTGREEN );
}
else if ( count == 8 )
{
setpalette( 11, EGA_RED );
setpalette( 13, EGA_LIGHTRED );
}
}
/* call the old routine */
oldhandler();
}
void LeeFuentes(char *file)
{
FILE *fich;
/* Reservamos 4 Kb. para cargar la fuente en memoria */
/* Abrimos el fichero de la fuente */
if ((fich=fopen(file,"rb"))==NULL) {
printf("\a\nArchivo %s no encontrado.\n",file);
Error(0, "No se encuentra el archivo de fuentes");
}
fseek(fich, SEEK_SET, 0); /* Nos colocamos al principio del fichero */
fread(ptr_char,1,4096,fich); /* Cargamos en memoria 4096 bytes del fichero */
fclose(fich); /* Cerramos el fichero */
}
#define TAMx 8
#define TAMy 8
void Fuente_Amplia( char *Frase, p_Ampliada far *FA )
{
int i, j, k; // Variables de avance
int c_elec; // Color en el momento de imprimir
int PosX, PosY; // Posicion fisica final
char LCaract; // Caracter de linea a tratar
if ( FA->Flen != _fstrlen( Frase ) ) // Reseteamos las variables de control interno
{
// Obtenemos la longitud de la frase. ( En d<>gitos )
FA -> Flen = _fstrlen( Frase );
// Contador de digito actual a cero
FA -> BitByte = 0;
// Posicion dentro de la frase
FA -> currByte = 0;
}
// Avance horizontal de bit's ( avance de digitos )
for ( i = 0; i < ( TAMx * (FA -> ndigitos) ); i++ )
{
k = ( Frase[ ( (i+FA->BitByte)/TAMx + FA -> currByte ) % FA->Flen ] ) << 4;
LCaract = ( (char)0x01 << (7 - (i+FA->BitByte)%TAMx) );
PosX = FA -> x + FA->AX * i; // Posicion f<>sica horizontal
// Avance vertical de bit's
for ( j = 0; j < TAMy; j ++ )
{
PosY = FA -> y + FA->AY * j; // Posicion f<>sica vertical
if ( ptr_char[ k + j ] & LCaract )
c_elec = FA->C2;
else
c_elec = FA->C1;
putpixel ( PosX, PosY, c_elec );
}
}
// Tenemos en cuenta el avance dentro de la frase
if ( ( FA -> BitByte ++ ) >= 7 )
{
FA -> BitByte = 0; FA -> currByte ++;
if ( FA -> currByte >= FA -> Flen )
FA -> currByte = 0;
}
}
#undef TAMy
#undef TAMx
void Error( int code, char *MensajeError )
{
free( ptr_char );
AnulaInterrupcion();
restorecrtmode();
printf( "\nSe produjo un codigo de error %d, subcodigo no disponible ", code );
switch( code )
{
case 0:
printf( "\n Error Desconocido " );
break;
case 1:
printf( "\n BDatos gener<65> el error de salida. |ERROR DE ACCESO| " );
break;
case 2:
printf( "\n Make Boton gener<65> el error de salida " );
break;
case 3:
printf( "\n Fall<6C> en alg<6C>n punto del men<65> principal" );
break;
};
printf( "\n> %s_", MensajeError );
exit(code);
}