// Variazione movimenti di prima nota e movimenti iva

#include <mask.h>
#include <relation.h>
#include <tabutil.h>
#include <utility.h>
#include <config.h>
#include <mailbox.h>
#include <prefix.h>

#include <nditte.h>  
#include <mov.h>
#include <rmov.h>
#include <rmoviva.h>  
#include <pconti.h>
#include <occas.h>
#include <comuni.h>

#include "cglib04.h"
#include "cglib.h"   
#include "cg2103.h"
#include "conto.h"

#include "cg6800.h"
#include "cg6801.h"
#include "cg6802.h"
#include "cg6803.h"

class TVar_mov : public TApplication
{
  TIsamtempfile*   _tmov,* _trmov,* _tiva, *_toccas;
  TLocalisamfile*  _pcon,* _clifo, *_mov, *_rmov, *_rmoviva, *_occas;
  TTable*          _tab_reg;
  TRectype*        _rec_mov,* _rec_rmov,* _rec_riva;
  TTransfer_file   _tras_file;
  char             _scelta;
  
  TString _trasf,_std,_descr_civa;
  long    _dittaric,_numreg;      
  TString _control_rec,_record;         
  bool    _righe,_corrisp, _is_exist;          
  int     _numrig,_tiporeg;
  bool    _registrato;
  
public:        
  TString     _titolo;
  
  virtual bool create();
  virtual bool destroy();
  virtual bool menu(MENU_TAG m);         
  bool    main_loop();
  void    apri_temp_file();
  bool    esegui_controlli();
  bool    leggi_trasfer();
  bool    controlli();
  void    leggi_record_controllo();
  bool    video_PN();
  bool    video_IVA();  
  void    registra_PN(TMask& m);                
  void    registra_IVA(TMask& m);                  
  bool    esiste_testata_mov(TMask& m);
  bool    ricerca_movimento(TMask& m);

  bool    esiste_riga_mov(TMask& m);
  bool    esiste_riga_iva(TMask& m);  

  void    ricerca_codcaus(const TString& codcaus);
  void    setta_campi_maschera(TMask& m);                                  
  bool    setta_campi_maschera_iva(TMask& m);                                    

  void    registra_file_temp_mov(int,long,const TDate&,const TDate&,const TDate&,const TString&,TString&,long,long,const TString&,TString&);
  void    registra_file_temp_rmov(long,int,int,int,long,char,const TString&,int,int,long,const real&);
  void    registra_file_temp_riva(long,int,const real&,const TString&,const real&,int,int,int,int,long);

  void    setta_parametri_record(const TString& sigla,const TString& flag);
  
  char    TipoConto (int g, int c);    
  void    ricerca_localita(TString& com, TString& den, TString& cap, TString& prov);
  
  void    datacompetenza(int anno, TString& datacomp);
  
  static bool codice_registro_hnd   (TMask_field& f, KEY k);
  static bool codice_causale_hnd    (TMask_field& f, KEY k);
  static bool numero_protocollo_hnd (TMask_field& f, KEY k);
  static bool ultimo_protocollo_hnd (TMask_field& f, KEY k);
  static bool codice_pagamento_hnd  (TMask_field& f, KEY k);  
  static bool data_stampa           (TMask_field& f, KEY k);  
  static bool data_competenza_hnd   (TMask_field& f, KEY k);
  
  static bool controllo_partita       (TMask_field& f, KEY k);    
  static bool controllo_contropartita (TMask_field& f, KEY k);    
  static bool controllo_importo       (TMask_field& f, KEY k);    
  
  static bool localita_occasionali  (TMask_field& f, KEY k);
  static bool cap_occasionali       (TMask_field& f, KEY k);  
  static bool codice_clifo_hnd      (TMask_field& f, KEY k);
  static bool codice_iva_hnd        (TMask_field& f, KEY k);  
  static bool imposta_hnd           (TMask_field& f, KEY k);  
  static bool detraibilita_hnd      (TMask_field& f, KEY k);  
  static bool tipocr_hnd            (TMask_field& f, KEY k);
  static bool data                  (TMask_field& f, KEY k);

  bool   decodifica_codiva(const TString& codiva);
  
  TVar_mov(char mov);
};                                      

HIDDEN TVar_mov& app() { return (TVar_mov &) main_app(); }

char TVar_mov::TipoConto(int g, int c)
{
  TLocalisamfile pcon (LF_PCON);
  char tipo = ' ';
  
  pcon.setkey(1);
  pcon.zero();
  pcon.put(PCN_GRUPPO,     g);
  pcon.put(PCN_CONTO,      c);
  pcon.put(PCN_SOTTOCONTO, 0l);
  if (pcon.read() == NOERR)
    tipo = pcon.get_char(PCN_TMCF);

  return tipo;
}

TVar_mov::TVar_mov(char mov) : _scelta(toupper(mov))
{
  switch (_scelta)
  {
  case 'P':
    _titolo = "Variazione movimenti prima nota";
    break;
    
  case 'I':
    _titolo = "Variazione movimenti iva";
    break;
    
  default:
    break;
  }
}

bool TVar_mov::create()
{
  TApplication::create();

  _pcon     = new TLocalisamfile (LF_PCON);
  _clifo    = new TLocalisamfile (LF_CLIFO);
  _rec_mov  = new TRectype (LF_MOV);
  _mov      = new TLocalisamfile (LF_MOV);
  _rmov     = new TLocalisamfile (LF_RMOV);
  _rmoviva  = new TLocalisamfile (LF_RMOVIVA); 
  _occas    = new TLocalisamfile (LF_OCCAS);
  _tab_reg  = new TTable ("REG");
  
  _rec_rmov = new TRectype (LF_RMOV);
  _rec_riva = new TRectype (LF_RMOVIVA);
  
  _registrato = FALSE;
  
  dispatch_e_menu (BAR_ITEM(1));

  return TRUE;
}

bool TVar_mov::destroy()
{ 
  delete _rec_mov;
  delete _pcon;
  delete _clifo;
  delete _mov;
  delete _rmov;
  delete _rmoviva;                          
  delete _occas;
  delete _tab_reg;
  delete _trmov;
  delete _rec_rmov;                         
  delete _tiva;
  delete _toccas;
  delete _rec_riva;
  delete _tmov;                               
  
  return TApplication::destroy();
}                                

void TVar_mov::apri_temp_file()
{
  TString80 tmpmov = "%";
  tmpmov  << get_firm_dir();
  tmpmov << "\\" << TEMP_MOV;
  TString80 tmprmov = "%";
  tmprmov << get_firm_dir();         
  tmprmov << "\\" << TEMP_RMOV;  
    
  _tmov     = new TIsamtempfile(LF_MOV, tmpmov, 0);
  _trmov    = new TIsamtempfile(LF_RMOV, tmprmov, 0);

  TString80 tmprmoviva = "%";
  tmprmoviva << get_firm_dir();     
  tmprmoviva << "\\" << TEMP_RMOVIVA;                     
  TString80 tmpoccas = "%";
  tmpoccas << get_firm_dir();     
  tmpoccas << "\\" << TEMP_OCC;                     
  
  _is_exist = FALSE;
  TString tmp = tmprmoviva.mid(1);
  tmp << ".dbf";
  if (fexist(tmp))
  {
    _tiva     = new TIsamtempfile(LF_RMOVIVA, tmprmoviva, 0);
    _toccas   = new TIsamtempfile(LF_OCCAS, tmpoccas, 0);
    _is_exist = TRUE;
  }
}

void TVar_mov::leggi_record_controllo()
{
  _tras_file.read_control_rec();
  _control_rec = _tras_file.record();
}

bool TVar_mov::main_loop()
{      
  _dittaric = get_firm();
  
  if (!esegui_controlli()) return FALSE;

  apri_temp_file();

  if (_scelta == 'I' && !_is_exist)
    return error_box("I movimenti iva non sono stati ricevuti: impossibile variarli");
      
  if (_scelta == 'P')
  {
    if (!video_PN())
    {
      if (_registrato)
      {
        setta_parametri_record(" ","C");
        leggi_record_controllo();
        TString str (_control_rec.overwrite("               ",241));
        _tras_file.write_control_rec(str,256);
      }
      return FALSE;                                       
    }  
  }
  else
  {
    if (_scelta == 'I')
      if (!video_IVA())
      {
        if (_registrato)
        {
          setta_parametri_record(" ","C");
          leggi_record_controllo();
          TString str (_control_rec.overwrite("               ",241));
          _tras_file.write_control_rec(str,256);
        }
        return FALSE;  
      }
  }
  
  return FALSE;
}

bool TVar_mov::video_PN()
{   
  TMask msk ("cg6800a");
  KEY     tasto;
  
  do
  { 
    tasto = msk.run();     
    
    if (tasto != K_ENTER) return FALSE;
    
    if (ricerca_movimento(msk))
    {
      TMask mask ("cg6800b");
      
      mask.set_handler(F_REGIVA,    codice_registro_hnd);
      mask.set_handler(F_CODCAUS,   codice_causale_hnd);  
      mask.set_handler(F_PROTIVA,   numero_protocollo_hnd);
      mask.set_handler(F_NUPROTIVA, ultimo_protocollo_hnd);
      mask.set_handler(F_CODPAG,    codice_pagamento_hnd);
      mask.set_handler(F_DATAREG,   data_stampa);      
      mask.set_handler(F_DATACOMP,  data_competenza_hnd);
      mask.set_handler(F_DATADOC,   data);
            
      if (_righe)                    
      {
        mask.set_handler(F_SOTTOCONTO, controllo_partita);
        mask.set_handler(F_SOTTOC,     controllo_contropartita);
        mask.set_handler(F_IMPORTO   , controllo_importo);
      }
      
      setta_campi_maschera(mask);
      
      tasto = mask.run();
      
      switch (tasto)
      {
      case K_ESC :
        break;
        
      case K_QUIT :
        break;       
        
      case K_SAVE :
      {
        registra_PN(mask);
        _registrato = TRUE;
      }
        break;
        
      default:
        break;
      }
    }
  }
  while (tasto != K_QUIT);                              //K_ENTER
  
  return TRUE;
}

void TVar_mov::ricerca_codcaus(const TString& codcaus)
{
  TLocalisamfile cau (LF_CAUSALI);
  TString tipodoc;
  
  cau.setkey(1);
  cau.zero();
  cau.put("CODCAUS", (const char*) codcaus);
  if (cau.read() == NOERR)
    tipodoc = cau.get("TIPODOC");
  
  TTable tpd ("%TPD");
  
  tpd.zero();
  tpd.put("CODTAB", (const char*) tipodoc);
  if (tpd.read() == NOERR)
    _corrisp = tpd.get_bool("B0");
}

bool TVar_mov::video_IVA()
{   
  TMask msk ("cg6800a");
  KEY     tasto;
  
  do
  { 
    tasto = msk.run();
    
    if (tasto != K_ENTER) return FALSE;
    
    if (ricerca_movimento(msk))
    {
      TMask mask ("cg6800c");                    
      
      TString regiva = _rec_mov->get(MOV_REG);
      
      if (!setta_campi_maschera_iva(mask))
        return FALSE;
      
      mask.set_handler(F_CODCF,     codice_clifo_hnd);              
      mask.set_handler(F_DATA74TER, data);
      mask.set_handler(F_LOCALITA,  localita_occasionali);
      mask.set_handler(F_CAPOCC,    cap_occasionali);
      
      if (_righe)                    
      {
        mask.set_handler(F_SOTTOCONTO, controllo_partita);
        mask.set_handler(F_CODIVA,     codice_iva_hnd);
        mask.set_handler(F_IMPOSTA,    imposta_hnd);
        mask.set_handler(F_TIPODET,    detraibilita_hnd);
        mask.set_handler(F_TIPOCR,     tipocr_hnd);
      }
      
      tasto = mask.run();
      
      switch (tasto)
      {
      case K_ESC :
        break;
        
      case K_QUIT :
        break;       
        
      case K_SAVE :
      {
        registra_IVA(mask);
        _registrato = TRUE;
      }
        break;
        
      default:
        break;
      }
    }
  }
  while (tasto != K_QUIT);                              //K_ENTER
  
  return TRUE;
}

bool TVar_mov::ricerca_movimento(TMask& m)
{   
  _numrig = atoi(m.get(F_NUMRIG));
  
  if (_numrig == 0)
  {
    _righe = FALSE;
    return esiste_testata_mov(m);
  }
  else
  {
    _righe = TRUE;               
    
    bool annullato = esiste_testata_mov(m);
    
    if (!annullato) return FALSE;
    
    if (_scelta == 'P')
      return esiste_riga_mov(m);
    else
      return esiste_riga_iva(m);
  }
  
  return TRUE;
}

bool TVar_mov::esiste_testata_mov(TMask& m)
{
  _numreg = m.get_long(F_NUMREG);
  
  _tmov->setkey(1);
  _tmov->zero();
  _tmov->put(MOV_NUMREG, _numreg);
  
  if (_tmov->read() == NOERR)
  { 
    if (_scelta == 'P')
    {
      _trmov->setkey(1);
      _trmov->zero();
      _trmov->put(RMI_NUMREG, _numreg);
      _trmov->read();  
      long nr = _trmov->get_long(RMV_NUMREG);
      if (_numreg != nr)
        return error_box("Registrazione richiesta NON PRESENTE tra i movimenti in trasferimento");
    }
    else
      if (_scelta == 'I')
      { 
        _tiva->setkey(1);
        _tiva->zero();
        _tiva->put(RMI_NUMREG, _numreg);
        _tiva->read();  
        long nr = _tiva->get_long(RMI_NUMREG);
        if (_numreg != nr)
          return error_box("Registrazione richiesta NON PRESENTE tra i movimenti in trasferimento");
      }
    
    *_rec_mov = _tmov->curr();  
  }
  else
    return error_box("Registrazione richiesta NON PRESENTE tra i movimenti in trasferimento");
  
  return TRUE;
}

bool TVar_mov::esiste_riga_mov(TMask& m)
{
  _numreg = m.get_long(F_NUMREG);
  _numrig = m.get_int (F_NUMRIG);
  
  _trmov->setkey(1);
  _trmov->zero();
  _trmov->put(RMV_NUMREG, _numreg);
  _trmov->put(RMV_NUMRIG, _numrig);  
  
  if (_trmov->read() == NOERR)
    *_rec_rmov = _trmov->curr();  
  else
    return error_box("Registrazione richiesta NON PRESENTE tra i movimenti in trasferimento");
  
  return TRUE;
}

bool TVar_mov::esiste_riga_iva(TMask& m)
{
  _numreg = m.get_long(F_NUMREG);
  _numrig = m.get_int (F_NUMRIG);
  
  _tiva->setkey(1);
  _tiva->zero();
  _tiva->put(RMI_NUMREG, _numreg);
  _tiva->put(RMI_NUMRIG, _numrig);  
  
  if (_tiva->read() == NOERR)
    *_rec_riva = _tiva->curr();  
  else
    return error_box("Registrazione richiesta NON PRESENTE tra i movimenti in trasferimento");
  
  return TRUE;
}

void TVar_mov::setta_campi_maschera(TMask& m)
{                                                     
  TDate   datareg (_rec_mov->get_date(MOV_DATAREG));
  TDate   datadoc (_rec_mov->get_date(MOV_DATADOC));
  TDate   datacomp(_rec_mov->get_date(MOV_DATACOMP));
  int     anno   = _rec_mov->get_int (MOV_ANNOES);
  
  TString numdoc    = _rec_mov->get     (MOV_NUMDOC);
  TString regiva    = _rec_mov->get     (MOV_REG);
  regiva.trim();
  long    protiva   = _rec_mov->get_long(MOV_PROTIVA);
  long    nuprotiva = _rec_mov->get_long(MOV_UPROTIVA);
  TString codcaus   = _rec_mov->get     (MOV_CODCAUS);
  TString codpag    = _rec_mov->get     (MOV_CODPAG);
  codpag.trim();
  
  m.set(F_NUMREG,    _numreg);
  m.set(F_NUMRIG,    _numrig); 
  m.set(F_DATAREG,   datareg.string());
  m.set(F_DATACOMP,  datacomp.string());
  m.set(F_ANNO,      anno);
  m.set(F_DATADOC,   datadoc.string());
  m.set(F_NUMDOC,    numdoc);
  m.set(F_REGIVA,    regiva);
  m.set(F_PROTIVA,   protiva);
  m.set(F_NUPROTIVA, nuprotiva);
  m.set(F_CODCAUS,   codcaus);
  m.set(F_CODPAG,    codpag);

  m.disable(F_NUMREG);
  m.disable(F_NUMRIG);       
  
  if (!_righe)
  {    
    m.enable(F_DATAREG);    
    m.enable(F_DATACOMP);
    m.enable(F_DATADOC);
    m.enable(F_NUMDOC);
    m.enable(F_REGIVA);
    m.enable(F_PROTIVA);
    m.enable(F_NUPROTIVA);
    m.enable(F_CODCAUS);
    m.enable(F_CODPAG);
    m.disable(F_GRUPPO);
    m.disable(F_CONTO);
    m.disable(F_SOTTOCONTO);
    m.disable(F_SEZIONE);
    m.disable(F_IMPORTO);
    m.disable(F_DESCR);
    m.disable(F_GRUPPOC);
    m.disable(F_CONTOC);
    m.disable(F_SOTTOC);
  }
  else    
    if (_righe)
    {
      int     gruppo   = _trmov->get_int (RMV_GRUPPO);
      int     conto    = _trmov->get_int (RMV_CONTO);
      long    sottocon = _trmov->get_long(RMV_SOTTOCONTO);
      TString sezione  = _trmov->get     (RMV_SEZIONE);
      TString descr    = _trmov->get     (RMV_DESCR);
      int     gruppoc  = _trmov->get_int (RMV_GRUPPOC);
      int     contoc   = _trmov->get_int (RMV_CONTOC);
      long    sottoc   = _trmov->get_long(RMV_SOTTOCONTOC);
      real    importo  = _trmov->get_real(RMV_IMPORTO);  
      
      m.set(F_GRUPPO,     gruppo);
      m.set(F_CONTO,      conto);
      m.set(F_SOTTOCONTO, sottocon);
      m.set(F_SEZIONE,    sezione);
      m.set(F_DESCR,      descr);
      m.set(F_GRUPPOC,    gruppoc);
      m.set(F_CONTOC,     contoc);
      m.set(F_SOTTOC,     sottoc);
      m.set(F_IMPORTO,    importo.string());
      
      m.disable(F_DATAREG);           
      m.disable(F_DATACOMP);
      m.disable(F_DATADOC);
      m.disable(F_NUMDOC);
      m.disable(F_REGIVA);
      m.disable(F_PROTIVA);
      m.disable(F_NUPROTIVA);
      m.disable(F_CODCAUS);
      m.disable(F_CODPAG);
      
      m.enable(F_GRUPPO);
      m.enable(F_CONTO);
      m.enable(F_SOTTOCONTO);
      m.enable(F_SEZIONE);
      m.enable(F_IMPORTO);
      m.enable(F_DESCR);
      m.enable(F_GRUPPOC);
      m.enable(F_CONTOC);
      m.enable(F_SOTTOC);
    }
}

bool TVar_mov::setta_campi_maschera_iva(TMask& m)
{  
  TDate   datareg   (_rec_mov->get_date(MOV_DATAREG));
  TDate   data74ter (_rec_mov->get_date(MOV_DATA74TER));
  TString regiva    = _rec_mov->get     (MOV_REG);
  regiva.trim();
  TString codcaus   = _rec_mov->get     (MOV_CODCAUS);
  long    codcf     = _rec_mov->get_long(MOV_CODCF); 
  TString ocfpi     = _rec_mov->get     (MOV_OCFPI);
  
/*****************************************************
 *****           CLIENTI OCCASIONALI             *****
 *****************************************************/

  TString ragsoc,ind,com,cap,localita,prov,civ;  
  
  if (ocfpi.not_empty())
  {              
    _toccas->setkey(1);            
    _toccas->zero();
    _toccas->put(OCC_CFPI, ocfpi);
    if (_toccas->read() == NOERR)
    {
      ragsoc    = _toccas->get(OCC_RAGSOC);
      ind       = _toccas->get(OCC_INDIR);
      civ       = _toccas->get(OCC_CIV);
      com       = _toccas->get(OCC_COM);
      cap       = _toccas->get(OCC_CAP);
    
      TLocalisamfile comuni (LF_COMUNI);
    
      comuni.setkey(1);
      comuni.zero();
      comuni.put(COM_COM, com);
      if (comuni.read() == NOERR)
      {                      
        localita  = comuni.get(COM_DENCOM);
        prov      = comuni.get(COM_PROVCOM);
      }
    }
  }
  
/*****************************************************/
  
  if (codcaus.not_empty())
    ricerca_codcaus(codcaus);
  
  int anno = date2esc(datareg);
  
  TRegistro rg (regiva, anno); 
  _tiporeg = rg.tipo();
  
  if (regiva.not_empty())
  {
    if (!rg.ok())  
      return error_box("Registrazione presente ma con PRIMANOTA ERRATA: correggerla prima");
  }
  else
    return error_box("Campo NON VALIDO o codice NON PRESENTE in archivio");    
  
  m.set(F_NUMREG,    _numreg);
  m.set(F_NUMRIG,    _numrig); 
  m.set(F_DATA74TER, data74ter.string());
  m.set(F_CODCF,     codcf);       
  m.set(F_RAGSOCOCC, ragsoc);
  m.set(F_INDOCC,    ind);   
  m.set(F_CIVOCC,    civ);
  m.set(F_LOCALITA,  localita);
  m.set(F_CAPOCC,    cap);
  m.set(F_PROVOCC,   prov);          
  m.set(F_COMOCC,    com);
  m.set(F_CFPI,      ocfpi);

  m.disable(F_NUMREG);
  m.disable(F_NUMRIG);       
  
  if (!_righe)
  {    
    m.enable(F_DATA74TER);
    m.enable(F_CODCF);
    m.enable(F_RAGSOCOCC);
    m.enable(F_INDOCC);
    m.enable(F_CIVOCC);
    m.enable(F_LOCALITA);
    m.enable(F_CAPOCC);
    m.enable(F_PROVOCC);
    m.disable(F_IMPONIBILE);
    m.disable(F_CODIVA);
    m.disable(F_IMPOSTA);
    m.disable(F_TIPODET);
    m.disable(F_TIPOCR);
    m.disable(F_GRUPPO);
    m.disable(F_CONTO);
    m.disable(F_SOTTOCONTO);
  }
  else
    if (_righe)
    {
      real    imponibile (_tiva->get_real(RMI_IMPONIBILE));
      TString codiva     (_tiva->get     (RMI_CODIVA));
      real    imposta    (_tiva->get_real(RMI_IMPOSTA));
      int     tipodet   = _tiva->get_int (RMI_TIPODET);
      int     tipocr    = _tiva->get_int (RMI_TIPOCR);
      int     gruppo    = _tiva->get_int (RMI_GRUPPO);
      int     conto     = _tiva->get_int (RMI_CONTO);
      long    sottoc    = _tiva->get_long(RMI_SOTTOCONTO);
      
      m.set(F_IMPONIBILE, imponibile.string());
      m.set(F_CODIVA,     codiva);
      m.set(F_IMPOSTA,    imposta.string());
      m.set(F_TIPODET,    tipodet);
      m.set(F_TIPOCR,     tipocr);
      m.set(F_GRUPPO,     gruppo);
      m.set(F_CONTO,      conto);
      m.set(F_SOTTOCONTO, sottoc);
      
      m.disable(F_DATA74TER);
      m.disable(F_CODCF);
      m.disable(F_RAGSOCOCC);
      m.disable(F_INDOCC);
      m.disable(F_CIVOCC);
      m.disable(F_LOCALITA);
      m.disable(F_CAPOCC);
      m.disable(F_PROVOCC);
      
      m.enable(F_IMPONIBILE);
      m.enable(F_CODIVA);
      m.enable(F_IMPOSTA);
      m.enable(F_TIPODET);
      m.enable(F_TIPOCR);
      m.enable(F_GRUPPO);
      m.enable(F_CONTO);
      m.enable(F_SOTTOCONTO);
    }
  
  return TRUE;
}

bool TVar_mov::codice_registro_hnd(TMask_field& f, KEY k)
{ 
  TTable reg ("REG");
  TString descr,dep;
  
  if (k == K_TAB || k == K_ENTER)
  {              
    TString codreg = f.get();
    TDate   datareg (f.mask().get(F_DATAREG));
    int     anno   = date2esc(datareg);
    
    dep.format("%04d%-3s", anno, (const char*) codreg);
    
    reg.zero();
    reg.put("CODTAB", dep);
    if (reg.read() == NOERR)
    {
      descr = reg.get("S0");
      f.mask().set(F_DESCRREG, descr);
    }
    else
      if (codreg.not_empty() && f.mask().is_running())
      {
        descr = "";
        f.mask().set(F_DESCRREG, descr);
        return warning_box("Codice registro IVA non presente in tabella");                               
      }
  } 
  
  return TRUE;
}

bool TVar_mov::codice_causale_hnd(TMask_field& f, KEY k)
{
  if (k == K_TAB || k == K_ENTER)
  {         
    TString codcau = f.get();
    
    if (f.mask().is_running())
    {
      TString codreg = f.mask().get(F_REGIVA);
      
      if (codreg.not_empty())
        if (codcau.empty())
          return warning_box("Il codice registro IVA e' significativo: deve essere significativo anche il codice causale");
    }
    
    TLocalisamfile cau (LF_CAUSALI);
    cau.setkey(1);
    cau.zero();
    cau.put("CODCAUS", codcau);
    if (cau.read() == NOERR)
    {
      const TString& descr = cau.get("DESCR");
      f.mask().set(F_DESCRCAU, descr);
    }                                 
    else           
      if (f.mask().is_running())
      {
        const TString& descr = "";
        f.mask().set(F_DESCRCAU, descr);  
        return warning_box("Codice causale non presente in tabella");
      }
  }            
  return TRUE;
}

bool TVar_mov::numero_protocollo_hnd(TMask_field& f, KEY k)
{
  if (k != K_ENTER) return FALSE;
  
  TString codreg   = f.mask().get(F_REGIVA);
  long    protiva  = atol(f.mask().get(F_PROTIVA));
  long    uprotiva = atol(f.mask().get(F_NUPROTIVA));
  
  if (codreg.empty())
    if (protiva != 0)
      return warning_box("Il codice registro IVA non e' significativo: non e' possibile compilare il numero protocollo IVA");
  
  return TRUE;    
}

bool TVar_mov::ultimo_protocollo_hnd(TMask_field& f, KEY k)
{
  if (k != K_ENTER) return FALSE;
  
  TString codreg   = f.mask().get(F_REGIVA);
  long    protiva  = atol(f.mask().get(F_PROTIVA));
  long    uprotiva = atol(f.mask().get(F_NUPROTIVA));
  
  if (codreg.empty())
    if (uprotiva != 0)  
      return warning_box("Il codice registro IVA non e' significativo: non e' possibile compilare l' ultimo numero protocollo IVA");
  
  if (protiva == 0)
    if (uprotiva != 0)
      return warning_box("Numero protocollo IVA non significativo: non e' possibile compilare il numero protocollo IVA riepilogato"); 
  
  return TRUE;    
}

bool TVar_mov::codice_pagamento_hnd(TMask_field& f, KEY k)
{ 
  TTable pag ("%CPG");
  TString descr,codpag,dep;
  
  if (k == K_TAB || k == K_ENTER)
  {              
    codpag = f.get();
    dep.format("%04s", (const char*)codpag);
    
    pag.zero();
    pag.put("CODTAB", dep);
    if (pag.read() == NOERR)
    {
      descr = pag.get("S0");
      f.mask().set(F_DESCRPAG, descr);
    }
    else
      if (codpag.not_empty() && k == K_ENTER)
      {
        descr = "";
        f.mask().set(F_DESCRPAG, descr);  
        return warning_box("Codice pagamento non presente in tabella");                               
      }
  } 
  
  return TRUE;
}
                                                            
bool TVar_mov::data_competenza_hnd(TMask_field& f, KEY k)
{             
  if (k == K_TAB || k == K_ENTER)
  {
    const TDate dr(f.mask().get(F_DATAREG));      // Data operazione
                    
    if (f.mask().is_running())                
      if ( !(TDate::isdate(f.get())) )
        return warning_box("Data errata o formato non valido");
      
    TString16 datacomp = f.get();
    if (datacomp.empty())
    {                           
      int anno = atoi(f.mask().get(F_ANNO));
      app().datacompetenza(anno,datacomp);
      f.set(datacomp);
    }

    TDate dc (f.get());
    
    int ae = date2esc(dc);
    
    if (ae)
    {                     
      int pr;                             // Esercizio precedente
      const int ar = date2esc(dr, &pr);   // Esercizio in corso
      if (ae != ar && ae != pr)
      {
        TString80 e; 
        e << "La data di competenza deve appartenere all'esercizio " << ar; 
        if (pr > 0) e << " o al " << pr;
        return f.error_box(e);
      }
      f.mask().set(F_ANNO, ae);
    }  
    else  
    {
      if (f.mask().is_running())
        return f.error_box("La data non appartiene a nessun esercizio");
    }
  }
   
  return TRUE;
}
                                                            
bool TVar_mov::data_stampa(TMask_field& f, KEY k)
{
  if (k == K_ENTER)
  {     
    if (f.mask().is_running())
      if ( !(TDate::isdate(f.get())) )
        return warning_box("Data errata o formato non valido");
      
    TDate datareg (f.mask().get(F_DATAREG));                               
    const int ae = date2esc(datareg);         
  
    TLibro_giornale gio;
    gio.read(ae);  //se _ae e' zero la read considera come anno quello corrente
  
    if (datareg < gio.last_print())
      return warning_box("La data di registrazione e' minore della data di stampa del Libro Giornale");  

    TString codreg = f.mask().get(F_REGIVA);

    if (!codreg.blank()) //movimento iva (fattura)
    {
      TRegistro rg (codreg, ae);   
    
      if (datareg < rg.last_print())
        return error_box("La data di registrazione e' minore della data stampa del registro IVA");
    }
  }
  return TRUE;
}

bool TVar_mov::controllo_partita(TMask_field& f, KEY k)
{
  if (k == K_TAB || k == K_ENTER)
  {  
    int  gruppo = f.mask().get_int (F_GRUPPO);
    int  conto  = f.mask().get_int (F_CONTO);
    long sottoc = f.mask().get_long(F_SOTTOCONTO);
    
    char tipo = app().TipoConto(gruppo,conto);
    
    TConto tc (gruppo,conto,sottoc,tipo); 
    
    TString descr = tc.descrizione();          
    f.mask().set(F_DESCRPARTITA, descr);
    
    if (k == K_ENTER)
      if (!tc.find())
        return warning_box("Sottoconto partita non presente in anagrafica Piano dei Conti oppure anagrafica Clienti / Fornitori");
  }     
  
  return TRUE; 
}

bool TVar_mov::controllo_contropartita(TMask_field& f, KEY k)
{
  if (k == K_TAB || k == K_ENTER)
  { 
    int  gruppo = f.mask().get_int (F_GRUPPOC);
    int  conto  = f.mask().get_int (F_CONTOC);
    long sottoc = f.mask().get_long(F_SOTTOC);
    
    char tipo = app().TipoConto(gruppo,conto);
    
    TConto tc (gruppo,conto,sottoc,tipo); 
    
    TString descr = tc.descrizione();          
    f.mask().set(F_DESCRCPARTITA, descr);
    
    if (k == K_ENTER)
      if (gruppo != 0 && conto != 0 && sottoc != 0)
        if (!tc.find())
          return warning_box("Sottoconto contropartita non presente in anagrafica Piano dei Conti oppure anagrafica Clienti / Fornitori");
  }     
  
  return TRUE; 
}

bool TVar_mov::controllo_importo(TMask_field& f, KEY k)
{
  if (k == K_ENTER)
  {
    real importo (f.mask().get(F_IMPORTO));
    char sezione = f.mask().get(F_SEZIONE)[0];
    
    if (importo == ZERO && (sezione == 'A' || sezione == 'D') )
      return warning_box("L' importo deve essere significativo");
    if (sezione == '\0' && importo != ZERO)
      return warning_box("La sezione e' nulla: l'importo non puo' essere significativo");
  }     
  
  return TRUE; 
}

bool TVar_mov::codice_clifo_hnd(TMask_field& f, KEY k)
{   
  char tipo;
  
  if (k == K_TAB || k == K_ENTER) 
  {
    long codcf = atol(f.get());
    if (app()._tiporeg == 1)
      tipo = 'C';
    else
      if (app()._tiporeg == 2)
        tipo = 'F';
    
    TConto tc (0,0,codcf,tipo);
    
    if (tc.find())
    {
      TString descr = tc.descrizione();
      f.mask().set(F_RAGSOCCF, descr);
    }                                 
    else
      if (k == K_ENTER)
      {
        TString descr = "";
        f.mask().set(F_RAGSOCCF, descr);  
        return warning_box("Campo NON VALIDO o codice non presente in archivio");
      }
  }
  
  return TRUE;  
}

bool TVar_mov::localita_occasionali(TMask_field& f, KEY k)
{             
  if (k == K_TAB)
  {  
    TString com,den,prov,cap;  
    
    com  = "";
    den  = "";
    prov = "";
    cap  = "";
          
    TString localita = f.mask().get(F_LOCALITA);
    
    com = app()._tras_file.cerca_comune_den(localita);
      
    if (com.not_empty())           
      app().ricerca_localita(com,den,cap,prov);  

    f.mask().set(F_COMOCC,   com);
    f.mask().set(F_LOCALITA, den);
    f.mask().set(F_CAPOCC,   cap);
    f.mask().set(F_PROVOCC,  prov);
  }
  
  return TRUE;
}

bool TVar_mov::cap_occasionali(TMask_field& f, KEY k)
{             
  if (k == K_TAB)
  { 
    TString com,den,prov,cap;
    
    den  = "";
    prov = "";
    cap  = "";
    com  = "";
            
    TString capocc = f.mask().get(F_CAPOCC);    
    
    if (capocc.not_empty())
      com = app()._tras_file.cerca_comune_cap(capocc);

    if (com.not_empty())           
      app().ricerca_localita(com,den,cap,prov);  

    f.mask().set(F_COMOCC,   com);
    f.mask().set(F_LOCALITA, den);
    f.mask().set(F_CAPOCC,   cap);
    f.mask().set(F_PROVOCC,  prov);
  }
  
  return TRUE;
}

bool TVar_mov::codice_iva_hnd(TMask_field& f, KEY k)
{   
  if (k == K_TAB || k == K_ENTER) 
  {
    TString codiva = f.get();
    
    bool ok = app().decodifica_codiva(codiva);
    
    f.mask().set(F_DESCRCODIVA, app()._descr_civa);
    
    if (k == K_ENTER)
    {
      real imponibile (f.mask().get(F_IMPONIBILE));
      real imposta    (f.mask().get(F_IMPOSTA));
      
      if ( (imponibile != ZERO || imposta != ZERO) && codiva.empty() )
        return warning_box("Il codice IVA deve essere indicato obbligatoriamente");
      
      if (codiva.not_empty())
        if (!ok)
          return warning_box("Codice non presente in tabella");  
    }
  }
  
  return TRUE;  
}

bool TVar_mov::decodifica_codiva(const TString& codiva)
{
  TTable iva ("%IVA");
  TString dep;
  
  dep.format("%-4s", (const char*)codiva);
  
  iva.zero();
  iva.put("CODTAB", dep);
  if (iva.read() == NOERR)
  {
    _descr_civa = iva.get("S0");
    return TRUE;
  }  
  else        
  {
    _descr_civa = "";
    return FALSE;
  }
  
  return TRUE;
}

bool TVar_mov::imposta_hnd(TMask_field& f, KEY k)
{   
  if (k == K_ENTER) 
  {
    real imposta    (f.mask().get(F_IMPOSTA));
    
    if (app()._corrisp && imposta != ZERO)
      return warning_box("Il movimento e' relativo ad un corrispettivo: l'imposta deve essere uguale a 0");
  }
  
  return TRUE;  
}

bool TVar_mov::detraibilita_hnd(TMask_field& f, KEY k)
{   
  if (k == K_ENTER) 
  {
    int det = atoi(f.get());
    
    if (det != 0 && det != 1 && det != 3 && det != 9)
      return warning_box("Valore non ammesso per il tipo detraibilita'");
  }
  
  return TRUE;  
}

bool TVar_mov::tipocr_hnd(TMask_field& f, KEY k)
{   
  if (k == K_ENTER) 
  {
    int tcr = atoi(f.get());
    
    if (tcr != 0 && tcr != 1 && tcr != 2 && tcr != 3 
        && tcr != 4 && tcr != 5 && tcr != 8 && tcr != 9)
      return warning_box("Valore non ammesso per il tipo costo/ricavo");
  }
  
  return TRUE;  
}                                   

bool TVar_mov::data(TMask_field& f, KEY k)
{   
  if (k == K_ENTER) 
  { 
    if ( !(TDate::isdate(f.get())) )
      return warning_box("Data errata o formato non valido");
  }
  
  return TRUE;  
}                                   

void TVar_mov::datacompetenza(int anno, TString& datacomp)
{
  TTable esc ("ESC");
  
  TString dep (format("%04d", anno));
  
  esc.zero();
  esc.put("CODTAB", dep);
  if (esc.read() == NOERR)
    datacomp = esc.get("D1");
  else
    datacomp = "";
}

void TVar_mov::ricerca_localita(TString& codcom, TString& den, TString& cap, TString& prov)
{
  TLocalisamfile com (LF_COMUNI);
  
  com.setkey(1);
  com.zero();
  com.put(COM_COM, codcom);
  if (com.read() == NOERR)
  {
    den  = com.get(COM_DENCOM);
    cap  = com.get(COM_CAPCOM);
    prov = com.get(COM_PROVCOM);
  }                             
  else
  {
    den  = "";                 
    cap  = "";
    prov = "";
  }
}

void TVar_mov::registra_PN(TMask& m)
{ 
  if (!_righe)
  {
    long    numreg    = m.get_long(F_NUMREG);
    int     anno      = m.get_int (F_ANNO);    
    TDate   datareg    (m.get(F_DATAREG));
    TDate   datacomp   (m.get(F_DATACOMP));        
    TDate   datadoc    (m.get(F_DATADOC));
    TString numdoc    = m.get     (F_NUMDOC);
    TString regiva    = m.get     (F_REGIVA);
    long    protiva   = m.get_long(F_PROTIVA);
    long    nuprotiva = m.get_long(F_NUPROTIVA);
    TString codcaus   = m.get     (F_CODCAUS);
    TString codpag    = m.get     (F_CODPAG);
    
    registra_file_temp_mov(anno,numreg,datareg,datacomp,datadoc,numdoc,regiva,protiva,nuprotiva,codcaus,codpag);
  }
  else
    if (_righe)
    {                                    
      long    numreg   = m.get_long(F_NUMREG);
      int     numrig   = m.get_int (F_NUMRIG);
      int     gruppo   = m.get_int (F_GRUPPO);
      int     conto    = m.get_int (F_CONTO);      
      long    sottoc   = m.get_long(F_SOTTOCONTO);
      char    sezione  = m.get     (F_SEZIONE)[0];
      TString descr    = m.get     (F_DESCR);
      int     gruppoc  = m.get_int (F_GRUPPOC);
      int     contoc   = m.get_int (F_CONTOC);
      long    sottocc  = m.get_long(F_SOTTOC);
      real    importo  (m.get(F_IMPORTO));  
      
      registra_file_temp_rmov(numreg,numrig,gruppo,conto,sottoc,sezione,descr,gruppoc,contoc,sottocc,importo);
    }
}

void TVar_mov::registra_file_temp_mov(int ae,long nr,const TDate& dr,const TDate& dc,const TDate& dd,
                                      const TString& nd,TString& ri,long pi,long upi,const TString& cc,TString& cp)
{
  _tmov->setkey(1);
  _tmov->zero();
  _tmov->put(MOV_NUMREG, nr);
  if (_tmov->read() == NOERR)
  {
    _tmov->put(MOV_ANNOES,   ae);
    _tmov->put(MOV_DATAREG,  dr);
    _tmov->put(MOV_DATACOMP, dc);
    _tmov->put(MOV_DATADOC,  dd);
    _tmov->put(MOV_NUMDOC,   nd);  
    _tmov->put(MOV_REG,      ri);
    _tmov->put(MOV_PROTIVA,  pi);
    _tmov->put(MOV_UPROTIVA, upi);
    _tmov->put(MOV_CODCAUS,  cc);
    _tmov->put(MOV_CODPAG,   cp);
    
    _tmov->rewrite();
  }
  
  TRectype* rec_rmov,* rec_riva;
  rec_rmov = new TRectype (LF_RMOV);

  _trmov->setkey(1);
  _trmov->zero();
  _trmov->put(RMV_NUMREG, nr); 
  *rec_rmov = _trmov->curr();
  
  for (_trmov->read(); !_trmov->eof(); _trmov->next())
  {
    if (_trmov->curr() > *rec_rmov) break;
    
    _trmov->put(RMV_ANNOES,  ae);
    _trmov->put(RMV_DATAREG, dr);
    
    _trmov->rewrite();
  }
  
  delete rec_rmov;
  
  rec_riva = new TRectype (LF_RMOVIVA);

  _tiva->setkey(1);
  _tiva->zero();
  _tiva->put(RMI_NUMREG, nr); 
  *rec_riva = _tiva->curr();
  
  for (_tiva->read(); !_tiva->eof(); _tiva->next())
  {
    if (_tiva->curr() > *rec_riva) break;
    
    _tiva->put(RMI_ANNOES, ae);
    
    _tiva->rewrite();
  }
  
  delete rec_riva;
}

void TVar_mov::registra_file_temp_rmov(long nr,int nri,int g,int c,long s,char sez,const TString& desc,
                                       int gc,int cc,long sc,const real& imp)
{
  _trmov->setkey(1);
  _trmov->zero();
  _trmov->put(RMV_NUMREG, nr);
  _trmov->put(RMV_NUMRIG, nri);  
  if (_trmov->read() == NOERR)
  {
    _trmov->put(RMV_GRUPPO,      g);
    _trmov->put(RMV_CONTO,       c);
    _trmov->put(RMV_SOTTOCONTO,  s);
    _trmov->put(RMV_SEZIONE,     sez);
    _trmov->put(RMV_DESCR,       desc);
    _trmov->put(RMV_GRUPPOC,     gc);
    _trmov->put(RMV_CONTOC,      cc);
    _trmov->put(RMV_SOTTOCONTOC, sc);
    _trmov->put(RMV_IMPORTO,     imp);     
    
    _trmov->rewrite();
  }
}

void TVar_mov::registra_IVA(TMask& m)
{     
  TString ocfpi;
  
  if (!_righe)
  {
    long    numreg    = m.get_long(F_NUMREG);
    TDate   data74ter  (m.get(F_DATA74TER));
    long    codcf     = m.get_long(F_CODCF);

/*****************************************************
 *****            CLIENTI OCCASIONALI            *****
 *****************************************************/
      
    TString ragsococc = m.get     (F_RAGSOCOCC);
    TString indocc    = m.get     (F_INDOCC);
    TString civocc    = m.get     (F_CIVOCC);
    TString localita  = m.get     (F_LOCALITA);
    TString capocc    = m.get     (F_CAPOCC);  
    TString comocc    = m.get     (F_COMOCC);
    
    TString com;
    
    if (ragsococc.not_empty())
    {
      ocfpi     = m.get     (F_CFPI);    
      
      // Se il cliente occasionale non esisteva su questo movimento e da maschera l'ho
      // aggiunto devo determinare con quale codice memorizzarlo sul file dove non esiste
      // Sara' il successivo all'ultimo esistente sul file.
      
      if (ocfpi.empty())                     
      { 
        TString app;
        long    progr;
        
        _toccas->last();
        ocfpi = _toccas->get(OCC_CFPI);
        app = ocfpi.mid(0,3);
        if (app == "RIC")
          progr = atol(ocfpi.mid(3,6));
        else
          progr = 0;
          
        progr++;
        ocfpi = format("%3s%6d", (const char*) "RIC", progr);  
      }
      
      // Se invece gia' esisteva sul movimento il campo della maschera nascosto contiene gia'
      // il valore e mi basta fare una rewrite().
      
      _toccas->setkey(1);
      _toccas->zero();
      _toccas->put(OCC_CFPI, ocfpi);
      if (_toccas->read() == NOERR)
      {
        _toccas->put(OCC_RAGSOC, ragsococc);
        _toccas->put(OCC_INDIR,  indocc);
        _toccas->put(OCC_CIV,    civocc);
        _toccas->put(OCC_COM,    comocc);
        _toccas->put(OCC_CAP,    capocc);
                          
        _toccas->rewrite();
      }
      else
      {                 
        _toccas->put(OCC_CFPI,   ocfpi);
        _toccas->put(OCC_RAGSOC, ragsococc);
        _toccas->put(OCC_INDIR,  indocc);
        _toccas->put(OCC_CIV,    civocc);
        _toccas->put(OCC_COM,    comocc);
        _toccas->put(OCC_CAP,    capocc);
        
        _toccas->write();      
      }
    }
    else
    { 
      // Se esisteva e lo voglio cancellare devo toglierlo fisicamente dal file
      
      ocfpi     = m.get     (F_CFPI);    
      
      if (ocfpi.not_empty())
      {
        _toccas->setkey(1);
        _toccas->zero();
        _toccas->put(OCC_CFPI, ocfpi);
        if (_toccas->read() == NOERR)
        {
          _toccas->remove();
          ocfpi = "";
        }
      }
    }
/*****************************************************/    

    _tmov->setkey(1);
    _tmov->zero();
    _tmov->put(MOV_NUMREG, numreg);
    if (_tmov->read() == NOERR)
    {
      _tmov->put(MOV_DATA74TER, data74ter);
      _tmov->put(MOV_CODCF,     codcf);
      _tmov->put(MOV_OCFPI,     ocfpi);
      
      _tmov->rewrite();
    }
  }
  else
    if (_righe)
    {                                    
      long    numreg    = m.get_long(F_NUMREG);
      int     numrig    = m.get_int (F_NUMRIG);
      real    imponibile (m.get     (F_IMPONIBILE));
      TString codiva    = m.get     (F_CODIVA);      
      real    imposta    (m.get     (F_IMPOSTA));
      int     tipodet   = m.get_int (F_TIPODET);
      int     tipocr    = m.get_int (F_TIPOCR);
      int     gruppo    = m.get_int (F_GRUPPO);
      int     conto     = m.get_int (F_CONTO);
      long    sottoc    = m.get_long(F_SOTTOCONTO);
      
      registra_file_temp_riva(numreg,numrig,imponibile,codiva,imposta,tipodet,tipocr,gruppo,conto,sottoc);
    }
}

void TVar_mov::registra_file_temp_riva(long nr,int nri,const real& imp,const TString& civa,const real& imposta,
                                       int tdet,int tcr,int g,int c,long s)
{
  _tiva->setkey(1);
  _tiva->zero();
  _tiva->put(RMI_NUMREG, nr);
  _tiva->put(RMI_NUMRIG, nri);  
  if (_tiva->read() == NOERR)
  {
    _tiva->put(RMI_IMPONIBILE, imp);
    _tiva->put(RMI_CODIVA,     civa);
    _tiva->put(RMI_IMPOSTA,    imposta);
    _tiva->put(RMI_TIPODET,    tdet);
    _tiva->put(RMI_TIPOCR,     tcr);
    _tiva->put(RMI_GRUPPO,     g);
    _tiva->put(RMI_CONTO,      c);
    _tiva->put(RMI_SOTTOCONTO, s);
    
    _tiva->rewrite();
  }
}                                       

bool TVar_mov::leggi_trasfer()
{ 
  _trasf = _tras_file.path(_dittaric);
  _trasf << HEADER;
  
  _tras_file.open(_trasf);
  
  if (_tras_file.exist())
  {  
    if (_tras_file.read_control_rec())
      _control_rec = _tras_file.record();
    else
      return error_box("Rilevati gravi errori negli archivi:procedura interrotta");
  } 
  else
    return error_box("Al momento non presenti trasferimenti attivi sulla ditta selezionata");
  
  return TRUE; 
}

bool TVar_mov::esegui_controlli()
{                    
  TConfig conf(CONFIG_DITTA);           
  
  _std = conf.get("FlStTra");

  if (!prefix().exist(_dittaric))
    return error_box("Rilevati gravi errori negli archivi: procedura interrotta");
  
  if (!leggi_trasfer())
    return FALSE;

  if (!controlli())
    return FALSE;     
  
  return TRUE;
}

void TVar_mov::setta_parametri_record(const TString& sigla,const TString& flag)
{ 
  TConfig conf (CONFIG_DITTA);
  
  conf.set("FlStTra", flag);
  
  leggi_record_controllo();
  _control_rec.overwrite(sigla,240);
  
  const int size = 256;
  
  _tras_file.write_control_rec(_control_rec, size);
}

bool TVar_mov::controlli()
{ 
  TString16 chiave,sigla;
  
  chiave = _control_rec.sub(241,256);
  chiave.trim();        
  sigla  = _control_rec.sub(240,241);
  sigla.trim();

  if (_std == "M" && sigla == "Z" && chiave != "")
    return error_box("Variazione NON POSSIBILE: trasferimento movimenti gia' iniziato");           
  
  if (_std == "M" && sigla == "U")
    return error_box("Variazione NON POSSIBILE: trasferimento movimenti gia' iniziato");           

  if (_std == "*") 
  {
    warning_box("Trasferimento interamente completato: proseguire per cancellare il file");    
    _tras_file.remove_all();
    setta_parametri_record(" "," ");
    return FALSE;
  }

  if (_std == "T")
    return error_box("Variazione NON POSSIBILE: eseguire prima la ricezione delle tabelle");           
  
  return TRUE;
}

bool TVar_mov::menu(MENU_TAG m)
{
  if (m == BAR_ITEM(1))
    return main_loop(); 
  return FALSE;
}

int cg6800 (int argc, char* argv[])
{                                
  switch (*argv[2])
  {
  case 'P':
  {
    TVar_mov main_app(*argv[2]);       
    main_app.run(argc, argv,main_app._titolo);
  }
  break;
 case 'I':
{
  TVar_mov main_app(*argv[2]);       
  main_app.run(argc, argv,main_app._titolo);
}
break;
 case 'S':
{   
  TDitta_ric a;       
  a.run(argc, argv,"Scelta ditta per ricezione");
}
break;
 case 'A':
{   
  TAnn_mov a;       
  a.run(argc, argv,"Annullamento movimenti da ricevere");
}
break;
 case 'V':
{   
  TVis_ric a;       
  a.run(argc, argv,"Visualizzazione stato ricezione");
}
break;    
default:
break;
}
//main_app.run(argc, argv,main_app._titolo);
return TRUE;
}
