/**************************************************************************\
|* *|
|* Make_Boton (orientado a objetos) *|
|* *|
|* Descripcion: *|
|* Este es mi viejo proyecto, que espero ver hecho realidad, *|
|* es Make Boton, en objeto. *|
|* *|
|* *|
|* *|
|* *|
|* *|
\**************************************************************************/
#include <alloc.h>
#include <graphics.h>
#include "N_MB.HH"
#define JD_imagesize(int left, int top, int right, int bottom) (( (left > right) ? (left - right + 1) : ( right - left + 1) )*( ( top > bottom) ? ( top - bottom + 1) : (bottom - top + 1) )+4)
/**************************************************************************\
|* *|
|* MBoton *|
|* *|
|* Descripcion: *|
|* Consturctir de clase, inicializa todos los datos necesarios *|
|* *|
|* Entradas: (ninguna) *|
|* Salidas: (ninguna) *|
|* *|
\**************************************************************************/
MBoton::MBoton()
{
NSecuencias = 0; // N� de secuencias
True_Push = OFF; // Pulsado real ( apagado )
}
/**************************************************************************\
|* *|
|* MBoton *|
|* *|
|* Descripcion: *|
|* Desctuctor de clase *|
|* *|
|* Entradas: (ninguna) *|
|* Salidas: (ninguna) *|
|* *|
\**************************************************************************/
MBoton::~MBoton()
{
free( NBSecuencia );
farfree( Botones );
}
/**************************************************************************\
|* *|
|* ObtenNumero *|
|* *|
|* Descripcion: *|
|* Obtiene un numero del handle a fichero, y situa en ch el *|
|* �ltimo caracter leido *|
|* *|
|* Entradas: handle al fichero, recipiente donde guardar el caracter *|
|* *|
|* Salidas: n�mero leido del fichero *|
|* *|
\**************************************************************************/
long MBoton::ObtenNumero( FILE *handle, char *ch )
{
long numero;
char signo = 1;
numero = 0;
*ch=fgetc(handle);
while ( *ch != EOL && *ch != EOF && *ch != ',' )
{
if ( *ch >= '0' && *ch <= '9') numero = ( numero*10 + *ch - '0' );
else if ( *ch == '-' ) signo = -1;
*ch = fgetc(handle);
}
return numero * signo;
}
/**************************************************************************\
|* *|
|* CargarObjetos *|
|* *|
|* Descripcion: *|
|* Carga los objetos del fichero, que se pasa como par�metro. *|
|* *|
|* Entradas: Fichero donde se encuentran los objetos *|
|* *|
|* Salidas: OK / ERROR *|
|* *|
\**************************************************************************/
int MBoton::CargarObjetos( char *file )
{
FILE *handle;
char ch;
unsigned int temp_num;
int SiZe_BoToN = 0;
int inc_Botones = -1;
// Abrimos el archivo especificado
if ( ( handle == fopen( file, "r" ) ) == NULL )
{
lError = 0x01; Error( lError );
return ERROR;
}
// Liberamos cualquier memoria previa.
if ( Botones != NULL )
farfree ( Botones );
if ( NBSecuencia != NULL )
free ( NBSecuencia );
// Ahora cribamos los datos del fichero, y cargamos en memoria
// todos aquellos que son DINAMICOS
ch=fgetc(handle); //Lee el primer caracter
while (ch!=EOF) //Lee hasta fin de fichero
{
switch ( ch )
{
// Comentarios
case '*':
while (ch!=EOL && ch!=EOF) ch=fgetc(handle);
break;
// N�mero de secuencias
case '#':
Secuencias = ObtenNumero( handle, &ch );
if (( NBSecuencia = (int *) malloc( sizeof(int)*Secuencias ) ) == NULL)
{
fclose( handle );
lError = 0x05; Error( lError );
return ERROR;
}
break;
//Numero de Botones en la secuencia
case '!':
// Obtenemos la secuencia activa
temp_num = ObtenNumero( handle, &ch );
// N�mero de botones para esa secuencia
NBSecuencia[ temp_num - 1 ] = ObtenNumero( handle, &ch );
SiZe_BoToN += ( sizeof( struct Make_Boton ) * NBSecuencia[ temp_num - 1 ] );
if ( (Botones = (struct Make_Boton far *)farrealloc(Botones, SiZe_BoToN )) == NULL)
{
fclose( handle );
lError = 0x05; Error( lError );
return ERROR;
}
break;
//C�lculos del boton
case '$':
inc_Botones++;
Botones[ inc_Botones ]. Left = ObtenNumero( handle, &ch );
Botones [inc_Botones]. Up = ObtenNumero( handle, &ch );
Botones [inc_Botones]. Right = ObtenNumero( handle, &ch );
Botones [inc_Botones]. Down = ObtenNumero( handle, &ch );
Botones [inc_Botones]. Cdf = ObtenNumero( handle, &ch );
Botones [inc_Botones]. Cb1 = ObtenNumero( handle, &ch );
Botones [inc_Botones]. Cb2 = ObtenNumero( handle, &ch );
Botones [inc_Botones]. Ab = ObtenNumero( handle, &ch );
Botones [inc_Botones]. Pb = ObtenNumero( handle, &ch );
Botones [inc_Botones]. Isc = ObtenNumero( handle, &ch );
Botones [inc_Botones]. Sc = ObtenNumero( handle, &ch );
break;
}
if (ch != EOF) ch = fgetc(handle);
}
// Cerramos el fichero
fclose( handle );
return OK;
}
/**************************************************************************\
|* *|
|* ImprimeSecuencia *|
|* *|
|* Descripcion: *|
|* Imprime la secuencia dada, de botones previamente cargados *|
|* *|
|* Entradas: Secuencia a imprimir *|
|* Salidas: (ninguna) *|
|* *|
\**************************************************************************/
void MBoton::ImprimeSecuencia( int Secuencia )
{
int IniSecuencia, i;
IniSecuencia = PrincipioSecuencia( Secuencia - 1 );
for( i = 0; i<NBSecuencia[ Secuencia - 1 ]; i++)
ImprimeBoton( RELLENO, Botones[ IniSecuencia + i ] );
}
/**************************************************************************\
|* *|
|* DespliegaDatos *|
|* *|
|* Descripcion: *|
|* Despliega los datos sobre los botones cargados *|
|* *|
|* Entradas: (ninguna) *|
|* Salidas: (ninguna) *|
|* *|
\**************************************************************************/
void MBoton::DespliegaDatos(void)
{
int i, j, InicioSecuencia;
clrscr();
for ( i = 0; i <= NSecuencias; i++)
{
InicioSecuencia = PrincipioSecuencia( i );
for ( j = 0; j < NBSecuencia[ i ]; j++)
{
printf("!%d,%02d U/L/R/D: %d-%d-%d-%d, C: %d-%d-%d Ab/Pb %d-%d, Isc-Sc %03d%03d\n",
i, j,
Botones[InicioSecuencia+j].Up,
Botones[InicioSecuencia+j].Left,
Botones[InicioSecuencia+j].Right,
Botones[InicioSecuencia+j].Down,
Botones[InicioSecuencia+j].Cdf,
Botones[InicioSecuencia+j].Cb1,
Botones[InicioSecuencia+j].Cb2,
Botones[InicioSecuencia+j].Ab,
Botones[InicioSecuencia+j].Pb,
Botones[InicioSecuencia+j].Isc,
Botones[InicioSecuencia+j].Sc );
}
}
}
/**************************************************************************\
|* *|
|* MuestraEstaticos *|
|* *|
|* Descripcion: *|
|* Muestra los botones est�ticos correspondientes al fichero, *|
|* y secuencia dadas. *|
|* *|
|* Entradas: Fichero donde se encuentran los objetos *|
|* Secuencia a mostrar *|
|* *|
|* Salidas: OK / ERROR *|
|* *|
\**************************************************************************/
int MBoton::MuestraEstaticos( char *file, int SecMostrar )
{
FILE *handle;
char ch, buffer[200];
int Font, SizeChar, Horiz, Color;
int secuencia_activa=-1, PosX, PosY;
struct Make_Boton Bot_Static;
if ( ( handle == fopen( file, "r" ) ) == NULL )
{
lError = 0x01; Error( lError );
return ERROR;
}
ch=fgetc(fichero); //Lee el primer caracter
while ( ch != EOF ) //Lee hasta fin de fichero
{
switch ( ch )
{
// Linea con comentario
case '*':
while (ch!=EOL && ch!=EOF) ch=fgetc(fichero);
break;
// Numero de Botones en la secuencia
case '�':
secuencia_activa = ObtenNumero( handle, &ch );
break;
// C�lculos del boton estatico
case '&':
if ( secuencia_activa == Sec_st)
{
Bot_Static.Left = ObtenNumero( handle, &ch );
Bot_Static.Up = ObtenNumero( handle, &ch );
Bot_Static.Right = ObtenNumero( handle, &ch );
Bot_Static.Down = ObtenNumero( handle, &ch );
Bot_Static.Cdf = ObtenNumero( handle, &ch );
Bot_Static.Cb1 = ObtenNumero( handle, &ch );
Bot_Static.Cb2 = ObtenNumero( handle, &ch );
Bot_Static.Ab = ObtenNumero( handle, &ch );
if ( Bot_Static.Ab < 0 )
{
Relleno = 0;
Bot_Static.Ab *= -1;
} else {
Relleno = 1;
}
Bot_Static.Pb = ObtenNumero( handle, &ch );
DibujaBoton( Relleno, Bot_Static );
}
break;
//C�lculos del texto
case '|':
if ( secuencia_activa == Sec_st )
{
PosX = ObtenNumero( handle, &ch );
PosY = ObtenNumero( handle, &ch );
Font = ObtenNumero( handle, &ch );
CharSize = ObtenNumero( handle, &ch );
Horiz = ObtenNumero( handle, &ch );
Color = ObtenNumero( handle, &ch );
buffer[0] = '\0'; numero = 0;
ch=fgetc(fichero);
while ( ch != EOL && ch != EOF && ch != '�' && numero < 150 )
{
ch = fgetc(fichero);
if( ch != ',')
{
buffer[numero] = ch;
numero++;
}
}
buffer[numero] = '\0';
setcolor( Color );
settextstyle( Font, Horiz, CharSize);
outtextxy( PosX, PosY, buffer);
}
break;
}
if ( ch != EOF ) ch = fgetc(handle);
}
fclose( handle );
return OK;
}
/**************************************************************************\
|* *|
|* PrincipioSecuencia *|
|* *|
|* Descripcion: *|
|* Nos da el comienzo f�sico de la secuencia deseada *|
|* *|
|* Entradas: Secuencia a obtener su principio *|
|* Salidas: Principio de la secuencia *|
|* *|
\**************************************************************************/
int MBoton::PrincipioSecuencia( int Secuencia )
{
int i, IniSecuencia;
IniSecuencia = 0;
for ( i = 0; i< Secuencia; i++)
IniSecuencia += NBSecuencia[i];
return IniSecuencia;
}
/**************************************************************************\
|* *|
|* ImprimeBoton *|
|* *|
|* Descripcion: *|
|* Muestra por pantalla el boton que se le pasa como par�metro *|
|* y lo rellena solo si asi lo indica D_Bord *|
|* *|
|* Entradas: Secuencia a obtener su principio *|
|* Salidas: Principio de la secuencia *|
|* *|
\**************************************************************************/
void MBoton::ImprimeBoton( int D_Bord, Make_Boton Bot_Imp )
{
int puntos[14];
switch( Bot_Imp.Down )
{
// Pulsador Redondo
case -1:
// Angulos inicial y final de cada semi-ciclo
if(Bot_Imp.Pb > 0)
{
puntos[1] = 120; puntos[2] = 300;
} else {
puntos[1] = 60; puntos[2] = 240;
}
// Dibujamos el primer semi-ciclo
setlinestyle( 0, 1, NORM_WIDTH );
setcolor( Bot_Imp.Cb1 );
setfillstyle( SOLID_FILL, Bot_Imp.Cb1 );
for ( puntos[0] = 0; puntos[0] < Bot_Imp.Ab; puntos[0]++ )
arc( Bot_Imp.Left, Bot_Imp.Up, puntos[1]+puntos[0], puntos[2]+puntos[0], Bot_Imp.Right - puntos[0] );
// Dibujamos el segundo semi-ciclo
setcolor( Bot_Imp.Cb2 );
setfillstyle( SOLID_FILL, Bot_Imp.Cb2 );
for ( puntos[0] = 0; puntos[0] < Bot_Imp.Ab; puntos[0]++ )
arc( Bot_Imp.Left, Bot_Imp.Up, puntos[2]+puntos[0], puntos[1]+puntos[0], Bot_Imp.Right - puntos[0] );
// Lo tenemos que rellenar ???
if( D_Bord )
{
setcolor( Bot_Imp.Cdf );
setfillstyle( SOLID_FILL, Bot_Imp.Cdf );
pieslice( Bot_Imp.Left, Bot_Imp.Up, 0, 360, Bot_Imp.Right - Bot_Imp.Ab );
}
// Si el borde es >= 2, dibujamos un circulo negro a su alrededor
if( Bot_Imp.Ab >= 2 )
{
setcolor( NEGRO );
setfillstyle(EMPTY_FILL, Bot_Imp.Cdf);
circle( Bot_Imp.Left, Bot_Imp.Up, Bot_Imp.Right);
}
break;
default:
// Posicion de los bordes
if ( Bot_Imp.Pb == 2 )
{
puntos[0] = Bot_Imp.Left; puntos[1] = Bot_Imp.Up;
puntos[2] = Bot_Imp.Right; puntos[3] = Bot_Imp.Up;
puntos[4] = Bot_Imp.Right; puntos[5] = Bot_Imp.Down;
puntos[6] = Bot_Imp.Right - Bot_Imp.Ab; puntos[7] = Bot_Imp.Down - Bot_Imp.Ab;
puntos[8] = Bot_Imp.Right - Bot_Imp.Ab; puntos[9] = Bot_Imp.Up + Bot_Imp.Ab;
puntos[10] = Bot_Imp.Left + Bot_Imp.Ab; puntos[11] = Bot_Imp.Up + Bot_Imp.Ab;
puntos[12] = Bot_Imp.Left; puntos[13] = Bot_Imp.Up;
} else {
puntos[0] = Bot_Imp.Left; puntos[1] = Bot_Imp.Up;
puntos[2] = Bot_Imp.Right; puntos[3] = Bot_Imp.Up;
puntos[4] = Bot_Imp.Right - Bot_Imp.Ab; puntos[5] = Bot_Imp.Up + Bot_Imp.Ab;
puntos[6] = Bot_Imp.Left + Bot_Imp.Ab; puntos[7] = Bot_Imp.Up + Bot_Imp.Ab;
puntos[8] = Bot_Imp.Left + Bot_Imp.Ab; puntos[9] = Bot_Imp.Down - Bot_Imp.Ab;
puntos[10] = Bot_Imp.Left; puntos[11] = Bot_Imp.Down;
puntos[12] = Bot_Imp.Left; puntos[13] = Bot_Imp.Up;
}
// Dibujamos el primer borde
setcolor( Bot_Imp.Cb1 );
setfillstyle( SOLID_FILL, Bot_Imp.Cb1 );
setlinestyle( 0, 1, NORM_WIDTH );
fillpoly( 7, puntos );
if ( Bot_Imp.Pb == 2 )
{
puntos[0] = Bot_Imp.Left + Bot_Imp.Ab; puntos[1] = Bot_Imp.Up + Bot_Imp.Ab;
puntos[2] = Bot_Imp.Left + Bot_Imp.Ab; puntos[3] = Bot_Imp.Down - Bot_Imp.Ab;
puntos[4] = Bot_Imp.Right - Bot_Imp.Ab; puntos[5] = Bot_Imp.Down - Bot_Imp.Ab;
puntos[6] = Bot_Imp.Right; puntos[7] = Bot_Imp.Down;
puntos[8] = Bot_Imp.Left; puntos[9] = Bot_Imp.Down;
puntos[10] = Bot_Imp.Left; puntos[11] = Bot_Imp.Up;
puntos[12] = Bot_Imp.Left + Bot_Imp.Ab; puntos[13] = Bot_Imp.Up + Bot_Imp.Ab;
} else {
puntos[0] = Bot_Imp.Right; puntos[1] = Bot_Imp.Up;
puntos[2] = Bot_Imp.Right; puntos[3] = Bot_Imp.Down;
puntos[4] = Bot_Imp.Left; puntos[5] = Bot_Imp.Down;
puntos[6] = Bot_Imp.Left + Bot_Imp.Ab; puntos[7] = Bot_Imp.Down - Bot_Imp.Ab;
puntos[8] = Bot_Imp.Right - Bot_Imp.Ab; puntos[9] = Bot_Imp.Down - Bot_Imp.Ab;
puntos[10] = Bot_Imp.Right - Bot_Imp.Ab; puntos[11] = Bot_Imp.Up + Bot_Imp.Ab;
puntos[12] = Bot_Imp.Right; puntos[13] = Bot_Imp.Up;
}
// Dibujamos el segundo borde
setcolor( Bot_Imp.Cb2 );
setfillstyle( SOLID_FILL, Bot_Imp.Cb2 );
setlinestyle( 0, 1, NORM_WIDTH );
fillpoly( 7, puntos );
// Hay que rellenarlo???
if( D_Bord )
{
setcolor( Bot_Imp.Cdf );
setfillstyle( SOLID_FILL, Bot_Imp.Cdf );
bar( Bot_Imp.Left+Bot_Imp.Ab+1, Bot_Imp.Up+Bot_Imp.Ab+1, Bot_Imp.Right-Bot_Imp.Ab-1, Bot_Imp.Down-Bot_Imp.Ab-1 );
}
// Se le puede poner un marco negro ???
if( Bot_Imp.Ab >= 2 )
{
setcolor( NEGRO );
setfillstyle( EMPTY_FILL, Bot_Imp.Cdf );
rectangle( Bot_Imp.Left, Bot_Imp.Up, Bot_Imp.Right, Bot_Imp.Down );
}
break;
}
}
/**************************************************************************\
|* *|
|* ImprimeBordes *|
|* *|
|* Descripcion: *|
|* Imprime el Boton #, de la Secuencia #, con los bordes Color *|
|* *|
|* Entradas: Seuencia, Boton, Color *|
|* Salidas: (ninguna) *|
|* *|
\**************************************************************************/
void MBoton::ImprimeBordes( int Secuencia, int Boton, int Color )
{
int IniSecuencia, puntos[14];
unsigned int size;
IniSecuencia = PrincipioSecuencia( Secuencia - 1 );
if( Boton <= 0 || Boton > NBSecuencia[ Secuencia - 1 ] ) return;
Boton--;
// Un Color negativo restaura sus bordes
if( Color < 0 )
{
ImprimeBoton( 0, Botones[ IniSecuencia + Boton ] );
} else {
switch( Botones[ IniSecuencia + Boton ].Down < 0 )
{
case -1:
setlinestyle( 0, 1, NORM_WIDTH );
setcolor( Color );
setfillstyle( SOLID_FILL, Color );
for ( puntos[0] = 0; puntos[0] < Botones[ IniSecuencia + Boton ].Ab; puntos[0]++ )
circle( Botones[ IniSecuencia + Boton ].Left, Botones[ IniSecuencia + Boton ].Up, Botones[ IniSecuencia + Boton ].Right - puntos[0] );
if( Botones[ IniSecuencia + Boton ].Ab >= 2 )
{
setcolor( NEGRO );
setfillstyle( EMPTY_FILL, Botones[ IniSecuencia + Boton ].Cdf );
circle( Botones[ IniSecuencia + Boton].Left, Botones[ IniSecuencia + Boton].Up, Botones[ IniSecuencia + Boton].Right);
}
break;
default:
puntos[0] = Botones[ IniSecuencia + Boton ].Left; puntos[1] = Botones[ IniSecuencia + Boton ].Up;
puntos[2] = Botones[ IniSecuencia + Boton ].Right; puntos[3] = Botones[ IniSecuencia + Boton ].Up;
puntos[4] = Botones[ IniSecuencia + Boton ].Right; puntos[5] = Botones[ IniSecuencia + Boton ].Down;
puntos[6] = Botones[ IniSecuencia + Boton ].Right - Botones[ IniSecuencia + Boton].Ab); puntos[7] = Botones[ IniSecuencia + Boton ].Down - Botones[ IniSecuencia + Boton ].Ab;
puntos[8] = Botones[ IniSecuencia + Boton ].Right - Botones[ IniSecuencia + Boton].Ab); puntos[9] = Botones[ IniSecuencia + Boton ].Up + Botones[ IniSecuencia + Boton ].Ab;
puntos[10] = Botones[ IniSecuencia + Boton ].Left + Botones[ IniSecuencia + Boton].Ab); puntos[11] = Botones[ IniSecuencia + Boton ].Up + Botones[ IniSecuencia + Boton ].Ab;
puntos[12] = Botones[ IniSecuencia + Boton ].Left; puntos[13] = Botones[ IniSecuencia + Boton ].Up;
setcolor( Color );
setfillstyle( SOLID_FILL, Color );
setlinestyle( 0, 1, NORM_WIDTH );
fillpoly( 7, puntos );
puntos[0] = Botones[ IniSecuencia + Boton ].Left + Botones[ IniSecuencia + Boton].Ab; puntos[1] = Botones[ IniSecuencia + Boton ].Up + Botones[ IniSecuencia + Boton ].Ab;
puntos[2] = Botones[ IniSecuencia + Boton ].Left + Botones[ IniSecuencia + Boton].Ab; puntos[3] = Botones[ IniSecuencia + Boton ].Down - Botones[ IniSecuencia + Boton ].Ab;
puntos[4] = Botones[ IniSecuencia + Boton ].Right - Botones[ IniSecuencia + Boton].Ab; puntos[5] = Botones[ IniSecuencia + Boton ].Down - Botones[ IniSecuencia + Boton ].Ab;
puntos[6] = Botones[ IniSecuencia + Boton ].Right; puntos[7] = Botones[ IniSecuencia + Boton ].Down;
puntos[8] = Botones[ IniSecuencia + Boton ].Left; puntos[9] = Botones[ IniSecuencia + Boton ].Down;
puntos[10] = Botones[ IniSecuencia + Boton ].Left; puntos[11] = Botones[ IniSecuencia + Boton ].Up;
puntos[12] = Botones[ IniSecuencia + Boton ].Left + Botones[ IniSecuencia + Boton].Ab; puntos[13] = Botones[ IniSecuencia + Boton ].Up + Botones[ IniSecuencia + Boton ].Ab;
setcolor( Color );
setfillstyle( SOLID_FILL, Color );
setlinestyle( 0, 1, NORM_WIDTH );
fillpoly( 7, puntos );
// El marquito negro
if( Botones[ IniSecuencia + Boton].Ab >= 2 )
{
setcolor( NEGRO );
setfillstyle( EMPTY_FILL, Botones[ IniSecuencia + Boton ].Cdf );
rectangle( Botones[ IniSecuencia + Boton ].Left, Botones[ IniSecuencia + Boton ].Up, Botones[ IniSecuencia + Boton ].Right, Botones[ IniSecuencia + Boton ].Down );
}
break;
}
}
/**************************************************************************\
|* *|
|* CompruebaSecuencia *|
|* *|
|* Descripcion: *|
|* Comprueba donde se pulsa el rat�n o si se ha pulsado alguna *|
|* tecla que corresponde a los botones, para presionarlos *|
|* *|
|* *|
|* Entradas: Secuencia a comprobar *|
|* Puntero a la funcion de raton ( NULL == INTERNA ) *|
|* *|
|* /************************************************************\ *|
|* |* *|*|
|* |* UserPointer *|*|
|* |* *|*|
|* |* Descripcion: *|*|
|* |* Puntero a la funcion de control para el raton *|*|
|* |* carga en Xraton, Yraton las coordenadas de �l. *|*|
|* |* *|*|
|* |* Entradas: Punteros para guardar Xraton, Yraton *|*|
|* |* Salidas: B.Derech B.Izqu. *|*|
|* |* 0 0 0 *|*|
|* |* 1 1 0 *|*|
|* |* 2 0 1 *|*|
|* |* 3 1 1 *|*|
|* \************************************************************//*|
|* *|
|* Salidas: *|
|* -2 Tecla normal en buffer *|
|* -1 Tecla especial en buffer *|
|* 0 Raton fue pulsado pero no accion� nada *|
|* *|
|* >>0 N� de boton pulsado (en orden de aparicion en el fichero ) *|
|* *|
\**************************************************************************/
int MBoton::CompruebaSecuencia( int Secuencia, int (far *UserPointer)( int *Xraton, int *Yraton ) )
{
char key, key2;
int i, IniSecuencia;
int Xraton, Yraton;
key2 = 0;
Pulso = 0;
IniSecuencia = PrincipioSecuencia(Secuencia-1);
if (
( (UserPointer == NULL) ? EsperaTeclaRaton( &Xraton, &Yraton ) : UserPointer( &Xraton, &Yraton ) ) == 0
)
{
if ( ( key = getch() ) == 0 ) key2 = getch();
for( i = 0; i < NBSecuencia[ Secuencia - 1 ]; i++ )
if( toupper( key ) == Botones[ IniSecuencia + i ].Isc && key2 == Botones[ IniSecuencia + i ].Sc )
{
DeprimeBoton( ON, Botones[ IniSecuencia + i ] );
delay(50);
DeprimeBoton( OFF, Botones[ IniSecuencia + i ] );
return i+1;
}
if(key==0)
{
ungetch(key2); return (-1);
} else {
ungetch(key); return (-2);
}
}
XRaton = Xraton;
YRaton = Yraton;
for(i = 0; i < NBSecuencia[Secuencia-1]; i++)
if( ( Xraton >= Botones[ IniSecuencia + i ].Left ) && ( Xraton <= Botones[ IniSecuencia + i ].Right ) &&
( Yraton >= Botones[ IniSecuencia + i ].Up ) && ( Yraton <= Botones[ IniSecuencia + i ].Down ) )
{
DeprimeBoton( ON, Botones[ IniSecuencia + i ] );
AnclarRaton();
DeprimeBoton( OFF, Botones[ IniSecuencia + i ] );
return ( i + 1 );
}
return (0);
}
/**************************************************************************\
|* *|
|* ReCompruebaSecuencia *|
|* *|
|* Descripcion: *|
|* Comprueba otra vez la secuencia dada, pero ahora solo tiene *|
|* en cuenta que el raton ya se ha pulsado. *|
|* *|
|* *|
|* Entradas: Secuencia a comprobar *|
|* *|
|* Salidas: *|
|* -2 Tecla normal en buffer *|
|* -1 Tecla especial en buffer *|
|* 0 Raton fue pulsado pero no accion� nada *|
|* *|
|* >>0 N� de boton pulsado (en orden de aparicion en el fichero ) *|
|* *|
\**************************************************************************/
int MBoton::ReComprueba_Secuencia( int Secuencia )
{
return CompruebaSecuencia( Secuencia, ReCmpPointer );
}
/**************************************************************************\
|* *|
|* ReCmpPointer *|
|* *|
|* Descripcion: *|
|* Funci�n que carga sus par�metros con la �ltima posici�n del *|
|* rat�n y devuelve, que el rat�n fue pulsado. *|
|* *|
|* Entradas: Punteros a donde guardar la pos. del raton *|
|* *|
|* Salidas: *|
|* 2 Raton pulsado ( Boton Izquierdo ) *|
|* *|
\**************************************************************************/
int MBoton::ReCmpPointer( int *Xraton, int *Yraton )
{
*Xraton = XRaton;
*Yraton = YRaton;
return 2;
}
/**************************************************************************\
|* *|
|* DeprimeBoton *|
|* *|
|* Descripcion: *|
|* Deprime o Imprime el boton, segun se le indique. *|
|* *|
|* Entradas: ON/OFF, Boton a tratar *|
|* Salidas: (ninguna) *|
|* *|
\**************************************************************************/
void MBoton::DeprimeBoton( int DepImp, Make_Boton DepBot )
{
unsigned long size;
int SWAP_COLOR;
switch ( Bot_Imp.Down )
{
case -1:
// Deprimir ( Cambiamos los colores del borde )
if ( DepImp == ON )
{
SWAP_COLOR = DepBot.Cb1;
DepBot.Cb1 = DepBot.Cb2;
DepBot.Cb2 = SWAP_COLOR;
}
ImprimeBoton( 0, DepBot );
break;
default:
// Si es Imprimir ( lo imprimo )
if ( DepImp == OFF )
{
if ( FBoton != NULL )
{
putimage( DepBot.Left + DepBot.Ab + 1, DepBot.Up + DepBot.Ab + 1, FBoton, COPY_PUT );
farfree( FBoton );
}
ImprimeBoton( 0, DepBot );
} else {
// Deprimir: �� Tengo memoria para deprimir WUAYYY ?
if ( ( FBoton = farmalloc( JD_imagesize( DepBot.Left + Ab + 1, DepBot.Up + Ab + 1, DepBot.Right - Ab - 1, DepBot.Down - Ab - 1 ) ) ) != NULL )
{
ImprimeBoton( 0, DepBot );
getimage( DepBot.Left + Ab + 1, DepBot.Up + Ab + 1, DepBot.Right - Ab - 1, DepBot.Down - Ab - 1, FBoton);
if( DepBot.Pb == 2)
{
putimage( DepBot.Left + 1, DepBot.Up+(Ab*2), FBoton, COPY_PUT);
} else {
putimage( DepBot.Left + (Ab*2), DepBot.Up+(Ab*2), FBoton, COPY_PUT);
}
} else {
SWAP_COLOR = DepBot.Cb1;
DepBot.Cb1 = DepBot.Cb2;
DepBot.Cb2 = SWAP_COLOR;
ImprimeBoton( 0, DepBot );
}
}
break;
}
}
/**************************************************************************\
|* *|
|* Error *|
|* *|
|* Descripcion: *|
|* Carga en cError, el error lError que se pasa como parametro *|
|* *|
|* Entradas: Error a cargar *|
|* Salidas: (ninguna) *|
|* *|
\**************************************************************************/
void MBoton::Error( int lError )
{
switch ( lError )
{
case 0:
strcpy( cError, "No hay ningun error" );
break;
case 1:
strcpy( cError, "Error abriendo el archivo" );
break;
case 5:
strcpy( cError, "No hay memoria" );
break;
}
}
//��������������������������������������������������������������������������������
//��������������������������������������������������������������������������������
// Funciones para el control del rat�n ( SOLO -> VGA <- )
//��������������������������������������������������������������������������������
//��������������������������������������������������������������������������������
void AnclarRaton( void )
{
union REGS io;
io.ax = 0;
int86(0x33, &io, &io); /* averigua si hay rat�n conectado */
if ( io.x.ax == 0 ) return;
io.x.ax = 3;
do {
int86(0x33, &io, &io);
} while( (io.x.bx & 1)==1 || ((io.x.bx >> 1) & 1)==1);
}
int Espera_TeclaRaton(void)
{
char Que;
activa_raton();
union REGS io;
io.x.ax = 3;
do{
int86(0x33, &io, &io); // lee posici�n y estados del bot�n
Xraton = io.x.cx;
Yraton = io.x.dx;
} while( (io.x.bx & 1) == 0 && ((io.x.bx >> 1) & 1) == 0 && !MB_TeclaPulsada() );
/////////////////////////////////////////
// RETURN Derecho Izquierdo //
// //
// 0 0 0 //
// 1 1 0 //
// 2 0 1 //
// 3 1 1 //
// //
/////////////////////////////////////////
if ( ((io.x.bx >> 1) & 1)==0 && (io.x.bx & 1)==0 ) Que = 0;
if ( ((io.x.bx >> 1) & 1)==1 && (io.x.bx & 1)==0 ) Que = 1;
if ( ((io.x.bx >> 1) & 1)==0 && (io.x.bx & 1)==1 ) Que = 2;
if ( ((io.x.bx >> 1) & 1)==1 && (io.x.bx & 1)==1 ) Que = 3;
desactiva_raton();
return Que;
}
void inicializa_raton_grafico(int x1, int y1, int x2, int y2)
{
int px = Xraton, py = Yraton;
struct SREGS seg;
union REGS ent, sal;
long dir;
ent.x.ax = 0;
int86(0x33, &ent, &sal); /* averigua si hay rat�n conectado */
raton = sal.x.ax; /* indica a la variable global el estado
del raton */
if(raton!=0) {
ent.x.ax = 15;
ent.x.cx = 5;
ent.x.dx = 11;
int86(0x33, &ent, &sal); /* fija la raz�n mickey/pixel */
ent.x.ax = 7;
ent.x.cx = x1;
ent.x.dx = x2;
int86(0x33, &ent, &sal); /* fija la posici�n m�x. y m�n. horizontal */
ent.x.ax = 8;
ent.x.cx = y1;
ent.x.dx = y2;
int86(0x33, &ent, &sal); /* fija la posici�n m�x. y m�n. vertical */
Carga_Puntero();
if( PunteroRaton != 0 )
{
dir = (long)dir_raton;
ent.x.ax = 9;
ent.x.bx = 0;
ent.x.cx = 0;
ent.x.dx = (int) dir;
seg.es = (int) (dir >> 16);
int86x(0x33, &ent, &sal, &seg); /* asigna un cursor diferente */
}
ent.x.ax = 4;
ent.x.cx = px;
Xraton=ent.x.cx >> 1;
ent.x.dx = py;
Yraton=ent.x.dx;
int86(0x33, &ent, &sal); /* fija la posici�n del rat�n */
ent.x.ax = 1;
int86(0x33, &ent, &sal); /* muestra el puntero del rat�n */
desactiva_raton();
}
}
void activa_raton(void)
{
union REGS ent;
ent.x.ax = 1;
int86(0x33, &ent, &ent);
}
void desactiva_raton(void)
{
union REGS ent;
ent.x.ax = 2;
int86(0x33, &ent, &ent);
}
void Initialize(int GraphDriver, int GraphMode)
{
int errorcode;
/*
if( (errorcode = registerbgifont(SMALL_FONT)) < 0 )
ErrorOccurred(errorcode);
*/
/* report any registration errors */
/* if ( (errorcode = registerbgidriver(EGAVGA_driver) ) < 0)
ErrorOccurred(errorcode);
*/
/* initialize graphics and local variables */
initgraph( &GraphDriver, &GraphMode, "" );
/* read result of initialization */
errorcode = graphresult();
if (errorcode != grOk) /* an error occurred */
ErrorOccurred(errorcode);
}
void ErrorOccurred(int errorcode) {
printf("Graphics error: %s\n", grapherrormsg(errorcode));
printf("Press any key to halt:");
getch();
exit(1); /* terminate with an error code */
}
/*
unsigned long JD_imagesize(int left, int top, int right, int bottom)
{
unsigned long X_width, Y_width;
X_width= ( (left > right) ? (left - right + 1) : ( right - left + 1) );
Y_width= ( ( top > bottom) ? ( top - bottom + 1) : (bottom - top + 1) );
return (X_width * Y_width + 4);
};
*/
void Carga_Puntero(void){
struct SREGS seg;
union REGS ent, sal;
long dir;
switch( PunteroRaton ) {
case 0:
break;
case 1:
dir_raton [ 0] = 0x007F; /*� � � � � � � � � 1 1 1 1 1 1 1*/
dir_raton [ 1] = 0x00FF; /*� � � � � � � � 1 1 1 1 1 1 1 1*/
dir_raton [ 2] = 0x01FF; /*� � � � � � � 1 1 1 1 1 1 1 1 1*/
dir_raton [ 3] = 0x01FF; /*� � � � � � � 1 1 1 1 1 1 1 1 1*/
dir_raton [ 4] = 0x00FF; /*� � � � � � � � 1 1 1 1 1 1 1 1*/
dir_raton [ 5] = 0x007F; /*� � � � � � � � � 1 1 1 1 1 1 1*/
dir_raton [ 6] = 0x18FF; /*� � � 1 1 � � � 1 1 1 1 1 1 1 1*/
dir_raton [ 7] = 0x800F; /*1 � � � � � � � � � � � 1 1 1 1*/
dir_raton [ 8] = 0x8083; /*1 � � � � � � � � � � � � � 1 1*/
dir_raton [ 9] = 0x8001; /*1 � � � � � � � � � � � � � � 1*/
dir_raton [10] = 0xF810; /*1 1 1 1 1 � � � � � � 1 � � � 1*/
dir_raton [11] = 0x8810; /*1 � � � 1 � � � � � � 1 � � � 1*/
dir_raton [12] = 0x8811; /*1 � � � 1 � � � � � � 1 � � � 1*/
dir_raton [13] = 0x8003; /*1 � � � � � � � � � � � � � 1 1*/
dir_raton [14] = 0x8007; /*1 � � � � � � � � � � � � 1 1 1*/
dir_raton [15] = 0x800F; /*1 � � � � � � � � � � � 1 1 1 1*/
dir_raton [16] = 0x0000; /*0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0*/
dir_raton [17] = 0x7E00; /*0 � � � � � � 0 0 0 0 0 0 0 0 0*/
dir_raton [18] = 0x7C00; /*0 � � � � � 0 0 0 0 0 0 0 0 0 0*/
dir_raton [19] = 0x7C00; /*0 � � � � � 0 0 0 0 0 0 0 0 0 0*/
dir_raton [20] = 0x7E00; /*0 � � � � � � 0 0 0 0 0 0 0 0 0*/
dir_raton [21] = 0x6700; /*0 � � 0 0 � � � 0 0 0 0 0 0 0 0*/
dir_raton [22] = 0x0200; /*0 0 0 0 0 0 � 0 0 0 0 0 0 0 0 0*/
dir_raton [23] = 0x0000; /*0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0*/
dir_raton [24] = 0x3E70; /*0 0 � � � � � 0 0 � � � 0 0 0 0*/
dir_raton [25] = 0x0248; /*0 0 0 0 0 0 � 0 0 � 0 0 � 0 0 0*/
dir_raton [26] = 0x0244; /*0 0 0 0 0 0 � 0 0 � 0 0 0 � 0 0*/
dir_raton [27] = 0x0242; /*0 0 0 0 0 0 � 0 0 � 0 0 0 � 0 0*/
dir_raton [28] = 0x2244; /*0 0 � 0 0 0 � 0 0 � 0 0 0 � 0 0*/
dir_raton [29] = 0x2248; /*0 0 � 0 0 0 � 0 0 � 0 0 � 0 0 0*/
dir_raton [30] = 0x3E70; /*0 0 � � � � � 0 0 � � � 0 0 0 0*/
dir_raton [31] = 0x0000; /*0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0*/
dir = (long)dir_raton;
ent.x.ax = 9;
ent.x.bx = 0;
ent.x.cx = 0;
ent.x.dx = (int) dir;
seg.es = (int) (dir >> 16);
int86x(0x33, &ent, &sal, &seg); /* asigna un cursor diferente */
break;
case 2: //� 2 1 0 � 2 1 0 � 2 1 0 � 2 1 0
dir_raton [ 0] = 0xF11F; /*1 1 1 1 � � � 1 � � � 1 1 1 1 1*/
dir_raton [ 1] = 0xF01F; /*1 1 1 1 � � � � � � � 1 1 1 1 1*/
dir_raton [ 2] = 0xF01F; /*1 1 1 1 � � � � � � � 1 1 1 1 1*/
dir_raton [ 3] = 0xF01F; /*1 1 1 1 � � � � � � � 1 1 1 1 1*/
dir_raton [ 4] = 0xF01F; /*1 1 1 1 � � � � � � � 1 1 1 1 1*/
dir_raton [ 5] = 0x0001; /*� � � � � � � � � � � � � � � 1*/
dir_raton [ 6] = 0x0101; /*� � � � � � � 1 � � � � � � � 1*/
dir_raton [ 7] = 0x0271; /*� � � � � � 1 1 1 � � � � � � 1*/
dir_raton [ 8] = 0x7773; /*1 � � � � 1 1 1 1 1 � � � � 1 1*/
dir_raton [ 9] = 0x0271; /*� � � � � � 1 1 1 � � � � � � 1*/
dir_raton [10] = 0x0101; /*� � � � � � � 1 � � � � � � � 1*/
dir_raton [11] = 0x0001; /*� � � � � � � � � � � � � � � 1*/
dir_raton [12] = 0xF01F; /*1 1 1 1 � � � � � � � 1 1 1 1 1*/
dir_raton [13] = 0xF01F; /*1 1 1 1 � � � � � � � 1 1 1 1 1*/
dir_raton [14] = 0xF01F; /*1 1 1 1 � � � � � � � 1 1 1 1 1*/
dir_raton [15] = 0xF11F; /*1 1 1 1 � � � 1 � � � 1 1 1 1 1*/
//� 2 1 0 � 2 1 0 � 2 1 0 � 2 1 0
dir_raton [16] = 0x0440; /*0 0 0 0 0 � 0 0 0 � 0 0 0 0 0 0*/
dir_raton [17] = 0x06C0; /*0 0 0 0 0 � � 0 � � 0 0 0 0 0 0*/
dir_raton [18] = 0x06C0; /*0 0 0 0 0 � � 0 � � 0 0 0 0 0 0*/
dir_raton [19] = 0x06C0; /*0 0 0 0 0 � � 0 � � 0 0 0 0 0 0*/
dir_raton [20] = 0x06C0; /*0 0 0 0 0 � � 0 � � 0 0 0 0 0 0*/
dir_raton [21] = 0x06C0; /*0 0 0 0 0 � � 0 � � 0 0 0 0 0 0*/
dir_raton [22] = 0xFC7E; /*� � � � � � 0 0 0 � � � � � � 0*/
dir_raton [23] = 0x7C7C; /*0 � � � � 0 0 0 0 0 � � � � 0 0*/
dir_raton [24] = 0x0000; /*0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0*/
dir_raton [25] = 0x7C7C; /*0 � � � � 0 0 0 0 0 � � � � 0 0*/
dir_raton [26] = 0xFC7E; /*� � � � � � 0 0 0 � � � � � � 0*/
dir_raton [27] = 0x06C0; /*0 0 0 0 0 � � 0 � � 0 0 0 0 0 0*/
dir_raton [28] = 0x06C0; /*0 0 0 0 0 � � 0 � � 0 0 0 0 0 0*/
dir_raton [29] = 0x06C0; /*0 0 0 0 0 � � 0 � � 0 0 0 0 0 0*/
dir_raton [30] = 0x06C0; /*0 0 0 0 0 � � 0 � � 0 0 0 0 0 0*/
dir_raton [31] = 0x0440; /*0 0 0 0 0 � 0 0 0 � 0 0 0 0 0 0*/
dir = (long)dir_raton;
ent.x.ax = 9;
ent.x.bx = 0;
ent.x.cx = 0;
ent.x.dx = (int) dir;
seg.es = (int) (dir >> 16);
int86x(0x33, &ent, &sal, &seg); /* asigna un cursor diferente */
break;
case 3: //� 2 1 0 � 2 1 0 � 2 1 0 � 2 1 0
dir_raton [ 0] = 0xFFFF; /*1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1*/
dir_raton [ 1] = 0xFFFF; /*1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1*/
dir_raton [ 2] = 0xFFFF; /*1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1*/
dir_raton [ 3] = 0xFFFF; /*1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1*/
dir_raton [ 4] = 0xCFF3; /*1 1 � � 1 1 1 1 1 1 1 1 � � 1 1*/
dir_raton [ 5] = 0xC7E3; /*1 1 � � � 1 1 1 1 1 1 � � � 1 1*/
dir_raton [ 6] = 0x03C0; /*� � � � � � 1 1 1 1 � � � � � �*/
dir_raton [ 7] = 0x0180; /*� � � � � � � 1 1 � � � � � � �*/
dir_raton [ 8] = 0x0000; /*� � � � � � � � � � � � � � � �*/
dir_raton [ 9] = 0x0180; /*� � � � � � � 1 1 � � � � � � �*/
dir_raton [10] = 0x03C0; /*� � � � � � 1 1 1 1 � � � � � �*/
dir_raton [11] = 0xC7E3; /*1 1 � � � 1 1 1 1 1 1 � � � 1 1*/
dir_raton [12] = 0xCFF3; /*1 1 � � 1 1 1 1 1 1 1 1 � � 1 1*/
dir_raton [13] = 0xFFFF; /*1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1*/
dir_raton [14] = 0xFFFF; /*1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1*/
dir_raton [15] = 0xFFFF; /*1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1*/
//� 2 1 0 � 2 1 0 � 2 1 0 � 2 1 0
dir_raton [16] = 0x0000; /*0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0*/
dir_raton [17] = 0x0000; /*0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0*/
dir_raton [18] = 0x0000; /*0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0*/
dir_raton [19] = 0x0000; /*0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0*/
dir_raton [20] = 0x0000; /*0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0*/
dir_raton [21] = 0x1008; /*0 0 0 � 0 0 0 0 0 0 0 0 � 0 0 0*/
dir_raton [22] = 0x1818; /*0 0 0 � � 0 0 0 0 0 0 � � 0 0 0*/
dir_raton [23] = 0x7C3E; /*0 � � � � � 0 0 0 0 � � � � � 0*/
dir_raton [24] = 0x7E7E; /*0 � � � � � � 0 0 � � � � � � 0*/
dir_raton [25] = 0x7C3E; /*0 � � � � � 0 0 0 0 � � � � � 0*/
dir_raton [26] = 0x1818; /*0 0 0 � � 0 0 0 0 0 0 � � 0 0 0*/
dir_raton [27] = 0x1008; /*0 0 0 � 0 0 0 0 0 0 0 0 � 0 0 0*/
dir_raton [28] = 0x0000; /*0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0*/
dir_raton [29] = 0x0000; /*0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0*/
dir_raton [30] = 0x0000; /*0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0*/
dir_raton [31] = 0x0000; /*0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0*/
dir = (long)dir_raton;
ent.x.ax = 9;
ent.x.bx = 0;
ent.x.cx = 0;
ent.x.dx = (int) dir;
seg.es = (int) (dir >> 16);
int86x(0x33, &ent, &sal, &seg); /* asigna un cursor diferente */
break;
};
};
/// int MB_TeclaPulsada(void)
/* Esta funci�n mira si se ha pulsado una tecla pero SIN llamadas a la BIOS,
de forma que no se inhabilitan las interrupciones en cada llamada, cosa
que bajar�a mucho la calidad de reproducci�n con el altavoz interno. */
/// {
/// return ( *(unsigned *) MK_FP(0x40,0x1A) != *(unsigned *) MK_FP(0x40,0x1C) );
/// }