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

#include "scperc.h"
#include "rver.h"
#include "rpag.h"
#include "perc.h"
#include "../cg/cgsaldac.h"
#include <partite.h>
#include <scadenze.h>
#include <pagsca.h>
// per dinamica non riprendere #include "../ve/velib.h"

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

// Token_string pilota per relazione tra l'informazione e la 
// sua posizione nello sheet, ogni riga individua uno sheet diverso
const char* PILOT_SHEET[] = {
   "DATAPAG|COMPENSO|SPESA|IMPONIBILE|PERC|RITENUTA|SOMREGCONV|ALQIMP10|CTSSNPERC|CTSSNCOMP|COD10|NETTO|SOMNSRIT|AMMLORDO|QUOTAPROV|IMPNETTO|COMNETTO|NUMVERS|NUMREG",
   "DATAPAG|COMPENSO|IMPCPA|IMPONIBILE|PERC|RITENUTA|SPESA|SOMREGCONV|NETTO|SOMNSRIT|AMMLORDO|QUOTAPROV|IMPNETTO|COMNETTO|NUMVERS|NUMREG",
                            }; 

// Items per causale quadro SC
const char* ITEMS_SC[] = {
  "A|A", "B|B", "C|C", "D|D", "E|E", "F|F", "G|G", "H|H", "I|I", 
  "K|K", "L|L", "M|M", "N|N", "P|P", "Q|Q", "R|R", "S|S", "T|T", NULL };
  
// Items per causale quadro SE
const char* ITEMS_SE[] = {
  "A|A", "B|B", "C|C", "D|D", "E|E", "F|F", "G|G", "T|T", NULL };
  
// Items per causale quadro SF
const char* ITEMS_SF[] = {
  "A|A", "B|B", "C|C", "D|D", "E|E", "F|F", "G|G", "H|H", "I|I", 
  "L|L", "M|M", "N|N", "P|P", "Q|Q", "R|R", "S|S", "T|T", NULL };
  
// Items per causale quadro SG
const char* ITEMS_SG[] = {
  "A|A", "B|B", "C|C", "D|D", "E|E", NULL };
  
// Items per causale quadro LA
const char* ITEMS_LA[] = {
  "A|A", "B|B", "C|C", "D|D", "E|E", "F|F", "G|G", "H|H", "I|I", "L|L", "M|M", 
  "N|N", "P|P", "Q|Q", "R|R", "S|S", "T|T", "U|U", "V|V", "W|W", "Z|Z", NULL };
  

HIDDEN TString80 __tmp;                                              

TSchedaPercipienti::TSchedaPercipienti(): _rel(NULL), _flag_cg(FALSE)
{
  _from_modify = FALSE;  
  _soggnres = 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);    
    m->set_handler(F_AGGPAG,  aggpag_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); 
      m->set_handler(F_MESECOMP, check_competenza);
      
////////////////////////////////////////////////////////////////////////
// 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);
    }
    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;
  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
  if (!app().esiste_perc(m, codanagr))
    return true;
    
  // istanza e inizializza chiave file schede 
  TLocalisamfile scperc(LF_SCPERC);    

	bool trovato = false;
	const long numreg = app().coll_numreg();
	if (numreg > 0L)
	{
		scperc.setkey(3);
		scperc.put(SPR_CODDITTA, prefix().get_codditta());
		scperc.put(SPR_NUMREG, numreg);

		if (scperc.read(_isgteq) == NOERR && scperc.get_long(SPR_NUMREG) == numreg)
		{
			nprog = scperc.get_int(SPR_NPROG);
			trovato = true;
		}
		scperc.setkey(1);
	}
	if (!trovato)
	{
		scperc.zero();
		scperc.put("CODDITTA", codditta);  
		scperc.put("TIPOA", tipoa);
		scperc.put("CODANAGR", codanagr);
	  
		// istanza record di confronto
		TRectype rec(scperc.curr());

		// cerca ultimo progressivo usato 
		// e per tipo collegamento variazione
		// individuo eventuale scheda coincidente 
		for (scperc.read(_isgteq); scperc.good() && scperc.curr() == rec && !trovato; scperc.next())
		{
			nprog = scperc.get_long("NPROG");   
			if (variazione)
			{                                   
				TString16 numdoc,datadoc;
				numdoc = scperc.get("NUMDOC");    
				numdoc.trim();                     
				datadoc = scperc.get("DATADOC");            
				trovato = ((numdoc == app()._coll._numdoc) && (datadoc == app()._coll._datadoc));
			}      
		}
	}
	if (!trovato)
		nprog = nprog++;
  m.set(F_NPROG, nprog);

  return trovato;
}

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)
  {
    TMask& m = f.mask();
    const bool variazione = app().coll_variazione();
    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);
    }  
    // faccio a mano decodifica del percipiente 
    // perchè l'automatismo non funziona
    long tmp_codanagr = atol(codanagr);
    TString16 tmp_tipoa = f.mask().get(F_TIPOA);
    TString80 tmp_ragsoc = app().get_ragsoc(tmp_tipoa, tmp_codanagr);
    f.mask().set(F_RAGSOCPER, tmp_ragsoc);
    f.mask().set(F_RAGSOCCOM, tmp_ragsoc);
  }

  return TRUE;
}

void TSchedaPercipienti::calcola_riga_pag(TRectype & rec,
                                                 const real h_PercAssImp,
                                                 const real h_PercCassaPrev,
                                                 const real h_PercRitenuta,
                                                 const real h_PercInps,
                                                 const real h_PercAssImpInps,
                                                 const real h_PercCommitInps)
{
  const int fdec = TCurrency::get_firm_dec();
	real compenso = rec.get_real(PAG_COMPENSO);
  real impcpa = (compenso * h_PercCassaPrev) / (CENTO + h_PercCassaPrev); impcpa.round(fdec);   // calcolo CPA
	rec.put(PAG_IMPCPA, impcpa);
  real imponibile = ((compenso - impcpa) * h_PercAssImp) / CENTO; imponibile.round(fdec);	// calcolo imponibile
	rec.put(PAG_IMPONIBILE, imponibile);
  real ritlorda = (imponibile * h_PercRitenuta) / CENTO;  ritlorda.round(fdec);   // calcolo ritenuta lorda
	rec.put(PAG_RITLORDA, ritlorda);
	const real detfamil = rec.get_real(PAG_DETFAMIL);  
	const real detlavdip = rec.get_real(PAG_DETLAVDIP);  
	const real totdet = detfamil + detlavdip;  
	const real ritenuta = totdet > ritlorda ? ZERO : ritlorda - totdet;
	rec.put(PAG_RITENUTA, ritenuta);
  real ctssncomp = (((compenso * h_PercAssImpInps) / CENTO) * h_PercInps) / CENTO;  ctssncomp.round(fdec);  // calcolo contributo Inps complessivo
	rec.put(PAG_INPSCOMP, ctssncomp);
	real ctssnperc = (h_PercCommitInps == ZERO) ? ctssncomp - ((ctssncomp * 2) / 3) : ctssncomp - ((ctssncomp * h_PercCommitInps) / CENTO);  ctssnperc.round(fdec); // calcolo contributo Inps del percipiente
	rec.put(PAG_INPSPERC, ctssnperc);
	real utpagati = rec.get_real(PAG_UTPAGATI);  
	if (abs(utpagati) > abs(imponibile))
    utpagati = imponibile;                          
	real ritutpag = rec.get_real(PAG_RITUTPAG);  
	if (abs(ritutpag) > abs(ritenuta))
    ritutpag = ritenuta;                          
	rec.put(PAG_UTSPETT, imponibile - utpagati); // ? da verificare  calcolo utili spettanti
  rec.put(PAG_RITUTPAG, ritenuta - ritutpag); // ? da verificare calcolo ritenute utili spettanti
	const real spesa = rec.get(PAG_SPESA);
  const real netto = compenso + spesa - ritenuta - ctssnperc;        // calcolo compenso netto
	rec.put(PAG_NETTO, netto);
	const real somregconv = rec.get_real(PAG_SOMREGCONV);  
	const real somnsrit = compenso - imponibile + spesa - impcpa - somregconv ;   // calcolo somme non soggette a ritenuta
	rec.put(PAG_SOMNSRIT, somnsrit);
	real controbb = rec.get_real(PAG_SOMREGCONV);  
  const real ammlordo = imponibile + somnsrit + controbb + somregconv;   // calcolo ammontare lordo
	rec.put(PAG_AMMLORDO, ammlordo);
  const real quotaprov = somnsrit - spesa;   // calcolo quota provvigioni
	rec.put(PAG_QUOTAPROV, quotaprov);
  const real impnetto = imponibile - ritenuta; // calcolo imponibile al netto delle ritenute
	rec.put(PAG_IMPNETTO, impnetto);
  const real comnetto = compenso - ritenuta;    // calcolo compenso al netto delle ritenute
	rec.put(PAG_COMNETTO, comnetto);
}

void TSchedaPercipienti::agg_pagamenti(const TRectype & sch)
{
	const long numreg = sch.get_long(SCH_NUMREG);

	if (numreg > 0)
	{
		TPartite_array partarr;

		partarr.add_numreg(numreg);
		if (partarr.items() > 0)
		{
			TSchedaPE sc;
			bool pag_udated = false;

			sc.lfile().curr() = sch;
			sc.read(_isequal, _lock);
			const real totrit = sc.lfile().get_real(SCH_TOTRIT);
			const real totale = sc.lfile().get_real(SCH_TOTALE) - totrit;
			const real spese = sc.lfile().get_real(SCH_SPESE);
			const real iva = sc.lfile().get_real(SCH_IVA);
			const real compenso = sc.lfile().get_real(SCH_COMPENSO);
			real spperc = spese / totale; spperc.round(8);
			real ivaperc = iva / totale; ivaperc.round(8);

			TString16 codcau(sc.lfile().get("CODCAUS"));
			const TRectype cau = cache().get("%CA7", codcau);

			// leggo valori tabella causali per calcolo
			const real h_PercAssImp = cau.get_real("R4");
			const real h_PercCassaPrev = cau.get_real("R5"); 
			const real h_PercRitenuta = cau.get_real("R0");     
			const real h_PercInps = cau.get_real("R1"); 
			const real h_PercAssImpInps = cau.get_real("R2");
			const real h_PercCommitInps = cau.get_real("R3");

			
			for (TPartita * p = partarr.first(); p != NULL; p =partarr.next())
			{
				const int row = p->prima_fattura(numreg);

				if (row >= 0)
				{
					TRiga_partite & rigapart = p->riga(row);
					int nrate = rigapart.rate();
					TDate datapag;

					for (int r = 1; r <= nrate; r++)
					{
						TRiga_scadenze & ratapart = rigapart.rata(r);
						TImporto tot[10];
						long numregp[10] = {0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L};
						int lastsch = 0;

						const int rows = sc.pag_items();

						for (int rowp = ratapart.last(); rowp > 0; rowp = ratapart.pred(rowp))
						{
							const TRectype& pag = ratapart.row(rowp);                         // Riga pagamento
							const TRiga_partite& sum = p->riga(rowp);              // Riga partite
							const char sez = sum.sezione();
							TImporto imppag(sez, pag.get_real(PAGSCA_IMPORTO));
							const long num = sum.get_long(PART_NREG);
							if(lastsch == 0 && numregp[0] == 0L)
							{
								numregp[lastsch] = num;
								tot[lastsch].reset();
							}
							if(num != numregp[lastsch])
							{
								numregp[++lastsch] = num;
								tot[lastsch].reset();
							}
							if (lastsch > 9)
							{
								message_box("Attenzione! Troppi pagamenti diversi per la registrazione %ld.", numreg);
								break;
							}
				
							bool found = false;
							imppag += TImporto(sez, pag.get_real(PAGSCA_RITENUTE));
							imppag += TImporto(sum.sezione_ritsoc(), pag.get_real(PAGSCA_RITSOC));
							real abbuoni = pag.get_real(PAGSCA_ABBUONI);
							real abb = pag.get_real(PAGSCA_ABBUONI);
							if (!abb.is_zero())
								imppag += TImporto(sez, abb);
							for (int i = 0; !found &&i < rows; i++)
							{
								TRectype & pagrec = sc.pag(i);
								const long numsch = pagrec.get_long(PAG_NUMREG);
								found = num == numsch;
								if (numsch == 0L && !found)
								{
									TDate data(sum.get_date(PART_DATADOC));
									if (!data.ok())
										data = sum.get_date(PART_DATAREG);
									if (!data.ok())
										data = sum.get_date(PART_DATAPAG);
									const TDate datasch(pagrec.get(PAG_DATAPAG));
									if (data == datasch)
									{
										pagrec.put(PAG_NUMREG, num);
										found = true;
									}
									else
									{
										imppag.normalize('D');

										real spesep = imppag.valore() * spperc;
										real ivap = imppag.valore() * ivaperc;
							
										spesep.round(TCurrency::get_firm_dec());
										if (abs(spesep) > abs(spese))
											spesep = spese;
										ivap.round(TCurrency::get_firm_dec());
										if (abs(ivap) > abs(iva))
											ivap = iva;

										real compensop = imppag.valore() - spesep - ivap;

										compensop += compensop * h_PercRitenuta;
										compensop.round(TCurrency::get_firm_dec());
										if (abs(compensop) > abs(compenso))
											compensop = compenso;
										if (compensop == pagrec.get_real(PAG_COMPENSO))
										{
											pagrec.put(PAG_NUMREG, num);
											found = true;
										}
									}
								}
							}
							if (!found)
							{
								tot[lastsch] += imppag;
							if (!datapag.ok())
								datapag = sum.get_date(PART_DATADOC);
							if (!datapag.ok())
								datapag = sum.get_date(PART_DATAREG);
							if (!datapag.ok())
								datapag = sum.get_date(PART_DATAPAG);
						}
						}
						for (int j = 0; j < 10 && numregp[j] > 0L; j++)
						{
							tot[j].normalize('D');
							if (tot[j].valore() == ZERO)
								break;

							TRectype & pagrec = sc.pag(rows);

							pagrec.put(PAG_CODDITTA, sc.lfile().get(SCH_CODDITTA));
							pagrec.put(PAG_TIPOA, sc.lfile().get(SCH_TIPOA));
							pagrec.put(PAG_CODANAGR, sc.lfile().get(SCH_CODANAGR));
							pagrec.put(PAG_NPROG, sc.lfile().get(SCH_NPROG));
							pagrec.put(PAG_NRIGA, rows + 1);
							pagrec.put(PAG_NUMVERS, -1);
							real spesepag = tot[j].valore() * spperc;
							real ivapag = tot[j].valore() * ivaperc;
						
						spesepag.round(TCurrency::get_firm_dec());
						if (abs(spesepag) > abs(spese))
							spesepag = spese;
						ivapag.round(TCurrency::get_firm_dec());
						if (abs(ivapag) > abs(iva))
							ivapag = iva;

							real compensopag = tot[j].valore() - spesepag - ivapag;

						compensopag += compensopag * h_PercRitenuta;
						compensopag.round(TCurrency::get_firm_dec());
						if (abs(compensopag) > abs(compenso))
							compensopag = compenso;
						pagrec.put(PAG_COMPENSO, compensopag);
						pagrec.put(PAG_SPESA, spesepag);
						pagrec.put(PAG_DATAPAG, datapag);
							sc.lfile().put(SCH_ANNOC, datapag.year());
							sc.lfile().put(SCH_MESEC, datapag.month());
						pagrec.put(PAG_PERC, h_PercRitenuta); // percentuale ritenuta acconto
						pagrec.put(PAG_ALQIMP10, h_PercAssImpInps);// percentuale 10% INPS
							pagrec.put(PAG_NUMREG, numregp[j]);
						pagrec.put(PAG_COD10, "C");
						calcola_riga_pag(pagrec, h_PercAssImp, h_PercCassaPrev, h_PercRitenuta, h_PercInps, h_PercAssImpInps, h_PercCommitInps);
					}
				}
			}
			}
			sc.rewrite();
		}
	}
}

bool schede(const TRelation& rel, void* pJolly)
{
	const TRectype & sch = rel.lfile().curr();
	TSchedaPercipienti * schper = (TSchedaPercipienti *) pJolly;

	schper->agg_pagamenti(sch);
	return true;
}

bool TSchedaPercipienti::aggpag_handler(TMask_field& f, KEY k)
{
  if (k == K_SPACE)
  {
		TLocalisamfile fsch(LF_SCPERC);
		TRectype from(fsch.curr());
		TLocalisamfile mov(LF_MOV);

		from.put("CODDITTA", prefix().get_codditta());

		TRectype to(from);
		TCursor c(new TRelation(LF_SCPERC), "", 1, &from, &to);

		c.scan(schede, &app(), "Aggiornamento schede");

	}
	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;   
  
  // memorizzo flag soggetto non residente nel dato membro usato 
  // nei controlli
  if (esiste_anagr)
    _soggnres = anag.get_bool("SOGGNRES");    

  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;
    }
  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|Ritenuta@16|",
         0,NULL_WIN,5);

  set_search_field(F_CODANAGRPERC);

//  simulo una chiamata da contabilità
//  (lo lascio per eventuali prove)
//  real totdocla = 1000000;
//  real spesela = ZERO;
//  real compensola = 1000000;
//  real impostela = ZERO;
//  real ritenutela = ZERO;
//  TToken_string s(80);
//  s.add(pagamento);
//  s.add("M");
//  s.add("F");
//  s.add(30010);
//  s.add(1);
//  s.add("1");
//  s.add("01-01-1996");
//  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()) )
    {
      NFCHECK("Errore nei parametri passati");
      return FALSE;
    }

    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)) 
        {
          NFCHECK("Creazione dichiarazione fallita!");
          return FALSE;
        }
  }
    
  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());
  m.set(F_NUMREG,  _coll._numreg);

  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; 
}

TString80 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();
  return anag.get("RAGSOC");
}

void TSchedaPercipienti::init_modify_mode(TMask& m)
{
  _from_modify = TRUE;
  _codanagr    = m.get_long(F_CODANAGR);
  _tipoa       = m.get(F_TIPOA);
  _ragsoc = get_ragsoc(_tipoa, _codanagr); 
  
  // inizilizza maschera
  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);
      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())
        {
          if (setta_nprog(m, variazione))
            m.send_key(K_AUTO_ENTER,0);
        }  
        return;
        break;     
      case occasionale:
        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)
  {
    // istanza struttura pagamento
    Pag_struct s;
    
    // compilo campi struttura
    s.datapag = rec.get_date("DATAPAG");      
    s.imponibile = rec.get_real("IMPONIBILE");
    s.perc = rec.get_real("PERC");  
    s.ritenuta = rec.get_real("RITENUTA"); 
    s.compenso = rec.get_real("COMPENSO");  
    s.netto = rec.get_real("NETTO"); 
    s.numvers = rec.get_long("NUMVERS");    
    s.spesa = rec.get_real("SPESA");
    s.ctssnperc = rec.get_real("CTSSNPERC");
    s.ctssncomp = rec.get_real("CTSSNCOMP"); 
    s.ritlorda = rec.get_real("RITLORDA");
    s.controbb = rec.get_real("CONTROBB");
    s.detfamil = rec.get_real("DETFAMIL"); 
    s.detlavdip = rec.get_real("DETLAVDIP");
    s.totdet = rec.get_real("TOTDET");
    s.giolavdip = rec.get_int("GIOLAVDIP"); 
    s.impcpa = rec.get_real("IMPCPA"); 
    s.somregconv = rec.get_real("SOMREGCONV");
    s.alqimp10 = rec.get_real("ALQIMP10"); 
    s.cod10 = rec.get("COD10");
    s.utpagati = rec.get_real("UTPAGATI");
    s.utspett = rec.get_real("UTSPETT");
    s.ritutpag = rec.get_real("RITUTPAG");
    s.ritutspe = rec.get_real("RITUTSPE"); 
    s.nquote = rec.get_real("NQUOTE"); 
    s.somnsrit = rec.get_real("SOMNSRIT");
    s.ammlordo = rec.get_real("AMMLORDO");
    s.quotaprov = rec.get_real("QUOTAPROV");
    s.impnetto = rec.get_real("IMPNETTO");
    s.comnetto = rec.get_real("COMNETTO");  
    s.numreg = rec.get_long(PAG_NUMREG);  
    
    // compilo riga di sheet 
    from_struct_to_sheet(s, r);
  }
}

int TSchedaPercipienti::read(TMask& m)
{
  m.autoload(*_rel);
  
  // reperische sheet attivo forzando l'abilitazione in base al quadro
  // ciò è necessario per attivare lo sheet corretto quando
  // si esce/entra dalle singole schede
  TSheet_field& pags = pag_sheet_enabled(m,TRUE);
  
  pags.destroy();
  int r;
  for (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();
  // calcolo numero di colonne utili (scartando l'ultima)    
  int num_col = ver.row(r).items() - 1;
  // abilito/disabilito celle 
  for (int i=1; i<num_col; 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, COLONNE_SIGNIFICATIVE_SPREADSHEET_VERSAMENTI);
  else    
    riga.add(-1, num_sheet_column() - 1);  
}
          
//
//  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) 
{ 
  // leggo codice quadro
  TString16 qua(m.get(F_CODQUA));        
  
  TSheet_field& pags = pag_sheet_enabled(m);
  int r;
  for (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());
  return err;
}

int  TSchedaPercipienti::write(const TMask& m)
{
  mask2rel(m);
  const int err = _rel->write();
  scrivi_dati_per(_rel->curr());
  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;
}        

bool TSchedaPercipienti::check_competenza(TMask_field& f, KEY k)           
{
  if (k == K_ENTER)
  {
    const bool forzatura = f.mask().get_bool(F_FORCED);  
    int anno_competenza(f.mask().get_int(F_ANNOCOMP)); 
    int mese_competenza(f.mask().get_int(F_MESECOMP)); 

    if (anno_competenza && !mese_competenza)
    {
      f.warning_box ("Indicare anche il mese di competenza");
      return forzatura;
    }     
    
    if (!anno_competenza && mese_competenza)
    {
      f.warning_box ("Indicare anche l'anno competenza");
      return forzatura;
    }
  }
  return TRUE;
}

//           
// Calcola:
//
// totale compensi
// 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)
  {      
    TMask& m = f.mask();
    
    const bool forzatura = m.get_bool(F_FORCED);    
    int     i;
    TArray& rpag = app().pags().rows_array();

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

      int pos;
      if ((pos = app().token_pos("COMPENSO")) != -1)
        compenso = row.get(pos);                 
      if ((pos = app().token_pos("SPESA")) != -1) 
        spese = row.get(pos);                     
      if ((pos = app().token_pos("RITENUTA")) != -1)    
        ritenuta = row.get(pos);
      
      app()._tot_compenso  += compenso;
      app()._tot_spese     += spese;
      app()._tot_rit       += ritenuta;               
    }
    
    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;
    }

    const int fdec = TCurrency::get_firm_dec();
    app()._tot_rit.round(fdec);
    app()._tot_vers.round(fdec);
    
    // memorizzo i totali ritenute pagate/versate
    m.set(F_RITOPE, app()._tot_rit);  
    m.set(F_RITVER, app()._tot_vers); 
    
    const real diff = abs(app()._tot_vers - app()._tot_rit);
    
    if (app()._tot_vers != ZERO && diff > ZERO)
    {
      const bool in_euro = is_euro_value("");
      const real THRESOLD = in_euro ? 0.50 : 500.0;
      const bool war = in_euro ? (diff >= THRESOLD) : (diff > THRESOLD);
      if (war)
      {
        f.warning_box("La differenza tra il totale dei versamenti " 
                      "ed il totale delle ritenute non puo' superare %s %s", 
                      THRESOLD.string(), in_euro ? "Euro" : "Lire");
        return forzatura;
      }
    }
  }
  return TRUE;
}

// Trasferisce i dati dalla maschera alla relazione
void TSchedaPercipienti::mask2rel(const TMask& m)
{
  // Assicurati che siano calcolate le ritenute
  if (_tot_rit.is_zero() || _tot_vers.is_zero())
  {
    TMask_field& datadoc = m.field(F_DATADOC);
    check_handler(datadoc, K_ENTER);
  }

  _rel->lfile().zero();
  m.autosave(*_rel);
  
  // leggo chiave scheda
  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);  
     
  // leggo valori tabella causali per calcolo
  const real h_PercAssImp = m.get_real(F_QUOTAIMP);
  const real h_PercCassaPrev = m.get_real(F_CASSA_PREV); 
  const real h_PercRitenuta = m.get_real(F_PERRIT);     
  const bool h_FlagInps = m.get_bool(F_FLAG_INPS);
  const real h_PercInps = m.get_real(F_PERC_INPS); 
  const real h_PercAssImpInps = m.get_real(F_PERC_ASS_INPS);
  const real h_PercCommitInps = m.get_real(F_PERC_COMMIT_INPS);
      
  // istanza struttura di comodo per calcolo riga pagamenti
  Pag_struct c; 
  
  _rel->destroy_rows();                  // Destroy all records
  pag_pack();                            // Destroy all null rows

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

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

    // compilo struttura rigo di pagamento
    Pag_struct s;                         
    from_sheet_to_struct(row, s);
    
    // ricalcolo riga pagamento
    // (per ottenere la congruità dei dati semplicemente 
    // registrando la scheda) 
		c.numreg = s.numreg;
    calcola_riga_pag(s,
                     c, 
                     FALSE,  
                     h_PercAssImp,
                     h_PercCassaPrev,
                     h_PercRitenuta,
                     h_PercInps,
                     h_PercAssImpInps,
                     h_PercCommitInps); 
    
    // compilo restanti campi
    r.put("DATAPAG", s.datapag);      
    r.put("IMPONIBILE",s.imponibile);
    r.put("PERC", s.perc);  
    r.put("RITENUTA", s.ritenuta); 
    r.put("COMPENSO", s.compenso);  
    r.put("NETTO",s.netto); 
    r.put("NUMVERS", s.numvers);    
    r.put("SPESA", s.spesa);
    r.put("CTSSNPERC", s.ctssnperc);
    r.put("CTSSNCOMP", s.ctssncomp); 
    r.put("RITLORDA", s.ritlorda);
    r.put("CONTROBB", s.controbb);
    r.put("DETFAMIL", s.detfamil); 
    r.put("DETLAVDIP", s.detlavdip);
    r.put("TOTDET", s.totdet);
    r.put("GIOLAVDIP", s.giolavdip); 
    r.put("IMPCPA", s.impcpa); 
    r.put("SOMREGCONV", s.somregconv);
    r.put("ALQIMP10", s.alqimp10); 
    r.put("COD10", s.cod10);
    r.put("UTPAGATI", s.utpagati);
    r.put("UTSPETT", s.utspett);
    r.put("RITUTPAG", s.ritutpag);
    r.put("RITUTSPE", s.ritutspe); 
    r.put("NQUOTE", s.nquote); 
    r.put("SOMNSRIT", s.somnsrit);
    r.put("AMMLORDO", s.ammlordo);
    r.put("QUOTAPROV", s.quotaprov);
    r.put("IMPNETTO", s.impnetto);
    r.put("COMNETTO", s.comnetto);
		r.put(PAG_NUMREG, s.numreg);
  }

  // salva versamenti
  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);
    
    const TString16 serie(row.get(4));
    const TString16 numero(row.get(5));  
    const long ProgBanca(row.get_long(6));
    const 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);
  }
}

TMask& TSchedaPercipienti::TheMask() const
{
  if (_msk[1] == NULL)
    error_box("Maschera di inserimento/modifica non ancora istanziata!");
  
  return *(_msk[1]);
}             

TSheet_field& TSchedaPercipienti::pag_sheet_enabled(TMask& m, bool force_enable) const
{
  TSheet_field* s = NULL;

  // istanza reference sheet a disposizione
  TSheet_field& s_C = (TSheet_field&)m.field(F_PAGAMENTI_C);
  TSheet_field& s_E = (TSheet_field&)m.field(F_PAGAMENTI_C);
  TSheet_field& s_F = (TSheet_field&)m.field(F_PAGAMENTI_D);
  TSheet_field& s_G = (TSheet_field&)m.field(F_PAGAMENTI_D);
  
  // forza la disabilitazione di tutti se richiesta
  // l'abilitazionein base al quadro
  if (force_enable) 
  {
    s_C.hide(); 
    s_E.hide();
    s_F.hide();  
    s_G.hide(); 
  } 
    
  // valorizzo reference sheet abilitato                    
  if (s_C.shown()) 
    s = &s_C;
  if (s_E.shown())
    s = &s_E;
  if (s_F.shown())
    s = &s_F;     
  if (s_G.shown())
    s = &s_G; 
    
  // se nessuno abilitato forzo l'abilitazione in base al quadro
  // questo si rende necessario per il primo che invoca questo
  // metodo, in quanto gli sheet sono hide alla partenza 
  if (s == NULL)
  {
    // reperisco codice quadro della scheda 
    TString16 codcau(_rel->lfile().get("CODCAUS"));
    TTable cau("%ca7");
    cau.zero();
    cau.put("CODTAB", codcau);
    TString16 qua = "C";
    if (cau.read() == NOERR)
      qua = cau.get("S1");  
      
    // abilito sheet  
    s = &(enable_pag_sheet(m, qua));   
    
    // aggancio handler
    set_pag_handler(*s);
  }  
  
  return *s;  
}             

bool TSchedaPercipienti::activate_pag_sheet(TMask& m)
{
  // reperisco sheet attivo da cui copiare, la Token_string pilota 
  // e il numero di colonne 
  TSheet_field& prev_s = pag_sheet_enabled(m);
  TToken_string prev_pilot(pilot_sheet());    
  int prev_col = num_sheet_column() + 1;  
  
  // leggo codice quadro
  TString16 qua(m.get(F_CODQUA));
  
  // abilito sheet  
  TSheet_field& curr_s = enable_pag_sheet(m, qua);  
    
  // reperisco la Token_string pilota dallo sheet attivo
  TToken_string curr_pilot(pilot_sheet());
  
  // copia dallo sheet disattivato a quello attivato solo se non coincidono,
  // preoccupandosi di spostare le colonne al posto giusto 
  if (prev_s.dlg() != curr_s.dlg())
  {
    curr_s.destroy();
    for (int i=0; i<prev_s.items(); i++) 
    {
      TToken_string curr_row;
      for (int j=0; j<prev_col; j++) 
      { 
        // trovo posizione token nello sheet attivo
        TString prev_token(prev_pilot.get(j));
        int pos = token_pos((const char*)prev_token);
        // copio solo se è presente nello sheet attivo
        if (pos != -1)      
        {
          TString prev_val(prev_s.row(i).get(j));
          curr_row.add(prev_val, pos);
        }
      }    
      curr_s.row(i) = curr_row;
    }
  }

  // ricalcolo tutte le righe pagamento
  const real h_PercAssImp = m.get_real(F_QUOTAIMP);
  const real h_PercCassaPrev = m.get_real(F_CASSA_PREV); 
  const real h_PercRitenuta = m.get_real(F_PERRIT);     
  const bool h_FlagInps = m.get_bool(F_FLAG_INPS);
  const real h_PercInps = m.get_real(F_PERC_INPS); 
  const real h_PercAssImpInps = m.get_real(F_PERC_ASS_INPS);
  const real h_PercCommitInps = m.get_real(F_PERC_COMMIT_INPS);
  // istanza strutture per calcolo
  Pag_struct c;
  Pag_struct s;
  // elaboro le righe di pagamento
  for (int r = 0; r < curr_s.items(); r++)   
  {         
    TToken_string& t = curr_s.row(r);
    if (!my_empty_items(t, FALSE)) 
    {
      from_sheet_to_struct(t, s);
      calcola_riga_pag(s,
                       c, 
                       TRUE,  
                       h_PercAssImp,
                       h_PercCassaPrev,
                       h_PercRitenuta,
                       h_PercInps,
                       h_PercAssImpInps,
                       h_PercCommitInps);     
      from_struct_to_sheet(s, t);  
    } 
  }   
  
  // aggancio handler pagamenti
  set_pag_handler(curr_s);     
  
  // forzo ridisegno dello sheet a video
  curr_s.force_update();          
  
  return TRUE;  
}                                                    

int TSchedaPercipienti::num_sheet_column() const
{
  // reperisco la Token_string pilota
  TToken_string columns(pilot_sheet());
    
  // ritorno il numero di colonne ignorando l'ultima
  // che è ad uso interno 
  return columns.items()-1; 
}                                               

int TSchedaPercipienti::token_pos(const char* t) const
{
  // reperisco la Token_string pilota
  TToken_string columns(pilot_sheet());  
  
  // ritorno la posizione del token richiesto
  return columns.get_pos(t);  
}                                                     

int TSchedaPercipienti::token_dlg(const char* t) const
{
  // reperisco la Token_string pilota
  TToken_string columns(pilot_sheet());  
  
  // ritorno l'identificatore del token richiesto
  int dlg = columns.get_pos(t);
  if (dlg != -1)
    dlg += 101;
  return dlg; 
}                                                     

const char* TSchedaPercipienti::pilot_sheet() const
{
  // reperisco sheet attivo
  TSheet_field& s = pag_sheet_enabled(TheMask());                                           
  
  // individuo la testata giusta
  char* columns;  
  int dlg = s.dlg();
  switch(dlg)
  {
    case F_PAGAMENTI_C  : columns = (char*)PILOT_SHEET[0]; break; 
    case F_PAGAMENTI_D  : columns = (char*)PILOT_SHEET[1]; break;
// esistevano nel vecchio caso    
//    case F_PAGAMENTI_DB : columns = (char*)PILOT_SHEET[2]; break;
//    case F_PAGAMENTI_G  : columns = (char*)PILOT_SHEET[3]; break;
    default : break;
  }
    
  // ritorno la Token_string pilota
  return columns; 
}                                                  

Pag_struct& TSchedaPercipienti::from_sheet_to_struct(TToken_string& t, Pag_struct& s)
{
  // reperisco la Token_string pilota
  TToken_string columns(pilot_sheet());
  
  // azzero struttura 
  clear_struct(s);
  
  // posizione dell'informazione all'interno della Token_string
  int pos;
  
  // set data pagamento
  if ((pos = token_pos("DATAPAG")) != -1)  
  {
    TString16 datap = t.get(pos);
    s.datapag = datap; 
  }
  
  // set imponibile
  if ((pos = token_pos("IMPONIBILE")) != -1)
    s.imponibile = t.get(pos);
  
  // set percentuale ritenuta
  if ((pos = token_pos("PERC")) != -1)
    s.perc = t.get(pos);   

  // set ritenuta
  if ((pos = token_pos("RITENUTA")) != -1)
    s.ritenuta = t.get(pos);   

  // set compenso
  if ((pos = token_pos("COMPENSO")) != -1)
    s.compenso = t.get(pos);   

  // set compenso netto
  if ((pos = token_pos("NETTO")) != -1)
    s.netto = t.get(pos);  

  // set numero versamento collegato
  if ((pos = token_pos("NUMVERS")) != -1)
    s.numvers = t.get_long(pos);   

  // set spesa
  if ((pos = token_pos("SPESA")) != -1)
    s.spesa = t.get(pos);  

  // set contr.10% percipiente
  if ((pos = token_pos("CTSSNPERC")) != -1)
    s.ctssnperc = t.get(pos);  

  // set contr.10% complessivo
  if ((pos = token_pos("CTSSNCOMP")) != -1)
    s.ctssncomp = t.get(pos);  

  // set ritenuta lorda
  if ((pos = token_pos("RITLORDA")) != -1)
    s.ritlorda = t.get(pos);   

  // set contributi obbligatori
  if ((pos = token_pos("CONTROBB")) != -1)
    s.controbb = t.get(pos);   

  // set detrazioni famigliari
  if ((pos = token_pos("DETFAMIL")) != -1)
    s.detfamil = t.get(pos);   

  // set detrazioni lavoro dipendente
  if ((pos = token_pos("DETLAVDIP")) != -1)
    s.detlavdip = t.get(pos);  

  // set totale detrazioni
  if ((pos = token_pos("TOTDET")) != -1)
    s.totdet = t.get(pos);   

  // set giorni lavoro dipendente
  if ((pos = token_pos("GIOLAVDIP")) != -1)
    s.giolavdip = t.get_int(pos);  

  // set importo CPA
  if ((pos = token_pos("IMPCPA")) != -1)
    s.impcpa = t.get(pos);   

  // set somme regime convenzionale
  if ((pos = token_pos("SOMREGCONV")) != -1)
    s.somregconv = t.get(pos);   

  // set percentuale contributo 10%
  if ((pos = token_pos("ALQIMP10")) != -1)
    s.alqimp10 = t.get(pos);   

  // set codice contributo 10%
  if ((pos = token_pos("COD10")) != -1)
    s.cod10 = t.get(pos);  

  // set utili pagati
  if ((pos = token_pos("UTPAGATI")) != -1)
    s.utpagati = t.get(pos);   

  // set utili spettanti
  if ((pos = token_pos("UTSPETT")) != -1)
    s.utspett = t.get(pos);  

  // set ritenuta utili pagati
  if ((pos = token_pos("RITUTPAG")) != -1)
    s.ritutpag = t.get(pos);   

  // set ritenuta utili spettanti
  if ((pos = token_pos("RITUTSPE")) != -1)
    s.ritutspe = t.get(pos);   

  // set numero quote
  if ((pos = token_pos("NQUOTE")) != -1)
    s.nquote = t.get(pos);   

  // set somme non sogg.ritenuta
  if ((pos = token_pos("SOMNSRIT")) != -1)
    s.somnsrit = t.get(pos);   

  // set ammontare lordo
  if ((pos = token_pos("AMMLORDO")) != -1)
    s.ammlordo = t.get(pos);   

  // set quota provvigioni
  if ((pos = token_pos("QUOTAPROV")) != -1)
    s.quotaprov = t.get(pos);  

  // set imponibile al netto ritenute
  if ((pos = token_pos("IMPNETTO")) != -1)
    s.impnetto = t.get(pos);   

  // set compenso al netto ritenute
  if ((pos = token_pos("COMNETTO")) != -1)
    s.comnetto = t.get(pos);       
    
  // set numero versamento collegato
  if ((pos = token_pos("NUMVERS")) != -1)
    s.numvers = t.get_long(pos);    

	// set numero registrazione
  if ((pos = token_pos(PAG_NUMREG)) != -1)
    s.numreg = t.get_long(pos);    

  return s;
}    

void TSchedaPercipienti::from_struct_to_sheet(Pag_struct& s, TToken_string& t)
{
  // reperisco la Token_string pilota
  TToken_string columns(pilot_sheet());
  
  // posizione dell'informazione all'interno della Token_string
  int pos;
  
  // set data pagamento
  if ((pos = token_pos("DATAPAG")) != -1)
    t.add(s.datapag, pos);
  
  // set imponibile
  if ((pos = token_pos("IMPONIBILE")) != -1)
    t.add(s.imponibile.string(), pos);
  
  // set percentuale ritenuta
  if ((pos = token_pos("PERC")) != -1)
    t.add(s.perc.string(), pos);   

  // set ritenuta
  if ((pos = token_pos("RITENUTA")) != -1)
    t.add(s.ritenuta.string(), pos);   

  // set compenso
  if ((pos = token_pos("COMPENSO")) != -1)
    t.add(s.compenso.string(), pos);   

  // set compenso netto
  if ((pos = token_pos("NETTO")) != -1)
    t.add(s.netto.string(), pos);  

  // set numero versamento collegato
  if ((pos = token_pos("NUMVERS")) != -1)
    t.add(s.numvers, pos);   

  // set spesa
  if ((pos = token_pos("SPESA")) != -1)
    t.add(s.spesa.string(), pos);  

  // set contr.10% percipiente
  if ((pos = token_pos("CTSSNPERC")) != -1)
    t.add(s.ctssnperc.string(), pos);  

  // set contr.10% complessivo
  if ((pos = token_pos("CTSSNCOMP")) != -1)
    t.add(s.ctssncomp.string(), pos);  

  // set ritenuta lorda
  if ((pos = token_pos("RITLORDA")) != -1)
    t.add(s.ritlorda.string(), pos);   

  // set contributi obbligatori
  if ((pos = token_pos("CONTROBB")) != -1)
    t.add(s.controbb.string(), pos);   

  // set detrazioni famigliari
  if ((pos = token_pos("DETFAMIL")) != -1)
    t.add(s.detfamil.string(), pos);   

  // set detrazioni lavoro dipendente
  if ((pos = token_pos("DETLAVDIP")) != -1)
    t.add(s.detlavdip.string(), pos);  

  // set totale detrazioni
  if ((pos = token_pos("TOTDET")) != -1)
    t.add(s.totdet.string(), pos);   

  // set giorni lavoro dipendente
  if ((pos = token_pos("GIOLAVDIP")) != -1)
    t.add(s.giolavdip, pos);   

  // set importo CPA
  if ((pos = token_pos("IMPCPA")) != -1)
    t.add(s.impcpa.string(), pos);   

  // set somme regime convenzionale
  if ((pos = token_pos("SOMREGCONV")) != -1)
    t.add(s.somregconv.string(), pos);   

  // set percentuale contributo 10%
  if ((pos = token_pos("ALQIMP10")) != -1)
    t.add(s.alqimp10.string(), pos);   

  // set codice contributo 10%
  if ((pos = token_pos("COD10")) != -1)
    t.add(s.cod10, pos);   

  // set utili pagati
  if ((pos = token_pos("UTPAGATI")) != -1)
    t.add(s.utpagati.string(), pos);   

  // set utili spettanti
  if ((pos = token_pos("UTSPETT")) != -1)
    t.add(s.utspett.string(), pos);  

  // set ritenuta utili pagati
  if ((pos = token_pos("RITUTPAG")) != -1)
    t.add(s.ritutpag.string(), pos);   

  // set ritenuta utili spettanti
  if ((pos = token_pos("RITUTSPE")) != -1)
    t.add(s.ritutspe.string(), pos);   

  // set numero quote
  if ((pos = token_pos("NQUOTE")) != -1)
    t.add(s.nquote.string(), pos);   

  // set somme non sogg.ritenuta
  if ((pos = token_pos("SOMNSRIT")) != -1)
    t.add(s.somnsrit.string(), pos);   

  // set ammontare lordo
  if ((pos = token_pos("AMMLORDO")) != -1)
    t.add(s.ammlordo.string(), pos);   

  // set quota provvigioni
  if ((pos = token_pos("QUOTAPROV")) != -1)
    t.add(s.quotaprov.string(), pos);  

  // set imponibile al netto ritenute
  if ((pos = token_pos("IMPNETTO")) != -1)
    t.add(s.impnetto.string(), pos);   

  // set compenso al netto ritenute
  if ((pos = token_pos("COMNETTO")) != -1)
    t.add(s.comnetto.string(), pos);
    
  // set numero versamento collegato      
  if ((pos = token_pos("NUMVERS")) != -1)
    t.add(s.numvers, pos);

	// set numero registrazione
  if ((pos = token_pos(PAG_NUMREG)) != -1)
    t.add(s.numreg, pos);    
} 

Pag_struct& TSchedaPercipienti::from_mask_to_struct(TMask& m, Pag_struct& s)
{
  // reperisco la Token_string pilota
  TToken_string columns(pilot_sheet());
  
  // azzero struttura 
  clear_struct(s);
  
  // identificatore del token all'interno della maschera
  int dlg;
  
  // set data pagamento
  if ((dlg = token_dlg("DATAPAG")) != -1)
    s.datapag = m.get_date(dlg);   

  // set imponibile
  if ((dlg = token_dlg("IMPONIBILE")) != -1)
    s.imponibile = m.get_real(dlg);  

  // set percentuale ritenuta
  if ((dlg = token_dlg("PERC")) != -1)
    s.perc = m.get_real(dlg);  

  // set ritenuta
  if ((dlg = token_dlg("RITENUTA")) != -1)
    s.ritenuta = m.get_real(dlg);  

  // set compenso
  if ((dlg = token_dlg("COMPENSO")) != -1)
    s.compenso = m.get_real(dlg);  

  // set compenso netto
  if ((dlg = token_dlg("NETTO")) != -1)
    s.netto = m.get_real(dlg);

  // set spesa
  if ((dlg = token_dlg("SPESA")) != -1)
    s.spesa = m.get_real(dlg);   

  // set contr.10% percipiente
  if ((dlg = token_dlg("CTSSNPERC")) != -1)
    s.ctssnperc = m.get_real(dlg);   

  // set contr.10% complessivo
  if ((dlg = token_dlg("CTSSNCOMP")) != -1)
    s.ctssncomp = m.get_real(dlg);   

  // set ritenuta lorda
  if ((dlg = token_dlg("RITLORDA")) != -1)
    s.ritlorda = m.get_real(dlg);  

  // set contributi obbligatori
  if ((dlg = token_dlg("CONTROBB")) != -1)
    s.controbb = m.get_real(dlg);  

  // set detrazioni famigliari
  if ((dlg = token_dlg("DETFAMIL")) != -1)
    s.detfamil = m.get_real(dlg);  

  // set detrazioni lavoro dipendente
  if ((dlg = token_dlg("DETLAVDIP")) != -1)
    s.detlavdip = m.get_real(dlg);   

  // set totale detrazioni
  if ((dlg = token_dlg("TOTDET")) != -1)
    s.totdet = m.get_real(dlg);  

  // set giorni lavoro dipendente
  if ((dlg = token_dlg("GIOLAVDIP")) != -1)
    s.giolavdip = m.get_int(dlg);  

  // set importo CPA
  if ((dlg = token_dlg("IMPCPA")) != -1)
    s.impcpa = m.get_real(dlg);  

  // set somme regime convenzionale
  if ((dlg = token_dlg("SOMREGCONV")) != -1)
    s.somregconv = m.get_real(dlg);  

  // set percentuale contributo 10%
  if ((dlg = token_dlg("ALQIMP10")) != -1)
    s.alqimp10 = m.get_real(dlg);  

  // set codice contributo 10%
  if ((dlg = token_dlg("COD10")) != -1)
    s.cod10 = m.get(dlg);  

  // set utili pagati
  if ((dlg = token_dlg("UTPAGATI")) != -1)
    s.utpagati = m.get_real(dlg);  

  // set utili spettanti
  if ((dlg = token_dlg("UTSPETT")) != -1)
    s.utspett = m.get_real(dlg);   

  // set ritenuta utili pagati
  if ((dlg = token_dlg("RITUTPAG")) != -1)
    s.ritutpag = m.get_real(dlg);  

  // set ritenuta utili spettanti
  if ((dlg = token_dlg("RITUTSPE")) != -1)
    s.ritutspe = m.get_real(dlg);  

  // set numero quote
  if ((dlg = token_dlg("NQUOTE")) != -1)
    s.nquote = m.get_real(dlg);  
  
  // set somme non sogg.ritenuta
  if ((dlg = token_dlg("SOMNSRIT")) != -1)
    s.somnsrit = m.get_real(dlg);  

  // set ammontare lordo
  if ((dlg = token_dlg("AMMLORDO")) != -1)
    s.ammlordo = m.get_real(dlg);  

  // set quota provvigioni
  if ((dlg = token_dlg("QUOTAPROV")) != -1)
    s.quotaprov = m.get_real(dlg);   

  // set imponibile al netto ritenute
  if ((dlg = token_dlg("IMPNETTO")) != -1)
    s.impnetto = m.get_real(dlg);  

  // set compenso al netto ritenute
  if ((dlg = token_dlg("COMNETTO")) != -1)
    s.comnetto = m.get_real(dlg);         
    
  // set numero versamento collegato      
  if ((dlg = token_dlg("NUMVERS")) != -1)
    s.numvers = m.get_long(dlg);            
  
  return s;
}                                                                           

void TSchedaPercipienti::from_struct_to_mask(Pag_struct& s, TMask& m)
{
  // reperisco la Token_string pilota
  TToken_string columns(pilot_sheet());
  
  // identificatore del token all'interno della maschera
  int dlg;
  
  // set data pagamento
  if ((dlg = token_dlg("DATAPAG")) != -1)
    m.set(dlg, s.datapag);   

  // set imponibile
  if ((dlg = token_dlg("IMPONIBILE")) != -1)
    m.set(dlg, s.imponibile);  

  // set percentuale ritenuta
  if ((dlg = token_dlg("PERC")) != -1)
    m.set(dlg, s.perc);  

  // set ritenuta
  if ((dlg = token_dlg("RITENUTA")) != -1)
    m.set(dlg, s.ritenuta);  

  // set compenso
  if ((dlg = token_dlg("COMPENSO")) != -1)
    m.set(dlg, s.compenso);  

  // set compenso netto
  if ((dlg = token_dlg("NETTO")) != -1)
    m.set(dlg, s.netto);

  // set spesa
  if ((dlg = token_dlg("SPESA")) != -1)
    m.set(dlg, s.spesa);   

  // set contr.10% percipiente
  if ((dlg = token_dlg("CTSSNPERC")) != -1)
    m.set(dlg, s.ctssnperc);   

  // set contr.10% complessivo
  if ((dlg = token_dlg("CTSSNCOMP")) != -1)
    m.set(dlg, s.ctssncomp);   

  // set ritenuta lorda
  if ((dlg = token_dlg("RITLORDA")) != -1)
    m.set(dlg, s.ritlorda);  

  // set contributi obbligatori
  if ((dlg = token_dlg("CONTROBB")) != -1)
    m.set(dlg, s.controbb);  

  // set detrazioni famigliari
  if ((dlg = token_dlg("DETFAMIL")) != -1)
    m.set(dlg, s.detfamil);  

  // set detrazioni lavoro dipendente
  if ((dlg = token_dlg("DETLAVDIP")) != -1)
    m.set(dlg, s.detlavdip);   

  // set totale detrazioni
  if ((dlg = token_dlg("TOTDET")) != -1)
    m.set(dlg, s.totdet);  

  // set giorni lavoro dipendente
  if ((dlg = token_dlg("GIOLAVDIP")) != -1)
    m.set(dlg, s.giolavdip);   

  // set importo CPA
  if ((dlg = token_dlg("IMPCPA")) != -1)
    m.set(dlg, s.impcpa);  

  // set somme regime convenzionale
  if ((dlg = token_dlg("SOMREGCONV")) != -1)
    m.set(dlg, s.somregconv);  

  // set percentuale contributo 10%
  if ((dlg = token_dlg("ALQIMP10")) != -1)
    m.set(dlg, s.alqimp10);  

  // set codice contributo 10%
  if ((dlg = token_dlg("COD10")) != -1)
    m.set(dlg, s.cod10);   

  // set utili pagati
  if ((dlg = token_dlg("UTPAGATI")) != -1)
    m.set(dlg, s.utpagati);  

  // set utili spettanti
  if ((dlg = token_dlg("UTSPETT")) != -1)
    m.set(dlg, s.utspett);   

  // set ritenuta utili pagati
  if ((dlg = token_dlg("RITUTPAG")) != -1)
    m.set(dlg, s.ritutpag);  

  // set ritenuta utili spettanti
  if ((dlg = token_dlg("RITUTSPE")) != -1)
    m.set(dlg, s.ritutspe);  

  // set numero quote
  if ((dlg = token_dlg("NQUOTE")) != -1)
    m.set(dlg, s.nquote);  
  
  // set somme non sogg.ritenuta
  if ((dlg = token_dlg("SOMNSRIT")) != -1)
    m.set(dlg, s.somnsrit);  

  // set ammontare lordo
  if ((dlg = token_dlg("AMMLORDO")) != -1)
    m.set(dlg, s.ammlordo);  

  // set quota provvigioni
  if ((dlg = token_dlg("QUOTAPROV")) != -1)
    m.set(dlg, s.quotaprov);   

  // set imponibile al netto ritenute
  if ((dlg = token_dlg("IMPNETTO")) != -1)
    m.set(dlg, s.impnetto);  

  // set compenso al netto ritenute
  if ((dlg = token_dlg("COMNETTO")) != -1)
    m.set(dlg, s.comnetto);               
    
  // set numero versamento collegato      
  if ((dlg = token_dlg("NUMVERS")) != -1)
    m.set(dlg, s.numvers);                
}                                                                           

Pag_struct& TSchedaPercipienti::clear_struct(Pag_struct& s)
{
  s.datapag = NULLDATE;
  s.imponibile = ZERO;
  s.perc = ZERO;
  s.ritenuta = ZERO;
  s.compenso = ZERO;
  s.netto = ZERO;
  s.numvers = -1L;
  s.spesa = ZERO;
  s.ctssnperc = ZERO;
  s.ctssncomp = ZERO;
  s.ritlorda = ZERO;
  s.controbb = ZERO;  
  s.detfamil = ZERO;
  s.detlavdip = ZERO;
  s.totdet = ZERO;
  s.giolavdip = 0;
  s.impcpa = ZERO;  
  s.somregconv = ZERO;   
  s.alqimp10 = ZERO;   
  s.cod10 = "";
  s.utpagati = ZERO;  
  s.utspett = ZERO;   
  s.ritutpag = ZERO;    
  s.ritutspe = ZERO;    
  s.nquote = ZERO;   
  s.somnsrit = ZERO;
  s.ammlordo = ZERO;  
  s.quotaprov = ZERO;   
  s.impnetto = ZERO;  
  s.comnetto = ZERO;        
  
  return s;
}    

Pag_struct& TSchedaPercipienti::calcola_riga_pag(Pag_struct& s,
                                                 Pag_struct& c,
                                                 bool force,
                                                 const real h_PercAssImp,
                                                 const real h_PercCassaPrev,
                                                 const real h_PercRitenuta,
                                                 const real h_PercInps,
                                                 const real h_PercAssImpInps,
                                                 const real h_PercCommitInps)
{
  const int fdec = TCurrency::get_firm_dec();

  // azzera struttura di valori calcolati
  clear_struct(c);
    
  // calcolo CPA
  c.impcpa = (s.compenso * h_PercCassaPrev) / (100.00 + h_PercCassaPrev);
  c.impcpa.round(fdec);
  if (s.impcpa == ZERO || force)
    s.impcpa = c.impcpa; 
    
  // calcolo imponibile
  c.imponibile = ((s.compenso - s.impcpa) * h_PercAssImp) / 100.00;
  c.imponibile.round(fdec);
  if (s.imponibile == ZERO || force)
    s.imponibile = c.imponibile;                                 
      
  // percentuale ritenuta acconto
  if (s.perc == ZERO || force)
    s.perc = h_PercRitenuta;                                     
      
  // calcolo ritenuta lorda
  c.ritlorda = (s.imponibile * s.perc) / 100.00;
  c.ritlorda.round(fdec);
  s.ritlorda = c.ritlorda; 
    
  // calcolo totale detrazioni
  c.totdet = s.detfamil + s.detlavdip;  
  if (abs(c.totdet) > abs(s.ritlorda))
    c.totdet = s.ritlorda;
  s.totdet = c.totdet;        
    
  // calcolo ritenuta
  c.ritenuta = s.ritlorda - s.totdet;                            
  if (s.ritenuta == ZERO || force)
    s.ritenuta = c.ritenuta;     
      
  // percentuale assoggettamento Inps
  if (s.alqimp10 == ZERO || force)
    s.alqimp10 = h_PercAssImpInps;
      
  // calcolo contributo Inps complessivo
  c.ctssncomp = (((s.compenso * s.alqimp10) / 100.00) * h_PercInps) / 100.00;
  c.ctssncomp.round(fdec);
  if (s.ctssncomp == ZERO || force)
    s.ctssncomp = c.ctssncomp; 
    
  // calcolo contributo Inps del percipiente
  if (h_PercCommitInps == ZERO)
    c.ctssnperc = s.ctssncomp - ((s.ctssncomp * 2) / 3); 
  else
    c.ctssnperc = s.ctssncomp - ((s.ctssncomp * h_PercCommitInps) / 100.00);              
  c.ctssnperc.round(fdec);
  if (s.ctssnperc == ZERO || force)
    s.ctssnperc = c.ctssnperc; 
      
  // calcolo utili pagati
  if (abs(s.utpagati) > abs(s.imponibile))
    s.utpagati = s.imponibile;                          
      
  // calcolo ritenute utili pagati
  c.ritutpag = (s.utpagati * s.perc) / 100.00;
  c.ritutpag.round(fdec);
  if (s.ritutpag == ZERO || force)
    s.ritutpag = c.ritutpag;    
  if (abs(s.ritutpag) > abs(s.ritenuta))
    s.ritutpag = s.ritenuta;    
      
  // calcolo utili spettanti
  s.utspett = s.imponibile - s.utpagati;  
    
  // calcolo ritenute utili spettanti
  s.ritutspe = s.ritenuta - s.ritutpag; 
    
  // calcolo compenso netto
  s.netto = s.compenso + s.spesa - s.ritenuta - s.ctssnperc;      
    
  // calcolo somme non soggette a ritenuta
  s.somnsrit = s.compenso - s.imponibile + s.spesa - s.impcpa - s.somregconv; 
    
  // calcolo ammontare lordo
  s.ammlordo = s.imponibile + s.somnsrit + s.controbb + s.somregconv;
    
  // calcolo quota provvigioni
  s.quotaprov = s.somnsrit - s.spesa;
    
  // calcolo imponibile al netto delle ritenute
  s.impnetto = s.imponibile - s.ritenuta;      
    
  // calcolo compenso al netto delle ritenute
  s.comnetto = s.compenso - s.ritenuta;    

	s.numreg = c.numreg;
  
  return s;
}

TSheet_field& TSchedaPercipienti::enable_pag_sheet(TMask& m, const TString& quadro) const
{
  TSheet_field* s = NULL;

  TSheet_field& s_C = (TSheet_field&)m.field(F_PAGAMENTI_C);
  if (quadro == "SC" || quadro == "SE") 
  {
    s_C.show();
    s = &s_C;
  }  
  else s_C.hide();   
  
  TSheet_field& s_F = (TSheet_field&)m.field(F_PAGAMENTI_D);
  if (quadro == "SF" || quadro == "SG")
  {
    s_F.show();
    s = &s_F;
  }  
  else s_F.hide();
  
  // abilito sheet di default nel caso il quadro non fosse uno dei previsti
  if (s == NULL)
  {
    s_C.show();
    s = &s_C;
  }   
  
  return *s;
}            

void TSchedaPercipienti::set_pag_handler(TSheet_field& s) const
{
  // aggancio handler notify dei pagamenti
  s.set_notify(pags_notify);
                                                                       
  // aggancio handler data pagamento
  int dlg = token_dlg("DATAPAG");
  if (dlg != -1) s.sheet_mask().set_handler(dlg, pag_standard_handler);                                                                     
  // aggancio handler imponibile
  dlg = token_dlg("IMPONIBILE");
  if (dlg != -1) s.sheet_mask().set_handler(dlg, pag_standard_handler);
  // aggancio handler percentuale ritenuta
  dlg = token_dlg("PERC");
  if (dlg != -1) s.sheet_mask().set_handler(dlg, pag_standard_handler);  
  // aggancio handler ritenuta
  dlg = token_dlg("RITENUTA");  
  if (dlg != -1) s.sheet_mask().set_handler(dlg, pag_standard_handler);
  // aggancio handler compensi
  dlg = token_dlg("COMPENSO");
  if (dlg != -1) s.sheet_mask().set_handler(dlg, pag_standard_handler);
  // aggancio handler spesa
  dlg = token_dlg("SPESA");
  if (dlg != -1) s.sheet_mask().set_handler(dlg, pag_standard_handler); 
  // aggancio handler contributo Inps percipiente
  dlg = token_dlg("CTSSNPERC");
  if (dlg != -1) s.sheet_mask().set_handler(dlg, pag_standard_handler); 
  // aggancio handler contributo Inps complessivo
  dlg = token_dlg("CTSSNCOMP");
  if (dlg != -1) s.sheet_mask().set_handler(dlg, pag_standard_handler);
  // aggancio handler contributi obbligatori
  dlg = token_dlg("CONTROBB");
  if (dlg != -1) s.sheet_mask().set_handler(dlg, pag_standard_handler);
  // aggancio handler detrazioni familiari a carico
  dlg = token_dlg("DETFAMIL");
  if (dlg != -1) s.sheet_mask().set_handler(dlg, pag_standard_handler);
  // aggancio handler contributo Inps complessivo
  dlg = token_dlg("DETLAVDIP");
  if (dlg != -1) s.sheet_mask().set_handler(dlg, pag_standard_handler);
  // aggancio handler CPA
  dlg = token_dlg("IMPCPA");
  if (dlg != -1) s.sheet_mask().set_handler(dlg, pag_standard_handler);
  // aggancio handler contributo Inps complessivo
  dlg = token_dlg("SOMREGCONV");
  if (dlg != -1) s.sheet_mask().set_handler(dlg, pag_standard_handler);
  // aggancio handler percentuale assogg.imponibile Inps
  dlg = token_dlg("ALQIMP10");
  if (dlg != -1) s.sheet_mask().set_handler(dlg, pag_standard_handler);
  // aggancio handler utili pagati
  dlg = token_dlg("UTPAGATI");
  if (dlg != -1) s.sheet_mask().set_handler(dlg, pag_standard_handler);
  // aggancio handler ritenute utili pagati
  dlg = token_dlg("RITUTPAG");
  if (dlg != -1) s.sheet_mask().set_handler(dlg, pag_standard_handler); 
  // aggancio handler numero quote
  dlg = token_dlg("NQUOTE");
  if (dlg != -1) s.sheet_mask().set_handler(dlg, pag_standard_handler);
  
  // aggancio handler button azzera
  s.sheet_mask().set_handler(DLG_AZZERAPAG, pag_azzera);    
}

void TSchedaPercipienti::build_causqua_items(TMask& m, const TString& quadro) const
{ 
  // reference al campo causale quadro
  TEdit_field& f_causqua = m.efield(F_CAUSQUA);
  // refernce allo sheet del campo causale quadro
  TString_array& Items = f_causqua.sheet()->rows_array();  
  // rimuovo tutti gli items
  Items.destroy();
  // genero i nuovi items
  if (quadro == "SC")
    for (int i=0; ITEMS_SC[i]; i++)
      Items.add(ITEMS_SC[i]);
  if (quadro == "SE")
    for (int i=0; ITEMS_SE[i]; i++)
      Items.add(ITEMS_SE[i]);    
  if (quadro == "SF")
    for (int i=0; ITEMS_SF[i]; i++)
      Items.add(ITEMS_SF[i]);    
  if (quadro == "SG")
    for (int i=0; ITEMS_SG[i]; i++)
      Items.add(ITEMS_SG[i]);   
  if (quadro == "LA")
    for (int i=0; ITEMS_LA[i]; i++)
      Items.add(ITEMS_LA[i]);   
}            

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