/**************************************************************************\
|*                                                                          *|
|* 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) );
/// }