// 770100.cpp - Scheda percipienti
#include <relapp.h>
#include <msksheet.h>
#include <tabutil.h>
#include <mailbox.h>
#include <defmask.h>

#include "scperc.h"
#include "rver.h"
#include "rpag.h"
#include "perc.h"

#include "770101.h"  
#include "770102.h"  
#include "770100a.h"
#include "770.h"
#include "77lib.h"

HIDDEN TString80 __tmp;
HIDDEN const int NUM_COL_VERS = 8;  // Contano da 0
HIDDEN const int NUM_COL_PAG = 9;	//  "  " "  " "

TSchedaPercipienti::TSchedaPercipienti(): _rel(NULL), _flag_cg(FALSE)
{
  _from_modify = FALSE;
  memset(_msk, 0, sizeof(_msk));
}

void  TSchedaPercipienti::update_lasts(TMask& m)
{
  if (m.mode() == MODE_MOD)   
  {
    const long codditta = m.get_long(F_CODDITTA);
    const char tipoa = m.get(F_TIPOA)[0];
    const long codanagr = m.get_long(F_CODANAGR);
    const int  nprog = m.get_int(F_NPROG);

// Determino ultimo numero di riga usato nei PAGAMENTI
    _rpag->zero();
    _rpag->put("CODDITTA", (long) codditta);
    _rpag->put("TIPOA", tipoa);
    _rpag->put("CODANAGR", (long) codanagr);
    _rpag->put("NPROG", nprog);

    TRectype dep(_rpag->curr());    
    long nriga = 0L;
    
    for (_rpag->read(); !_rpag->eof(); _rpag->next())
    {
      if (_rpag->curr() > dep) break;
      nriga = _rpag->get_long("NRIGA");
    }                                    
    _lastpag = nriga;

// Determino ultimo numero di riga usato nei VERSAMENTI
    _rver->zero();
    _rver->put("CODDITTA", (long) codditta);
    _rver->put("TIPOA", tipoa);
    _rver->put("CODANAGR", (long) codanagr);
    _rver->put("NPROG", nprog);

    TRectype dep2(_rver->curr());    
    long nrigav = 0L;
    
    for (_rver->read(); !_rver->eof(); _rver->next())
    {
      if (_rver->curr() > dep2) break;
      nrigav = _rver->get_long("NRIGA");
    }                                    
    _lastvers = nrigav;
  }
  else
    _lastpag = _lastvers = 0L;
}

bool TSchedaPercipienti::changing_mask(int mode)
{
 if ((mode == MODE_MOD) && (_mode == MODE_INS))
	return FALSE; 
 else	              
  return _mode != mode;
}

TMask* TSchedaPercipienti::get_mask(int mode)
{
  const int m = (mode == MODE_QUERY) ? 0 : 1;
  _mode = mode;
  return load_mask(m);
}


TMask* TSchedaPercipienti::load_mask(int n)
{
  if (_msk[n] != NULL) 
    return _msk[n];

  TFilename name("770100"); name << char(n == 0 ? 'a' : 'b');
  TMask* m = new TMask(name);
                             
  switch (n)
  {                                   
  case 0:        
    m->set_handler(F_NPROG, nprog_handler);
    m->set_handler(F_CODDITTA, codditta_handler);
    m->set_handler(F_CODANAGRCOM,  codanagr_handler);
    m->set_handler(F_CODANAGRPERC,  codanagr_handler);    
    break;
  case 1: 
    {
      m->disable(DLG_FINDREC);    
      m->set_handler(F_DATADOC, check_handler);
      m->set_handler(F_CODCAUS, check_causale);
      m->set_handler(F_SPESE,   check_spese);
      m->set_handler(F_COMPENS, check_compensi);
      
////////////////////////////////////////////////////////////////////////
// Handler versamenti
////////////////////////////////////////////////////////////////////////
      TSheet_field& vers = (TSheet_field&) m->field(F_VERSAMENTI);  
      vers.set_notify(vers_notify);
      vers.sheet_mask().set_handler(F_VERS_1015, vers1015_handler);
      vers.sheet_mask().set_handler(DLG_SELPAG, pag_select);
      vers.sheet_mask().set_handler(DLG_AZZERA, ver_azzera);
      vers.sheet_mask().set_handler(F_TIPOVERS, tipo_hndl);
      vers.sheet_mask().set_handler(F_LUOVERS,  luo_hndl);
      vers.sheet_mask().set_handler(F_ABI,  abicab_hndl);
      vers.sheet_mask().set_handler(F_CAB,  abicab_hndl);      
      
////////////////////////////////////////////////////////////////////////
// Handler pagamenti                                                    
////////////////////////////////////////////////////////////////////////
      TSheet_field& pags = (TSheet_field&) m->field(F_PAGAMENTI);  
      pags.set_notify(pags_notify);
      pags.sheet_mask().set_handler(MPAG_COMPENSO,     compenso_handler);
      pags.sheet_mask().set_handler(MPAG_IMPONIBILE,   imponibile_handler);
      pags.sheet_mask().set_handler(MPAG_PERCRA,       percra_handler);
      pags.sheet_mask().set_handler(MPAG_NETTO,        netto_handler);      
      pags.sheet_mask().set_handler(MPAG_SPESA,        spesa_handler);
      pags.sheet_mask().set_handler(MPAG_RITPAG,       check_ritenuta);
      pags.sheet_mask().set_handler(DLG_AZZERAPAG,  pag_azzera);    
    }
    break;
  default:
    CHECKD(0, "Che strano genere di maschera e' la ", n);
    break;  
  }
  return _msk[n] = m;
}
                               
// Ricerca e output dell'ultimo nprog del percipiente scelto
bool TSchedaPercipienti::setta_nprog(TMask& m, const bool variazione, const char* codanag)
{
  long  nprog = 0L;
  TString16 numdoc;
  const char tipoa    = m.get(F_TIPOA)[0];               
  TString16 codanagr(codanag ? codanag : m.get(F_CODANAGR));
  const long codditta = app().tipo_coll()==nessuno ? get_firm_770() : app().get_firm();

// Scrivi nprog solo se il percipiente ESISTE sull'arkivio, non SEMPRE
  if (!app().esiste_perc(m, codanagr))
    return TRUE;
    
  TLocalisamfile scperc(LF_SCPERC, FALSE);    
  scperc.zero();
  scperc.put("CODDITTA", codditta);  
  scperc.put("TIPOA", tipoa);
  scperc.put("CODANAGR", codanagr);
  if (variazione)
  {
    scperc.put("CODANAGR", codanagr);
    scperc.put("DATADOC", app()._coll._datadoc);
    scperc.setkey(2);
  } 
  
  TRectype rec(scperc.curr());
  bool trovato = FALSE;
  bool one_rec = FALSE;
        
  scperc.read();

  if (scperc.eof())
  { 
    one_rec = TRUE;
    nprog  = scperc.get_long("NPROG");
    numdoc = scperc.get("NUMDOC");
    
    trovato = scperc.curr() == rec; 
    
/*    if (variazione)
      trovato = scperc.curr() == rec;   // (numdoc == app()._coll._numdoc);
    else 
      trovato = scperc.curr() == rec; */
  }
  else                              
    for ( ; !scperc.eof(); scperc.next())   
    {
      if (trovato || scperc.curr() > rec) break;
      numdoc = scperc.get("NUMDOC");    
      numdoc.trim();
      nprog  = scperc.get_long("NPROG");

//      trovato = scperc.curr() == rec; 
      
      if (variazione) 
        trovato = (numdoc == app()._coll._numdoc);
    }

// Azzero nprog se la scheda non e' quella giusta
  if (variazione || one_rec)
    if (!trovato) nprog = 0L;
  
  app()._last_scheda = nprog;
  
  m.set(F_NPROG, variazione ? nprog : nprog+1);

  return TRUE;
}

bool TSchedaPercipienti::codditta_handler(TMask_field& f, KEY k)
{
  if (k == K_TAB && !(f.mask().is_running()) )
  {
    TString16 codditta;      
// Se chiamata dalla contabilita' prendo ditta con get_firm    
    if (app().tipo_coll() == nessuno)
      codditta << get_firm_770();
    else
      codditta << app().get_firm();
      
    if (codditta != "0")
    {
      f.set(codditta);
      f.check();
    }
  }   
  return TRUE;
}

bool TSchedaPercipienti::codanagr_handler(TMask_field& f, KEY k)
{
//  if (k == K_TAB && f.focusdirty())
// Faccio sempre l'output di codesto numeretto
  if (k == K_TAB)
  {
    TMask& m = f.mask();
    const bool variazione = app().coll_variazione();
    char tipo = f.mask().get(F_TIPOA)[0];
    TString16 codanagr(f.get());
    if (codanagr.not_empty())  
    {
			if (!app().esiste_perc(f.mask(), codanagr)) 
      	return f.warning_box("Percipiente non valido");;
      setta_nprog(m, variazione, codanagr);
    }
  }

  return TRUE;
}

bool TSchedaPercipienti::esiste_perc(TMask& m, const char* codanag)
{
  const char tipoa    = m.get(F_TIPOA)[0];               
  TString16 codanagr(codanag ? codanag : m.get(F_CODANAGR));

// Controllo che l'anagrafica esista
  TLocalisamfile anag(LF_ANAG);
  anag.zero();
  anag.put("TIPOA",    tipoa);
  anag.put("CODANAGR", codanagr);
  const bool esiste_anagr = anag.read() == NOERR;      

  return esiste_anagr;
}

// Passa al modo inserimento/modifica.
bool TSchedaPercipienti::nprog_handler(TMask_field& f, KEY key)
{
  if (!f.mask().is_running()) 
    return TRUE;            

  if (key == K_CTRL+K_TAB)
  {
    f.set_dirty();
    return TRUE;
  }
    
  const int nprog = atoi(f.get());

  if (key == K_ENTER)
    if (app()._flag_cg)
    {
      app()._flag_cg = FALSE;   // avoid recursion
      if (nprog==0 || !app().esiste_perc(f.mask())) 
        return FALSE;
//      f.mask().stop_run(K_AUTO_ENTER);
    } 
         
//  if (key == K_TAB)
//  {
//    if (!app().esiste_perc(f.mask())) 
//      return FALSE;
//    f.mask().stop_run(K_AUTO_ENTER); // entra in modo modifica/inserimento
//  }
  return TRUE;
}

bool TSchedaPercipienti::user_create()
{                          
  _per      = new TLocalisamfile(LF_PERC);
  _rel      = new TSchedaPE;
  _rver     = new TLocalisamfile(LF_RVER);
  _rpag     = new TLocalisamfile(LF_RPAG);

  _pags = new TNikArray_sheet(-1, -1, -4, -4, "Selezione Pagamenti",
         "@1|Data@11|Compenso@16|Spese@16|Ritenuta@16|",
         0,NULL_WIN,5);

  set_search_field(F_CODANAGRPERC);

//  simulo una chiamata da contabilità
//  (lo lascio per eventuali prove)
//  real totdocla = ZERO;
//  real spesela = ZERO;
//	real compensola = ZERO;
//	real impostela = ZERO;
//	real ritenutela = ZERO;
//	TToken_string s(80);
//  s.add(3);
//  s.add("M");
//  s.add("F");
//  s.add(30010);
//  s.add(1);
//  s.add("2");
//  s.add("05-02-1997");
//  s.add(totdocla.string());
//  s.add(spesela.string());    
//  s.add(compensola.string());    
//  s.add(impostela.string());    
//  s.add(ritenutela.string());   
//  const char* name = "770 -0";
//  TMessage mla(name, "LINK770", s);                                                      
//  mla.send();                        
    
// Collegamento da contabilita'
  TMailbox m;
  TMessage* msg = m.next_s("LINK770");

  if (msg != NULL)           
  {
    if ( !_coll.read(msg->body()) )
#ifdef DBG
      return warning_box("Errore nei parametri passati");
#endif
     ;

    const long ditta_cg = get_firm();
    if (!exist_dichiar_770(ditta_cg))
      if (yesno_box("Creo la dichiarazione per la ditta %ld", ditta_cg))
        if (!enter_dichiar_770(ditta_cg))
#ifdef DBG        
          return warning_box("Creazione dichiarazione fallita!");
#endif          
            ;

  }
    
  load_mask(0);                                   

  return TRUE;
}

bool TSchedaPercipienti::user_destroy()
{ 
  if (_msk[1] != NULL) delete _msk[1];
  if (_msk[0] != NULL) delete _msk[0];

  delete _rel;  delete _per;  delete _rver;
  delete _rpag; delete _pags;

  return TRUE;
}

//
// COMPILA_TESTATA
//
// Usata nel collegamento da cg 
//
void TSchedaPercipienti::compila_testata(TMask& m)
{
  m.set(F_DATADOC,  _coll._datadoc);
  m.set(F_NUMDOC,   _coll._numdoc);
  m.set(F_IVA,      _coll._imposte.string());  
  m.set(F_SPESE,    _coll._spese.string());
  m.set(F_COMPENS,  _coll._compenso.string());
      
  switch (tipo_coll())
  {                               
    case occasionale:
      m.set(F_COMPENS, _coll._compenso.string()); 
      m.set(F_TOTDOC,  _coll._compenso.string());   
      break;
    case fattura:
      m.set(F_TOTDOC, _coll._totdoc.string());   
      m.set(F_TOTRIT, _coll._ritenute.string());
      break;
    default:
      break;
  }
}

bool TSchedaPercipienti::coll_variazione() const
{ 
  return _coll._immissione == 'M' || tipo_coll() == pagamento || 
         tipo_coll() == pagamento_piu_perc; 
}

void TSchedaPercipienti::get_ragsoc(const char* tipoa, const long codanagr)
{
  TLocalisamfile anag(LF_ANAG);
  anag.zero();
  anag.setkey(1);
  anag.put("TIPOA", tipoa);
  anag.put("CODANAGR", codanagr);
  const int rc = anag.read();
  if (rc != NOERR) 
    anag.zero();
  _ragsoc = anag.get("RAGSOC");
}

void TSchedaPercipienti::init_modify_mode(TMask& m)
{
  _from_modify = TRUE;
  _codanagr    = m.get_long(F_CODANAGR);
  _tipoa       = m.get(F_TIPOA);
  get_ragsoc(_tipoa, _codanagr);
  init_mask(m);
}
  
void TSchedaPercipienti::init_insert_mode(TMask& m)
{
  init_mask(m);
}

void TSchedaPercipienti::on_config_change()
{
  TConfig conf(CONFIG_STUDIO);
  _anno_dic = (int)conf.get_long(ANNO_SEL, NULL); 
}

void TSchedaPercipienti::init_query_mode(TMask& m)
{
  m.set(F_ANNODIC, _anno_dic);

// Controllo se chiamata dalla contabilita'  
  if (tipo_coll() != nessuno)
  {                          
    const bool variazione = coll_variazione();        
    _flag_cg = TRUE;                    
    TString16 tipo("");
    tipo << _coll._tipo;
    m.set(F_TIPOA,        tipo);
    if (_coll._codanagr != 0L)
    {
      m.set(F_CODANAGR,     _coll._codanagr);
      m.set(F_CODANAGRPERC, _coll._codanagr, TRUE);
      m.set(F_CODANAGRCOM,  _coll._codanagr);        
    } 
    
    switch (tipo_coll())
    {
      case fattura:
        setta_nprog(m, variazione);
        m.send_key(K_AUTO_ENTER,0); 
        return;
        break;
      case pagamento:
        if (coll_datanum())
        {
          setta_nprog(m, variazione);
          m.send_key(K_AUTO_ENTER,0);
        }  
        return;
        break;     
      case occasionale:
     // setta_nprog(m,FALSE); // Sempre in aggiunta
        m.send_key(K_AUTO_ENTER, 0); 
        return;
        break;
      default:
        break;
    }
  }

  if (_from_modify)  
  {
    m.set(F_TIPOA,    _tipoa);
    m.set(F_CODANAGR, _codanagr);
    m.set(F_CODANAGRPERC, _codanagr);
    m.set(F_CODANAGRCOM, _codanagr);
    m.set(F_RAGSOCPER,   _ragsoc);
    m.set(F_RAGSOCCOM,   _ragsoc);
  }    
  else 
  {
    m.hide(-1);  // group 1 Scelta ANAGR
    m.show(-2);  // group 3 Ricerca su DATI PER
  }

  _from_modify = FALSE;

// forza il ricalcolo dell'ultimo numero disponibile
  TString16 dummy(m.get(F_NPROG));
  if (dummy.not_empty())
    setta_nprog(m);
}

void TSchedaPercipienti::init_query_insert_mode(TMask& m)
{
  m.set(F_ANNODIC, _anno_dic);

// Se vengo da modifica mantieni la selezione precedente
  if (_from_modify)
  {
    m.set(F_TIPOA,    _tipoa);
    m.set(F_CODANAGR, _codanagr);
    m.set(F_CODANAGRPERC, _codanagr);
    m.set(F_CODANAGRCOM, _codanagr);
    m.set(F_RAGSOCPER,   _ragsoc);
    m.set(F_RAGSOCCOM,   _ragsoc);
  }
  else
  {
    m.hide(-2);  // group 3 Nasconde ricerca su PERC
    m.show(-1);  // group 1 Ricerca su ANAGR
  }
}

void TSchedaPercipienti::rec2row(TToken_string& r, TRectype& rec, int row)
{
  TString16     dver, dpag, serie, numero, rite;
  TString16     comp, impo, perc,  spesa, netto;
  TString16     nrigavers, numpag, progrbanca;
  TString		SsnPerc, SsnCompl;
  
  r = ""; 
  if (rec.num() == LF_RVER) 
  {
    char v1015 = rec.get_bool("VERS1015") ? 'X' : ' ';
    dver       = rec.get("DATAVERS");
    char  tv   = rec.get_char("TIPOVERS");
    char  lv   = rec.get_char("LUOVERS");
    serie      = rec.get("SERIE");
    numero     = rec.get("NUMERO");
    rite       = rec.get("RITENUTA");      
    progrbanca = rec.get("PROGBANC");
    nrigavers    = rec.get("NRIGA");    

    if (rite.empty())       rite = " ";
    if (progrbanca.empty()) progrbanca = " ";
    if (nrigavers.empty())  nrigavers = " ";    
    if (serie.empty())      serie = " ";
    if (numero.empty())     numero = " ";
    
    r.add(v1015, 0); 
    r.add(dver,1); 
    r.add(lv == '\0' ? ' ' : lv); 
    r.add(tv == '\0' ? ' ' : tv);
    r.add(serie);     
    r.add(numero);           
    r.add(progrbanca);
    r.add(rite);
    r.add(nrigavers);
    
    if (v1015 == 'X')
      disable_vers_cells(row);
    else
      enable_vers_cells(row);
  }

  if (rec.num() == LF_RPAG)
  {
    dpag = rec.get("DATAPAG");
    comp = rec.get("COMPENSO");
    impo = rec.get("IMPONIBILE");
    perc = rec.get("PERC");
    rite = rec.get("RITENUTA");
    spesa = rec.get("SPESA");
    netto = rec.get("NETTO");     
    SsnPerc = rec.get("CTSSNPERC");
    SsnCompl = rec.get("CTSSNCOMP");  
    nrigavers    = rec.get("NUMVERS");
    
    r.add(dpag);  r.add(comp); 
    r.add(spesa); r.add(impo);
    r.add(perc);  r.add(rite); 
    r.add(SsnPerc); r.add(SsnCompl);
    r.add(netto);
    r.add(nrigavers); 
  }
}

int TSchedaPercipienti::read(TMask& m)
{
  m.autoload(*_rel);
  
  TSheet_field& pags = (TSheet_field&)m.field(F_PAGAMENTI);
  pags.destroy();
  
  for (int r = 0; r < _rel->pag_items(); r++)
    rec2row(pags.row(r), _rel->pag(r), r);

  TSheet_field& vers = (TSheet_field&)m.field(F_VERSAMENTI);
  vers.destroy();
  
  for (r = 0; r < _rel->ver_items(); r++) 
    rec2row(vers.row(r), _rel->ver(r), r);
      
  return 0;
}            

void TSchedaPercipienti::enable_vers_cells(int r, bool enable)
{
  TSheet_field& ver = vers();
  for (int i=1; i<NUM_COL_VERS; i++)
    enable ? ver.enable_cell(r,i) : ver.disable_cell(r,i);
}

void TSchedaPercipienti::new_row(TSheet_field& ver_pag, int r, bool vers) 
{ 
  TToken_string&    riga = ver_pag.row(r);

  if (vers)
    riga.add(++_lastvers, NUM_COL_VERS);
  else 
    riga.add(-1, NUM_COL_PAG);  
}
          
//
//  FILL_SHEET
//  
// Determino QUI un progressivo unico per i pagamenti e i versamenti
// (NUMVERS e NUMPAG: vedi new_row())
//        
void TSchedaPercipienti::fill_sheet(TMask& m) 
{ 
  TSheet_field& pags = (TSheet_field&)m.field(F_PAGAMENTI);
  for (int r = pags.items(); r < 16; r++)
    new_row(pags, r, FALSE);

  TSheet_field& vers = (TSheet_field&)m.field(F_VERSAMENTI);
  for (r = vers.items(); r < 16; r++) 
    new_row(vers, r, TRUE);
}

bool TSchedaPercipienti::scrivi_dati_per(TRectype& rec)
{
  TLocalisamfile dati_per(LF_PERC);
  const long codditta = rec.get_long("CODDITTA");
  char       tipoa    = rec.get_char("TIPOA");
  const long codanagr = rec.get_long("CODANAGR");
  
  dati_per.zero();
  dati_per.put("CODDITTA", codditta);    
  dati_per.put("TIPOA", tipoa);    
  dati_per.put("CODANAGR", codanagr);   
  
  const bool preesistente = (dati_per.read() == NOERR);
  
  if (!preesistente)
  {
    dati_per.zero();
    dati_per.put("CODDITTA", codditta);    
    dati_per.put("TIPOA", tipoa);    
    dati_per.put("CODANAGR", codanagr);   
  
    dati_per.write();   
  }
    
  return preesistente;
}

int  TSchedaPercipienti::rewrite(const TMask& m)
{
  mask2rel(m);
  const int err = _rel->rewrite();
  scrivi_dati_per(_rel->curr());         
//  update_lasts();   // aggiorna lastvers e lastpag
  return err;
}

int  TSchedaPercipienti::write(const TMask& m)
{
  mask2rel(m);
  const int err = _rel->write();
  scrivi_dati_per(_rel->curr());
//  update_lasts();   // aggiorna lastvers e lastpag  
  return err;
}

bool TSchedaPercipienti::check_compensi(TMask_field& f, KEY k)           
{
  if (k == K_ENTER)
  {
    const bool forzatura = f.mask().get_bool(F_FORCED);  
    real       doc_compenso(f.get());

    if (app()._tot_compenso > doc_compenso)
    {  
      f.warning_box ("Il totale dei compensi non puo' superare\n"
                     "il compenso indicato nel documento");

      return forzatura;
    }
  }
  return TRUE;     
}

bool TSchedaPercipienti::check_spese(TMask_field& f, KEY k)           
{
  if (k == K_ENTER)
  {
    const bool forzatura = f.mask().get_bool(F_FORCED);  
    real       doc_spese(f.get());

    if (app()._tot_spese > doc_spese)
    {
      f.warning_box ("Il totale delle spese non puo' superare\n"
                     "la spesa indicata nel documento");
      return forzatura;
    }
  }
  return TRUE;
}

//           
// Calcola:
//
// totale compenzi
// totale spese
// totale netti pagati
//
// - NB - 
// FUNZIONA SOLO SE PASSA PRIMA DI QUA!
// 
bool TSchedaPercipienti::check_handler(TMask_field& f, KEY k)
{  
  if (k == K_ENTER)
  {      
    const bool forzatura = f.mask().get_bool(F_FORCED);    
    int     i;
    TArray& rpag = app().pags().rows_array();

    app()._tot_compenso = ZERO;
    app()._tot_spese    = ZERO;
    app()._tot_netto    = ZERO;
    app()._tot_rit      = ZERO;
    
// Calcolo totale compensi e totale spese e totale netti  
    for (i = 0; i < rpag.items(); i++)
    {
      TToken_string& row = (TToken_string&)rpag[i];    
      
      if (app().my_empty_items(row, FALSE)) continue;  

      real      compenso  (row.get(1));  
      real      spese     (row.get(2));
      real      ritenuta  (row.get(5));      
      real      netto     (row.get(8));               
      
      app()._tot_compenso  += compenso;
      app()._tot_spese     += spese;
      app()._tot_netto     += netto;
      app()._tot_rit       += ritenuta;        
    }

    /**const real somma = doc_compenso + doc_spese;
    if (tot_netto > somma)
    {
      warning_box ("Il totale dei netti pagati non puo' superare\n"
                   "la somma del compenso e della spesa indicate nel documento");
      return forzatura;
    }**/
    
    TArray& rver        = app().vers().rows_array();
    app()._tot_vers     = ZERO;  
    
// Calcola totale versato
    for (i = 0; i < rver.items(); i++)
    { 
      TToken_string& row = (TToken_string&)rver[i];    
      if (app().my_empty_items(row, TRUE)) continue;  
      real       versato (row.get(7));
      app()._tot_vers  += versato;
    }

    app()._tot_rit.round(0);
    app()._tot_vers.round(0);
    
    const real THRESOLD = 500.00;
    const real diff = app()._tot_vers - app()._tot_rit;
    
    if (diff > ZERO)
      if (diff > THRESOLD)
      {
        f.warning_box ("La differenza tra il totale dei versamenti " 
                       "e il totale delle ritenute non puo' superare "
                       "le %s lire", THRESOLD.string());
        return forzatura;
      }
  }
  return TRUE;
}

// Trasferisce i dati dalla maschera alla relazione
void TSchedaPercipienti::mask2rel(const TMask& m)
{
  _rel->lfile().zero();
  m.autosave(*_rel);
  
  const long codditta = m.get_long(F_CODDITTA);
  const char tipoa    = m.get(F_TIPOA)[0];
  const long codanagr = m.get_long(F_CODANAGR);
  const int  nprogr   = m.get_int(F_NPROG);
      
  _rel->destroy_rows();                  // Destroy all records
  pag_pack();                            // Destroy all null rows

  TArray& rows = pags().rows_array();
  
  for (int i = 0; i < rows.items(); i++)
  {
    TToken_string& row = (TToken_string&)rows[i];
    TRectype &r = _rel->pag(i);

    long nriga = i + 1;
    
    r.zero();
    r.put("CODDITTA", codditta);
    r.put("TIPOA",    tipoa);
    r.put("CODANAGR", codanagr);
    r.put("NPROG",    nprogr);
    r.put("NRIGA",    nriga);

// LEGGO SPREADSHEET PAGAMENTI
    TString16 datap = row.get(0);
    const TDate datapag(datap);
    real      compenso  (row.get(1));  
    real      spese     (row.get(2));
    real      imponibile(row.get(3));
    const real aliquota(row.get(4));
    real      ritenuta  (row.get(5));         
    real	SsnPerc  (row.get(6));
    real	SsnCompl (row.get(7));
    real      compnetto (row.get(8));         
    const int numvers (row.get_int(9));
//    const int numpag  (row.get_int(8));
    
    r.put("DATAPAG",    datapag);  
    r.put("COMPENSO",   compenso);  
    r.put("IMPONIBILE", imponibile); 
    r.put("PERC",       aliquota); 
    r.put("RITENUTA",   ritenuta); 
    r.put("SPESA",      spese); 
    r.put("NETTO",      compnetto); 
    r.put("NUMVERS",    (long)numvers);      
    r.put("CTSSNPERC", SsnPerc);
    r.put("CTSSNCOMP", SsnCompl);
//    r.put("NUMPAG",     (long)nriga);         
//    r.put("NUMPAG",     (long)numpag);     
  }

//  ver_pack();                            // Destroy all null rows

  rows = vers().rows_array();
  
  for (i = 0; i < rows.items(); i++)
  {
    TToken_string& row = (TToken_string&)rows[i];
    TRectype &r = _rel->ver(i);
    
    if (my_empty_items(row, TRUE))
      continue;  // non salvare righe vuote
      
    long nriga = i+1;
    
    r.zero();
    r.put("CODDITTA", codditta);
    r.put("TIPOA",    tipoa);
    r.put("CODANAGR", codanagr);
    r.put("NPROG",    nprogr);
    r.put("NRIGA",    nriga);   

// LEGGO SPREADSHEET VERSAMENTI    
    const bool  vers1015 = (row.get_char(0) == 'X');
    TString16   datav    = row.get(1);
    const TDate dataver(datav);

    const char luogo    = row.get_char(2);
    const char tipo     = row.get_char(3);
    
    TString16  serie(row.get(4));
    TString    numero(row.get(5));  
    const long ProgBanca(row.get_long(6));
    real       ritenuta  (row.get(7));
    const int  numvers (row.get_int(8));
   
    r.put("VERS1015",vers1015);  
    r.put("DATAVERS",dataver);  
    r.put("LUOVERS", luogo); 
    r.put("TIPOVERS",tipo);    
    r.put("SERIE",   serie); 
    r.put("NUMERO",  numero); 
    r.put("PROGBANC",ProgBanca);
    r.put("RITENUTA",ritenuta);        
//    r.put("NUMVERS",    (long)nriga);     
//    r.put("NUMVERS",    (long)numvers); 
  }
}

int SchedaPerc (int argc, char* argv[])
{
  TSchedaPercipienti a;
  a.run(argc, argv, "Scheda Percipienti");
  return 0;
}
