#include <alloc.h>
#include <conio.h>
#include <string.h>
#include <stdlib.h>

#include "d:\program\src_dos\libs\bdatos\bdatos.hh"
#include "zorr.h"

#define NLINEAS_REF 18

BDatos BCompras;            // Base de datos de Compraserencias
INFO_PRECIOS SCompras;     // Estructura de referencias

int OrdenGestionInterna;

extern CONFIG Config;

void RastreaFicheroGastosi(void);

void Error( int code );
void MuestraDatosCompras( int RowStart );

int ComparaRegistros( const void *A, const void *B );

void EditItemCompras( char columna, int linea );
void ComprasNuevoRegistro( INFO_PRECIOS *MSCompras );
void MuestraCompras( char columna, int linea, char como );
void ObtenCoordenadasCompras( char columna, char linea, int *X0, int *Y0, int *X1, int *Y1 );
void OrdenarGastosi(void);

void ObtenCoordenadasMatch( char Row, int *X0, int *Y0, int *X1, int *Y1 );
void MatchDrawCompras( char Row, INFO_PRECIOS MCompras,  char como );
void BuscaCompras( char TipoBusqueda, char *CurrRow, int *CurrCompras );
int  Match_Compras( INFO_PRECIOS A, INFO_PRECIOS B );
void EditMatchCompras( char Row, INFO_PRECIOS * MCompras );
int  ObtenMatchCompras( INFO_PRECIOS *MCompras );



void ImprimeCompraserencias( char como );
void ImprimeCabeceraCompras( char como, FILE *file_out );
void DibujaPantallaGastosInt( void );


//  ßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßß
// Û                     Parte principal del m¢dulo                       Û
//  ÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜ


 /**************************************************************************\
|*                                                                          *|
|*  InfoProducto                                                            *|
|*                                                                          *|
|*  Descripci¢n:                                                            *|
|*              Controla la introduccion de datos y muestreo asi como todo  *|
|*              el interfaz de usuario...                                   *|
|*                                                                          *|
|*  Entradas: (ninguna)                                                     *|
|*  Salidas:  (ninguna)                                                     *|
|*                                                                          *|
 \**************************************************************************/
void GastosInternos(void)
{
struct Boton_Texto BT[6];


BT[0].x =  1; BT[0].y =  1; strcpy( BT[0].Texto, " &Men£ Principal "); BT[0].ID_T1 =  0; BT[0].ID_T2 = 50;
BT[1].x = 20; BT[1].y =  1; strcpy( BT[1].Texto, " &Ins. Art."); BT[1].ID_T1 =  0; BT[1].ID_T2 = 23;

BT[2].x = 33; BT[2].y =  1; strcpy( BT[2].Texto, " &Borr. Art."); BT[2].ID_T1 =  0; BT[2].ID_T2 = 48;
BT[3].x = 47; BT[3].y =  1; strcpy( BT[3].Texto, " &Ordenar");    BT[3].ID_T1 =  0; BT[3].ID_T2 = 24;

BT[4].x = 58; BT[4].y =  1; strcpy( BT[4].Texto, " &Gast.Prov."); BT[4].ID_T1 =  0; BT[4].ID_T2 = 0;
BT[5].x = 72; BT[5].y =  1; strcpy( BT[5].Texto, " Im&pr. ");         BT[5].ID_T1 =  0; BT[5].ID_T2 = 25;

 char buffer[100], ok = 0;
 int BPush, key;

 char oldCol;
 char CurrRow;         // Linea sobre la que estamos
 char CurrCol;         // Columna sobre la que estamos
 long CurrCompras;         // Producto sobre el que estamos posicionados a golpes

 _setcursortype( _NOCURSOR );
 DibujaPantallaGastosInt();

 sprintf( buffer, "GastosI.%03d", AnoActual );
 if ( BCompras.AbrirReg( buffer, sizeof( INFO_PRECIOS ) ) == ERROR )
                                                             Error(0x01);

 // Si no hay registros, creamos uno almenos.
 if ( BCompras.Registros() == 0 )
 {
      ComprasNuevoRegistro( &SCompras );
      if ( BCompras.InsReg( (void *)&SCompras, BCompras.Registros(), ARRIBA ) == ERROR )
                                                             Error(0x02);
 }

 CurrCompras = 0; CurrRow = 0;

 // Mostramos datos hasta que se nos acabe la pantalla
 MuestraDatosCompras( CurrRow + CurrCompras );
 if ( BCompras.LeeReg( (void *)&SCompras, 0      ) == ERROR )
                                                             Error(0x03);

 CurrCol = 0; oldCol = -1;

 do {
      if ( CurrCol != oldCol )
      {
       oldCol = CurrCol;
      }

      MuestraCompras( CurrCol, CurrRow, INTENSO );
      BPush = Funcion_Botones(STD_BY, 6, BT);
      MuestraCompras( CurrCol, CurrRow, NORMAL  );

      switch ( BPush )
      {
       case  0:				  // No se pulso ningun BOTON
	       while( kbhit() ) getch();  // Limpiamos posibles teclas en BUFFER
	       break;
       case -2:				  // Hay una tecla normal en BUFFER
               if ( ( key = getch() ) != 13 && key != 27 )
                                      ungetch( key );
               EditItemCompras( CurrCol, CurrRow );
               _setcursortype( _NOCURSOR );
               if ( BCompras.EscribeReg( (void *)&SCompras, (CurrRow + CurrCompras) ) == ERROR )
                                                             Error(0x04);
	       while( kbhit() ) getch();  // Limpiamos posibles teclas en BUFFER
               break;
       case -1:				  // Hay una tecla especial en BUFFER
               switch( getch() )
               {
                // Flecha Izquierda
                case  75:
                case  15:
                       CurrCol--; if ( CurrCol <  0 ) CurrCol = 5;
                       break;
                // Flecha Derecha
                case  77:
                case   9:
                       CurrCol++; if ( CurrCol > 5 ) CurrCol =  0;
                       break;
                // Flecha Arriba
                case  72:
                        if ( (CurrRow + CurrCompras) > 0 )
                        {
                         if ( ( CurrRow ) <= 0 )
                         {
                          CurrRow = NLINEAS_REF - 1;          CurrCompras -= NLINEAS_REF;
                          if ( CurrCompras < 0 ) CurrCompras = 0;

                          while( ( CurrRow + CurrCompras ) >= BCompras.Registros() && CurrRow > 0 ) CurrRow--;
                          while( ( CurrRow + CurrCompras ) >= BCompras.Registros() && CurrCompras > 0 ) CurrCompras++;

                          // Mostramos datos hasta que se nos acabe la pantalla
                          MuestraDatosCompras( CurrCompras );
                         } else {
                          CurrRow --; if ( CurrRow < 0 ) CurrRow = 0;
                         }
                        }

                        if ( BCompras.LeeReg( (void *)&SCompras, (CurrCompras + CurrRow) ) == ERROR )
                                                             Error(0x03);
                       break;
                // Flecha Abajo
                case  80:
                        if ( ( CurrRow + CurrCompras ) < BCompras.Registros() - 1 )
                        {

                         if ( ( CurrRow ) >= NLINEAS_REF - 1 )
                         {
                           CurrRow = 0;		CurrCompras += NLINEAS_REF;

                           while ( (CurrCompras + CurrRow) >= BCompras.Registros() ) CurrCompras--;

                           // Mostramos datos hasta que se nos acabe la pantalla
                           MuestraDatosCompras( CurrCompras );
                         } else
                         	CurrRow++;
                        }
                        if ( BCompras.LeeReg( (void *)&SCompras, (CurrCompras + CurrRow) ) == ERROR )
                                                             Error(0x03);
                       break;
                // Inicio
                case  71:
                       CurrRow = 0;
                       if ( CurrCompras != 0 )
                       {
                        CurrCompras = 0;

                        // Mostramos datos hasta que se nos acabe la pantalla
                        MuestraDatosCompras( CurrCompras );
                       }

                       if ( BCompras.LeeReg( (void *)&SCompras, (CurrCompras + CurrRow) ) == ERROR )
                                                             Error(0x03);

                       break;
                // Fin
                case  79:
                       CurrRow = 0;
                       if ( CurrCompras != BCompras.Registros() - NLINEAS_REF )
                       {
                        CurrCompras = BCompras.Registros() - NLINEAS_REF;
                        while( CurrCompras >= BCompras.Registros() ) CurrCompras--;
                        if ( CurrCompras < 0 ) {
                         CurrCompras = 0;
                         CurrRow = BCompras.Registros()-1;
                        }
                        // Mostramos datos hasta que se nos acabe la pantalla
                        MuestraDatosCompras( CurrCompras );
                       }

                       if ( BCompras.LeeReg( (void *)&SCompras, (CurrCompras + CurrRow) ) == ERROR )
                                                             Error(0x03);

                       break;
       // AvanceR pido
       case  81:
	       CurrRow = 0;		CurrCompras += NLINEAS_REF;

               while ( (CurrCompras + CurrRow) >= BCompras.Registros() ) CurrCompras--;

               // Mostramos datos hasta que se nos acabe la pantalla
               MuestraDatosCompras( CurrCompras );
               if ( BCompras.LeeReg( (void *)&SCompras, (CurrCompras + CurrRow) ) == ERROR )
                                                             Error(0x03);

	       break;
       // Retroceso R pido
       case  73:
               CurrRow = NLINEAS_REF - 1;          CurrCompras -= NLINEAS_REF;
               if ( CurrCompras < 0 ) CurrCompras = 0;

               while( ( CurrRow + CurrCompras ) >= BCompras.Registros() && CurrRow > 0 ) CurrRow--;
               while( ( CurrRow + CurrCompras ) >= BCompras.Registros() && CurrCompras > 0 ) CurrCompras++;

               // Mostramos datos hasta que se nos acabe la pantalla
               MuestraDatosCompras( CurrCompras );
               if ( BCompras.LeeReg( (void *)&SCompras, (CurrCompras + CurrRow) ) == ERROR )
                                                             Error(0x03);

	       break;

               }
	       while( kbhit() ) getch();  // Limpiamos posibles teclas en BUFFER
	       break;
       // Imprimir Lista de socios
       case  6:
//               MuestraImpresionesCompras();
	       break;
       // Menu Principal
       case  1:
               ok = 1;
               break;
       // Eliminar
       case  3:
       while( kbhit() ) getch();
               if ( Optar( 1, "ATENCION", "Eliminar  un gasto interno", "confirme eliminacion",  NULL ) )
               {
                if ( BCompras.DelReg( CurrCompras + CurrRow ) == ERROR )
                                                              Error(0x05);
                if ( BCompras.Registros() == 0 )
                {
                  ComprasNuevoRegistro( &SCompras );
                  if ( BCompras.InsReg( (void *)&SCompras, BCompras.Registros(), ARRIBA ) == ERROR )
                                                                               Error(0x02);
                  CurrRow = 0;
                } else

                // Si he borrado el £ltimo registro subo una linea
                if ( (CurrCompras+CurrRow) >= ( BCompras.Registros() - 2 ) )
                {
                         if ( (CurrRow + CurrCompras) > 0 )
                         {
                          if ( ( CurrRow ) <= 0 )
                          {
                           CurrRow = NLINEAS_REF - 1;          CurrCompras -= NLINEAS_REF;
                           if ( CurrCompras < 0 ) CurrCompras = 0;

                           while( ( CurrRow + CurrCompras ) >= BCompras.Registros() && CurrRow > 0 ) CurrRow--;
                           while( ( CurrRow + CurrCompras ) >= BCompras.Registros() && CurrCompras > 0 ) CurrCompras++;

                           // Mostramos datos hasta que se nos acabe la pantalla
                           MuestraDatosCompras( CurrCompras );
                          } else {
                           CurrRow --; if ( CurrRow < 0 ) CurrRow = 0;
                          }
                         }

                         if ( BCompras.LeeReg( (void *)&SCompras, (CurrCompras + CurrRow) ) == ERROR )
                                                              Error(0x03);
                }

                // Mostramos datos hasta que se nos acabe la pantalla
                MuestraDatosCompras( CurrCompras );
                if ( BCompras.LeeReg( (void *)&SCompras, (CurrCompras + CurrRow) ) == ERROR )
                                                              Error(0x03);
               }
	       break;
       // Insertar
       case  2:
               ComprasNuevoRegistro( &SCompras );
               if ( BCompras.InsReg( (void *)&SCompras, (CurrCompras + CurrRow), ARRIBA ) == ERROR )
                                                             Error(0x02);
               if ( ( CurrRow + CurrCompras ) < BCompras.Registros() - 1 )
               {

                if ( ( CurrRow ) >= NLINEAS_REF - 1 )
                {
                   CurrRow = 0;		CurrCompras += NLINEAS_REF;

                   while ( (CurrCompras + CurrRow) >= BCompras.Registros() ) CurrCompras--;

                 } else
                   CurrRow++;
                 }

                 // Mostramos datos hasta que se nos acabe la pantalla
                 MuestraDatosCompras( CurrCompras );
                 if ( BCompras.LeeReg( (void *)&SCompras, (CurrCompras + CurrRow) ) == ERROR )
                                                             Error(0x03);

	       break;

       // Ordenar
       case  4:
               OrdenarGastosi();
 CurrCompras = 0; CurrRow = 0;

 // Mostramos datos hasta que se nos acabe la pantalla
 MuestraDatosCompras( CurrRow + CurrCompras );
 if ( BCompras.LeeReg( (void *)&SCompras, 0      ) == ERROR )
                                                             Error(0x03);

 CurrCol = 0;

	       break;
       // Gastos por proveedor
       case  5:
               RastreaFicheroGastosi();
	       break;
       default:
               while( kbhit() ) getch();
	       break;
      }

 } while( !ok );

 BCompras.CerrarReg();
}



 /**************************************************************************\
|*                                                                          *|
|*  MuestraDatosCompras                                                         *|
|*                                                                          *|
|*  Descripci¢n:                                                            *|
|*              Dado un registro, se muestran sucesivamente este y todos    *|
|*              los que hay por debajo de ‚l, hasta que se agote la base    *|
|*              o no quepan mas en la pantalla.                             *|
|*                                                                          *|
|*  Entradas: Registro por el que comenzar                                  *|
|*  Salidas:  (ninguna)                                                     *|
|*                                                                          *|
 \**************************************************************************/
void MuestraDatosCompras( int RowStart )
{
 int linea, campo;
 char dev;

 // Imprimo la NLINEAS_REF que caben en la pantalla
 dev = OK;
 for ( linea=0; linea < NLINEAS_REF && dev == OK; linea++ )
 {
   dev = BCompras.LeeReg( (void *)&SCompras, RowStart + linea );
   if ( dev == OK )
   // Por cada linea hay 6 campos, ehhh!!!
      for  ( campo=0; campo < 6; campo++ )
                                  MuestraCompras( campo, linea, NORMAL );
 }

 // Ahora limpio los restantes huecos si los hay
 if ( dev != OK )
 {
   linea--;

   textbackground( BLACK );
   textcolor( WHITE );
   for ( ; linea < NLINEAS_REF; linea++ )
     for  ( campo=0; campo < 6; campo++ )
     {
      gotoxy(  1, linea +  6 );
      cprintf( "³          ³                        ³       ³          ³             ³         ³");
     }
 }
}

 /**************************************************************************\
|*                                                                          *|
|*  MuestraCompras                                                              *|
|*                                                                          *|
|*  Descripci¢n:                                                            *|
|*              Reescribe el campo dado, seg£n la fila, y la intensidad     *|
|*                                                                          *|
|*  Entradas:                                                               *|
|*            columna    campo ha mostar                                    *|
|*            linea      linea en la que nos encontramos                    *|
|*            como       intensidad del texto (NORMAL/INTENSO)              *|
|*                                                                          *|
|*  Salidas:  (ninguna)                                                     *|
|*                                                                          *|
 \**************************************************************************/
void MuestraCompras( char columna, int linea, char como )
{
 char buffer[80];
 char buffer1[80];

 int X0, Y0, X1, Y1;

 ObtenCoordenadasCompras( columna, linea, &X0, &Y0, &X1, &Y1 );

 switch( columna )
 {
  // Fecha
  case  0:
       sprintf ( buffer, " %02d-%02d-%02d ", (int)SCompras.Fecha.da_day, (int)SCompras.Fecha.da_mon, SCompras.Fecha.da_year  );
       break;
  // Articulo
  case  1:
       sprintf ( buffer, "%24s",  SCompras.Articulo  );
       break;
  // Cantidades
  case  2:
       sprintf ( buffer, "   %04d",  SCompras.Cantidades  );
       break;
  // Precio
  case  3:
       formatea_u_long( SCompras.Precio, buffer1 );
       sprintf ( buffer, "   %7s", buffer1 );
       break;
  // Total
  case  4:
       formatea_u_long( SCompras.Precio * SCompras.Cantidades, buffer1 );
       sprintf ( buffer, "%13s",  buffer1 );
       break;
  // N§ Proveedor
  case  5:
       sprintf ( buffer, "      %03d",  SCompras.Proveedor );
       break;
 }

 textbackground( ( como == NORMAL ) ? Config.TxtBgN : Config.TxtBgI );
 strnset( buffer1, 32, X1 );

 textcolor( ( como == NORMAL ) ? Config.TxtFgN : Config.TxtFgI );
 gotoxy( X0, Y0 );
 cprintf( "%s", buffer );

}


 /**************************************************************************\
|*                                                                          *|
|*  EditItemCompras                                                             *|
|*                                                                          *|
|*  Descripci¢n:                                                            *|
|*              Se encarga de editar y validar el campo.                    *|
|*                                                                          *|
|*  Entradas:                                                               *|
|*            columna    campo ha editar                                    *|
|*            linea      linea en la que nos encontramos                    *|
|*                                                                          *|
|*  Salidas:  (ninguna)                                                     *|
|*                                                                          *|
 \**************************************************************************/
void EditItemCompras( char columna, int linea )
{
 char buffer[80];

 int X0, Y0, X1, Y1;

 ObtenCoordenadasCompras( columna, linea, &X0, &Y0, &X1, &Y1 );

 switch( columna )
 {
  // Fecha
  case  0:
       sprintf ( buffer, "%02d%02d", (int)SCompras.Fecha.da_day, (int)SCompras.Fecha.da_mon );
       if ( !( InputCadenaG( buffer, 1,  4, Config.TxtBgN, Config.TxtFgN, X0, Y0, X1, Y1) >> 8 ) )
        if ( ( (buffer[0]-'0')*10 + (buffer[1]-'0') ) <= 31 && ( (buffer[2]-'0')*10 + (buffer[3]-'0') ) <= 12 )
        {
         SCompras.Fecha.da_day  = (char)((buffer[0]-'0')*10 + (buffer[1]-'0'));
         SCompras.Fecha.da_mon  = (char)((buffer[2]-'0')*10 + (buffer[3]-'0'));
         SCompras.Fecha.da_year = AnoActual;
        }
       break;
  // Articulo
  case  1:
       strcpy ( buffer, SCompras.Articulo   );
       if ( !( InputCadenaG( buffer, 0, 24, Config.TxtBgN, Config.TxtFgN, X0, Y0, X1, Y1) >> 8 ) )
       strcpy ( SCompras.Articulo, buffer   );
       break;
  // Cantidad
  case  2:
       sprintf ( buffer, "%d", SCompras.Cantidades  );
       if ( !( InputCadenaG( buffer, 0, 4, Config.TxtBgN, Config.TxtFgN, X0, Y0, X1, Y1) >> 8 ) )
       {
        SCompras.Cantidades = atoi( buffer );
        MuestraCompras( 4, linea, NORMAL );
       }
       break;
  // Precio
  case  3:
       sprintf ( buffer, "%ld", SCompras.Precio  );
       if ( !( InputCadenaG( buffer, 0, 6, Config.TxtBgN, Config.TxtFgN, X0, Y0, X1, Y1) >> 8 ) )
       {
        SCompras.Precio = atol( buffer );
        MuestraCompras( 4, linea, NORMAL );
       }
       break;
  //Total
  case  4:
        break;
  // Proveedor
  case  5:
       sprintf ( buffer, "%d", SCompras.Proveedor  );
       if ( !( InputCadenaG( buffer, 0, 3, Config.TxtBgN, Config.TxtFgN, X0, Y0, X1, Y1) >> 8 ) )
       SCompras.Proveedor = atoi( buffer );
       break;
 }

}

 /**************************************************************************\
|*                                                                          *|
|*  ObtenCoordenadasCompras                                                     *|
|*                                                                          *|
|*  Descripci¢n:                                                            *|
|*              Obtiene las coordenadas de acotacion para el campo pedido   *|
|*                                                                          *|
|*  Entradas:                                                               *|
|*            columna    campo del que obtener las coordenadas              *|
|*            linea      linea en la que nos encontramos                    *|
|*            X0 Y0 X1 Y1  Punteros para devolver las coordenadas           *|
|*                                                                          *|
|*  Salidas:  (ninguna)                                                     *|
|*                                                                          *|
 \**************************************************************************/
void ObtenCoordenadasCompras( char columna, char linea, int *X0, int *Y0, int *X1, int *Y1 )
{

 // Calculamos la Y0, Y1 para la linea dada ( SOLO columna < 6 )
 *Y0 = 6 + linea;
 *Y1 = 6 + linea;

 switch( columna )
 {
  case 0:
       *X0 =   2;       *X1 =  10;
       break;
  case 1:
       *X0 =  13;       *X1 =  24;
       break;
  case 2:
       *X0 =  38;       *X1 =   7;
       break;
  case 3:
       *X0 =  46;       *X1 =  10;
       break;
  case 4:
       *X0 =  57;       *X1 =  13;
       break;
  case 5:
       *X0 =  71;       *X1 =   9;
       break;
 }


}

 /**************************************************************************\
|*                                                                          *|
|*  ComprasNuevoRegistro                                                        *|
|*                                                                          *|
|*  Descripci¢n:                                                            *|
|*              Limpia el buffer, para un nuevo registro.                   *|
|*                                                                          *|
|*  Entradas: (ninguna)                                                     *|
|*  Salidas:  (ninguna)                                                     *|
|*                                                                          *|
 \**************************************************************************/
void ComprasNuevoRegistro( INFO_PRECIOS *NSCompras )
{

 NSCompras -> Fecha.da_day  = 0;
 NSCompras -> Fecha.da_mon  = 0;
 NSCompras -> Fecha.da_year = AnoActual;

 NSCompras -> Articulo[0]   = '\0';
 NSCompras -> Cantidades = 0;
 NSCompras -> Precio = 0;
 NSCompras -> Proveedor = 0;

}




//  ßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßß
// Û                     Parte secundaria del m¢dulo                      Û
// Û                                                                      Û
// Û                  Secci¢n de Busqueda de refecencias                  Û
//  ÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜÜ

 /**************************************************************************\
|*                                                                          *|
|*  MuestraImpresionesRed                                                      *|
|*                                                                          *|
|*  Descripci¢n:                                                            *|
|*              Muestra un cuadro con las distintas opciones de impresi¢n   *|
|*                                                                          *|
|*  Entradas:(ninguna)                                                      *|
|*  Salidas: (ninguna)                                                      *|
|*                                                                          *|
 \**************************************************************************/


 /**************************************************************************\
|*                                                                          *|
|*  ImprimeCompraserencias                                                      *|
|*                                                                          *|
|*  Descripci¢n:                                                            *|
|*              Imprime todas las referencias seg£n se le indique           *|
|*                                                                          *|
|*  Entradas:                                                               *|
|*           Como imprimir las referencias                                  *|
|*                                                                          *|
|*  Salidas: (ninguna)                                                      *|
|*                                                                          *|
 \**************************************************************************/
void ImprimeCompraserencias( char como )
{
 long i, old_reg;
 FILE *file_out;

 old_reg = BCompras.RegActual();

 if ( !Config.Printer )
 {
   if ( ( file_out = fopen( Config.PrintTo, "w" ) ) == NULL )
                                                            return;
 } else
      file_out = stdprn;

 ImprimeCabeceraCompras( como, file_out );

 for ( i=0; i<BCompras.Registros(); i++ )
 {
  BCompras.LeeReg( (void *)&SCompras, i );
  switch( como )
  {
/*
   // Listado R pido
   case 1:

        formatea_u_long( (unsigned long)SCompras.CantUnitaria, buffer );
        fprintf( file_out, "%9lu  %-30s  %-6s  ", SCompras.CodigoR, SCompras.Descripcion, buffer );
        formatea_u_long( (unsigned long)SCompras.PrecioCosto,    buffer );
        fprintf( file_out, "%-7s  ", buffer );
        formatea_u_long( (unsigned long)SCompras.PrecioVenta[0], buffer );
        fprintf( file_out, "%-7s  %-10s\n\r", buffer, SCompras.Combinado ? "Combinado" : "" );
        break;
   // Listado Completo
   case 2:
        formatea_u_long( (unsigned long)SCompras.CantUnitaria, buffer );
        fprintf( file_out, "%9lu  %-30s  %-6s  ", SCompras.CodigoR, SCompras.Descripcion, buffer );
        formatea_u_long( (unsigned long)SCompras.PrecioCosto,    buffer );
        fprintf( file_out, "%-7s  ", buffer );
        formatea_u_long( (unsigned long)SCompras.PrecioVenta[0], buffer );
        fprintf( file_out, "%-7s  %-10s\n\r", buffer, SCompras.Combinado ? "Combinado" : "" );
        if ( SCompras.Combinado )
        {
         for ( j=0; j<10; j++ )
          if ( SCompras.CodigosAsociados[j] != 0 )
                   fprintf( file_out, "                                                           %-7s     %9lu", j < 4 ? SCompras.PrecioVenta[j+1] : 0, SCompras.CodigosAsociados[j] );
        }
        break;
   // C¢digos de barra
   case 3:
        break;
*/
  }
 }

 if ( !Config.Printer )
                      fclose( file_out );

 BCompras.LeeReg( (void *)&SCompras, old_reg );

}

void ImprimeCabeceraCompras( char como, FILE *file_out )
{
  switch( como )
  {
   // Listado R pido
   case 1:
        fprintf( file_out, "C¢digo     Proveedor                      Cant.Unt P.Costo  P.Venta  Combinado\n\r" );
        break;
   // Listado Completo
   case 2:
        fprintf( file_out, "C¢digo     Proveedor                      Cant.Unt P.Costo  P.Venta  Cod. Combinado\n\r" );
        break;
   // C¢digos de barra
   case 3:
        break;
  }

}

void Error( int code )
{

 printf( "\nSe produjo un codigo de error %d, subcodigo no disponible \n\r", code );
 switch( code )
 {
  case 0:
       printf( "\n Error incocumentado " );
       break;
  case 1:
       printf( "\n Error abriendo " );
       break;
  case 2:
       printf( "\n Error insertando " );
       break;
  case 3:
       printf( "\n Error leyendo " );
       break;
  case 4:
       printf( "\n Error escribiendo " );
       break;
  case 5:
       printf( "\n Error borrando " );
       break;
 };

 exit(code);
}










void DibujaPantallaGastosInt(void)
{
  textcolor( WHITE );
  textbackground( BLACK );
          // 145678 123456789-123456789-123 12345  345.789 123.123.123 123456789-123456789-

  cprintf( "\r                                                                                ");
  cprintf( "                                                                                ");
  cprintf( "ÚÄÄÄÄÄÄÄÄÄÄÂÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÂÄÄÄÄÄÄÄÂÄÄÄÄÄÄÄÄÄÄÂÄÄÄÄÄÄÄÄÄÄÄÄÄÂÄÄÄÄÄÄÄÄÄ¿");
  cprintf( "³  Fecha   ³ Articulo               ³  Und  ³  Precio  ³    Total    ³ N§ Pdor ³");
  cprintf( "ÃÄÄÄÄÄÄÄÄÄÄÅÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÅÄÄÄÄÄÄÄÅÄÄÄÄÄÄÄÄÄÄÅÄÄÄÄÄÄÄÄÄÄÄÄÄÅÄÄÄÄÄÄÄÄÄ´");
  cprintf( "³          ³                        ³       ³          ³             ³         ³");
  cprintf( "³          ³                        ³       ³          ³             ³         ³");
  cprintf( "³          ³                        ³       ³          ³             ³         ³");
  cprintf( "³          ³                        ³       ³          ³             ³         ³");
  cprintf( "³          ³                        ³       ³          ³             ³         ³");
  cprintf( "³          ³                        ³       ³          ³             ³         ³");
  cprintf( "³          ³                        ³       ³          ³             ³         ³");
  cprintf( "³          ³                        ³       ³          ³             ³         ³");
  cprintf( "³          ³                        ³       ³          ³             ³         ³");
  cprintf( "³          ³                        ³       ³          ³             ³         ³");
  cprintf( "³          ³                        ³       ³          ³             ³         ³");
  cprintf( "³          ³                        ³       ³          ³             ³         ³");
  cprintf( "³          ³                        ³       ³          ³             ³         ³");
  cprintf( "³          ³                        ³       ³          ³             ³         ³");
  cprintf( "³          ³                        ³       ³          ³             ³         ³");
  cprintf( "³          ³                        ³       ³          ³             ³         ³");
  cprintf( "³          ³                        ³       ³          ³             ³         ³");
  cprintf( "³          ³                        ³       ³          ³             ³         ³");
  cprintf( "ÀÄÄÄÄÄÄÄÄÄÄÁÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÁÄÄÄÄÄÄÄÁÄÄÄÄÄÄÄÄÄÄÁÄÄÄÄÄÄÄÄÄÄÄÄÄÁÄÄÄÄÄÄÄÄÄÙ");



}



void RastreaFicheroGastosi(void)
{
 char buffer[80], ok = 0, dev;
 char buffer1[80];
 int Proveedor; long i;
 long old_pos;

 long Meses[12] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
 char MesesF[12][80];

 // Pido el n§ de proveedor que deseo buscar
 Optar( ENCUADRE, "Rastreo de gastos", "Introduzca el n§ de", "proveedor, a rastrear.", "", "N§ Proveedor:             ", NULL );
 buffer[0] = '\0';
 if ( !( InputCadenaG( buffer, 1,  4, Config.TxtBgN, Config.TxtFgN, 46, 12, 4, 0) >> 8 ) )
 {
  Proveedor = atoi( buffer );
  ok = 1;
 }
 Optar( ENCUADRE, NULL );

 if ( ok == 1 )
 {
  Optar( ENCUADRE, "Realizando rastreo...", "Esto puede tardar unos", "minutos, por favor, epere...", NULL );



  old_pos = BCompras.RegActual();

  dev = OK;
  for ( i=0; i < BCompras.Registros(); i++ )
  {
   BCompras.LeeReg( (void *)&SCompras, i );
   if ( SCompras.Proveedor == Proveedor )
   {
    if ( SCompras.Fecha.da_mon > 0 && SCompras.Fecha.da_mon <= 12 )
      Meses[ SCompras.Fecha.da_mon - 1 ] += SCompras.Cantidades * SCompras.Precio;
   }
  }

  for( i = 0; i <  6; i++ )
  {
       formatea_u_long( Meses[i], buffer );
       formatea_u_long( Meses[i+6], buffer1);
       switch( i )
       {
        case  0: sprintf( MesesF[i], "Enero:  %10s Julio:      %10s", buffer, buffer1 ); break;
        case  1: sprintf( MesesF[i], "Febrero:%10s Agosto:     %10s", buffer, buffer1 ); break;
        case  2: sprintf( MesesF[i], "Marzo:  %10s Septiembre: %10s", buffer, buffer1 ); break;
        case  3: sprintf( MesesF[i], "Abril:  %10s Octubre:    %10s", buffer, buffer1 ); break;
        case  4: sprintf( MesesF[i], "Mayo:   %10s Noviembre:  %10s", buffer, buffer1 ); break;
        case  5: sprintf( MesesF[i], "Junio:  %10s Diciembre:  %10s", buffer, buffer1 ); break;
       }
  }


  Optar( ENCUADRE, NULL );

  Optar( 0, "Rastreo concluido", MesesF[0], MesesF[1], MesesF[2], MesesF[3], MesesF[4], MesesF[5], NULL );
  while( kbhit() ) getch();

  BCompras.LeeReg( (void *)&SCompras, old_pos );
 }




}



void OrdenarGastosi(void)
{
/*
BDatos BCompras;            // Base de datos de Compraserencias
INFO_PRECIOS SCompras;     // Estructura de referencias

int OrdenGestionInterna;
*/
struct Boton_Texto BT[4];
int devolver;

BT[0].x = 32; BT[0].y =  9; strcpy( BT[0].Texto, " &Fecha de compra   "); BT[0].ID_T1 =  0; BT[0].ID_T2 = 0;
BT[1].x = 32; BT[1].y = 11; strcpy( BT[1].Texto, " &Nombre de Articulo"); BT[1].ID_T1 =  0; BT[1].ID_T2 = 0;
BT[2].x = 32; BT[2].y = 13; strcpy( BT[2].Texto, " &Proveedor del Art "); BT[2].ID_T1 =  0; BT[2].ID_T2 = 0;
BT[3].x = 32; BT[3].y = 15; strcpy( BT[3].Texto, " &Cancelar operacion"); BT[3].ID_T1 =  0; BT[3].ID_T2 = 0;

 Optar( ENCUADRE, "Elija orden a seguir", NULL );

 while( ( devolver = Funcion_Botones(STD_BY, 4, BT) ) < 1 || devolver > 4 ) while ( kbhit() ) getch();

 if ( devolver != 4 )
 {
  OrdenGestionInterna = devolver;
  BCompras.SortReg( ComparaRegistros );
 }

 Optar( ENCUADRE, NULL );

}


int ComparaRegistros( const void *A, const void *B )
{
 // Tipos de ordenaciones posibles
 switch( OrdenGestionInterna )
 {
  // Por Proveedor
  case 3:
   if ( ( ((INFO_PRECIOS *)A) -> Proveedor ) <  ( ((INFO_PRECIOS *)B) -> Proveedor ) ) return -1;
   if ( ( ((INFO_PRECIOS *)A) -> Proveedor ) == ( ((INFO_PRECIOS *)B) -> Proveedor ) ) return  0;
   if ( ( ((INFO_PRECIOS *)A) -> Proveedor ) >  ( ((INFO_PRECIOS *)B) -> Proveedor ) ) return  1;
   break;
  // Por Articulo
  case 2:
   return strcmpi( ( ((INFO_PRECIOS *)A) -> Articulo ), ( ((INFO_PRECIOS *)B) -> Articulo ) );
  case 1:
   if ( ( ((INFO_PRECIOS *)A) -> Fecha.da_year ) < ( ((INFO_PRECIOS *)B) -> Fecha.da_year ) ) return -1;
   if ( ( ((INFO_PRECIOS *)A) -> Fecha.da_year ) > ( ((INFO_PRECIOS *)B) -> Fecha.da_year ) ) return  1;

   if ( ( ((INFO_PRECIOS *)A) -> Fecha.da_mon  ) < ( ((INFO_PRECIOS *)B) -> Fecha.da_mon  ) ) return -1;
   if ( ( ((INFO_PRECIOS *)A) -> Fecha.da_mon  ) > ( ((INFO_PRECIOS *)B) -> Fecha.da_mon  ) ) return  1;

   if ( ( ((INFO_PRECIOS *)A) -> Fecha.da_day  ) < ( ((INFO_PRECIOS *)B) -> Fecha.da_day  ) ) return -1;
   if ( ( ((INFO_PRECIOS *)A) -> Fecha.da_day  ) > ( ((INFO_PRECIOS *)B) -> Fecha.da_day  ) ) return  1;
   return 0;
 }

 return -1;
}