#include "770100a.h"
#include "770101.h"
#include "770102.h"
#include <tabutil.h>       
//
// Lista modifiche
//
// 27.5.96	work_tipoluogo() disabilita il campo PROGRBANCA e lo abilita
//			solo se e' un versamento in banca
//
//  5.6.96	Calcolo contributo INPS
// 22.7.96	Esegue controllo ritenuta solo se diversa da ZERO
//					Tolti tutti i trunc() per lasciare i decimali nei conti
// 24.7.96  Non considera piu' la perc. come 100 se lasciata vuota
// 					

HIDDEN TString80 	tmp1, tmp2;
HIDDEN real			__impo  = ZERO;
HIDDEN real			__compe = ZERO;
HIDDEN real			__percra = ZERO;
HIDDEN TString80	__rite;
HIDDEN bool __bRicalcolaRigaPag = FALSE;
HIDDEN real	__rCompensoCg = ZERO;
void CalcolaInps(const real& rPercCassaPrev,const real& rCompenso, const real &rPercContrInps,
                 const real& rPercAssContrInps,const real &rQuotaCommitContrInps, 
                 real& rInpsPerc,real &rInpsComplex);

void TSchedaPercipienti::init_mask(TMask& m)
{
  update_lasts(m);
  __bRicalcolaRigaPag = FALSE;       
  __rCompensoCg = ZERO;
  if (tipo_coll() != nessuno)
  {
    const bool variazione = coll_variazione();
    if (!variazione) compila_testata(m);
    switch (tipo_coll())
    {
      case pagamento:
      case occasionale:
// Compilo riga di pagamento SOLO SE NON ce ne sono gia'..
        if ( (tipo_coll() == pagamento && _rel->pag_items() == 0) 
              ||
              tipo_coll() == occasionale )          
        {
          const real totrit(m.get(F_TOTRIT));
          const real totdoc(m.get(F_TOTDOC));
          const real compenso(m.get(F_COMPENS));
          const real spese(m.get(F_SPESE));
                    
          if  ((tipo_coll() == pagamento && (_coll._compenso + totrit == totdoc) )
               ||
               (tipo_coll() == occasionale))
          {
            TSheet_field& pags = (TSheet_field&)m.field(F_PAGAMENTI);            
            TRectype rpag(_rel->pag(0));
            rpag.zero();
            real& imponibile = _coll._compenso;
            rpag.put("DATAPAG",    _coll._datadoc);
            rpag.put("COMPENSO",   compenso);
            rpag.put("SPESA",      spese);  
// forza il ricalcolo della riga pag. (da check_causale)
            __bRicalcolaRigaPag = TRUE;
            __rCompensoCg = compenso;
// Update spreadsheet
            rec2row(pags.row(0), rpag, 0);
            pags.force_update();
          }
        }
//        break;
      default:               
// per evitare di riscrivere tutto dopo registra      
        _coll._tipo_coll = nessuno;
        break;
    }
  }             
  fill_sheet(m);
}

// Utilizzato in collegamento da cg
real TSchedaPercipienti::calcola_ritenuta(const real& imponibile, TString& sPercRa,
          real&  rPercCassaPrev,real& rPercContrInps,real& rPercAssContrInps,
                real& rQuotaCommitContrInps, bool& bContrInps)
{
  TTable cau("%ca7");
  TString codcau(curr_mask().get(F_CODCAUS));
  cau.zero();
  cau.put("CODTAB", codcau);
  cau.read();
  real rQuotaRaCaus = cau.get_real("R0");  
  sPercRa = cau.get("R0");
  bContrInps=cau.get_bool("B4");
  if (bContrInps)
  {
	  rPercCassaPrev=cau.get_real("R5");
	  rPercContrInps=cau.get_real("R1");
	  rPercAssContrInps=cau.get_real("R2");
	  rQuotaCommitContrInps=cau.get_real("R3");
  }
  else
  {
	  rPercCassaPrev=ZERO;
	  rPercContrInps=ZERO;
	  rPercAssContrInps=ZERO;
	  rQuotaCommitContrInps=ZERO;
  }
  real rite = ZERO;
  rite  =  (imponibile * rQuotaRaCaus)/100.00;
  return rite;
}

// Utilizzato in collegamento da cg  Forse ora da togliere..
real TSchedaPercipienti::calcola_imponibile(const real& compenso)
{                                            
  TTable cau("%ca7");
  TString codcau(curr_mask().get(F_CODCAUS));
  cau.zero();
  cau.put("CODTAB", codcau);
  if (cau.read() != NOERR)
    return ZERO;
  real        quota_imp   = cau.get_int("R4");
  TString16   cod_qua(cau.get("S1"));
  real        imponibile_calcolato = ZERO;
// Calcola imponibile                       
  if (compenso != ZERO) 
    imponibile_calcolato = (compenso * quota_imp) / 100.00;            
  return imponibile_calcolato;
}

bool TSchedaPercipienti::vers_notify(TSheet_field& s, int r, KEY k)
{
  switch(k)
  {                      
     
// Inserimento riga      
    case K_INS:
// Impedisce inserimento di nuove righe
	    return FALSE;     
	            
// Inizio modifica riga	    
    case K_SPACE: 
    {
// Pulisco descrizioni luogo e tipo versamento (solo se non gia' indicati!)
      TSheet_field& vers = app().vers();   
      TMask& mp = vers.sheet_mask();          
      TString16 tipo(mp.get(F_TIPOVERS));
      TString16 luo (mp.get(F_LUOVERS));
      if (tipo.empty())
        mp.reset(70);  
      if (luo.empty())
        mp.reset(71);        
      break;
    } 

    default:
      break;
  }
  return TRUE;
}

bool TSchedaPercipienti::pags_notify(TSheet_field& s, int r, KEY k)
{
  switch(k)
  {                         
       
// Inserimento riga      
    case K_INS:
// Impedisce inserimento di nuove righe
	    return FALSE;     

// Inizio modifica riga	    
    case K_SPACE:
    {
      app()._azzerato_pag = FALSE;
// Se c'e' competenza => diventa obbligatoria DATAPAG
      TSheet_field& pags = app().pags();   
      TMask& m = app().curr_mask();
// Salvo imponibile e compenso precedenti alla modifica.
// v. imponibile_handler e compenso_handler
      TToken_string& row = pags.row(r);
      __compe = row.get(1);
      __impo  = row.get(3);
      __percra = atof(row.get(4));
      __rite   = row.get(7);
      if (__percra == 0.0)
        __percra  = atof(s.mask().get(F_PERRIT));
      const long annoc = m.get_long(F_ANNOCOMP);
      const long mesec = m.get_long(F_MESECOMP);       
#define F_DATAPAG 101      
      TMask& mp = pags.sheet_mask();              
      TEdit_field& fld = mp.efield(F_DATAPAG);
      
      if (annoc != 0L || mesec != 0L)
        fld.check_type(CHECK_REQUIRED);
      else
        fld.check_type(CHECK_NONE);
      break;                        
    }

// Fine modifica di una riga  
    case K_ENTER: 
// Pulisco i buffer di confronto                    
      __impo 	= ZERO;
      __compe	= ZERO;
      __percra	= ZERO;
      __rite = "";
      break;                                  

    default:
      break;
  }
  return TRUE;
}

TSheet_field& TSchedaPercipienti::pags() const
{
  TSheet_field& s = (TSheet_field&)curr_mask().field(F_PAGAMENTI);
  return s;
}

TSheet_field& TSchedaPercipienti::vers() const
{
  TSheet_field& s = (TSheet_field&)curr_mask().field(F_VERSAMENTI);
  return s;
}
              
bool TSchedaPercipienti::my_empty_items(TToken_string& r, bool vers)
{      
  TString rr;     
  
  if (vers)
   for (int i=0; i < COLONNE_SIGNIFICATIVE_SPREADSHEET_VERSAMENTI; i++)
   {
     rr = r.get(i);
     rr.trim();     
     switch (i) {
       case 0: // 1015
        if (rr.not_empty()) 
          return FALSE;
        break;       
       case 1:        
        if (rr.not_empty()) 
          return FALSE;
        break;       
       case 2:   // lugo e tipo vers.
       case 3:
        if (rr.not_empty())
          if (rr != "N") 
            return FALSE;
        break;
       case 4:
       case 5:
        if (rr.not_empty()) 
          return FALSE;      
        break;
       case 6:
         if (rr.not_empty()) {
           real   rrr(real::ita2eng(rr));
           if (rrr != ZERO) 
             return FALSE;
         }
         break;
       default:
         break;
    }
  }        
  else
    for (int i=0; i < COLONNE_SIGNIFICATIVE_SPREADSHEET_PAGAMENTI; i++)
    {
      rr = r.get(i);   
      rr.trim();
      switch (i) {
        case 0: // Data
          if (rr.not_empty()) 
            return FALSE;
          break;       
        case 1:   // Compenso  
          if (rr.not_empty()) {
            real rrr(real::ita2eng(rr)); 
            if (rrr != ZERO) 
              return FALSE;
          }
          break; 
        case 2:   // Spese e Imponibile
        case 3:  
          if (rr.not_empty()) {
            real rrr(real::ita2eng(rr)); 
            if (rrr != ZERO) 
              return FALSE;
          }
          break; 
        case 4:   // r.a. che faccio ?
          break;
        case 5:
        case 6:  
          if (rr.not_empty()) {    
            real rrr(real::ita2eng(rr)); 
            if (rrr != ZERO) 
              return FALSE;
          }
          break; 
        default:
          break;
      }
    }        
  return TRUE;
}

void TSchedaPercipienti::pag_pack()
{
  TString_array& rows = pags().rows_array();

  const int max = rows.items();
  for (int i = 0; i < max; i++)
  {
    TToken_string& r = (TToken_string&)rows[i];
    if (my_empty_items(r, FALSE))             // Remove all empty strings
      rows.destroy(i, FALSE);
  }

  rows.pack();
//  rows.sort(compare_rows);           // Pack and sort array
}
  
void TSchedaPercipienti::ver_pack()
{
  TString_array& rows = vers().rows_array();

  const int max = rows.items();
  for (int i = 0; i < max; i++)
  {
    TToken_string& r = (TToken_string&)rows[i];
    if (my_empty_items(r, TRUE))             // Remove all empty strings
      rows.destroy(i, FALSE);
  }
  rows.pack();
//  rows.sort(compare_rows);           // Pack and sort array
}


//
// LOAD_PAG_SHEET
//
// Inizializza array sheet dei pagamenti
// 
void TSchedaPercipienti::load_pag_sheet(const long numvers)
{
  real  comp, spese, imp, ritpag;
  int   i, iNumRigaAS;
  
  TSheet_field& pag = pags();
  _pags->destroy();

  iNumRigaAS = 0; 	// numero di riga dell'array-sheet. Viene incrementato
  					// solo quando si trovano pagamenti 'giusti' (cioe' solo
  					// quando si aggiungono elementi all'array-sheet)
  for ( i = 0; i < pag.items(); i++)
  {
    TToken_string* d    = new TToken_string(64);
    TToken_string& riga = pag.row(i);

// Scarto le righe non significative 
    if (my_empty_items(riga, FALSE)) continue;

    const long nvers = riga.get_long(9);
    
// "Se il pagamento e' gia' stato selezionato DA UN ALTRO versamento
//  NON si deve vedere! "    
    if (nvers > 0  &&  nvers != numvers) 
      continue; 

    const long npag = i;    
    
    const int LARGHEZZA_COL = 15;
    d->add(" ");                    // 0 spazio per la 'X' di selezione
    TString dep(riga.get(0));
    d->add(dep);                    // 1 data pagamento
    comp    = riga.get(1); 
    dep     = comp.string(".");
    dep.right_just(LARGHEZZA_COL);
    d->add(dep);       				// 2 compenso
    spese   = riga.get(2);      
    dep     = spese.string(".");
    dep.right_just(LARGHEZZA_COL);    
    d->add(dep);      				// 3 spese

// NB 
// se cambia posizione nriga o ritpag nella tokenstring cambia 
// anche in pag_select()!
    ritpag  =   riga.get(SS_POS_RITPAG);
    dep     = ritpag.string(".");     
    dep.right_just(LARGHEZZA_COL);        
    d->add(dep);
    
    d->add(i, SS_POS_NRIGA);
// Metto nell'array-sheet anche NUMVERS
    d->add(nvers, SS_POS_NVER);   
    
    _pags->add(*d);   // aggiungo la riga nell'array_sheet
// Setto il bit alla posizione numpag e metto la X
    if (nvers == numvers)
    {
      _selected.set(npag);    
      _pags->check(iNumRigaAS, TRUE);
    }                        
    iNumRigaAS++; // ignoro in questo contatore i pagamenti che NON 
                  // si vedono (se il pagamento e' scartato prima di qui
                  // non ci passa)
  }
}  

void TSchedaPercipienti::attach_pag_vers (int pag, long numvers)
{
  TSheet_field&  pag_s = pags();
  TToken_string& riga  = pag_s.row(pag);

// setta NUMVERS nello sheet
  riga.destroy(9);
  riga.add(numvers, 9);

// setta NUMVERS nel record
  _rel->pag(pag).put("NUMVERS", numvers);  
}

void TSchedaPercipienti::detach_pag_vers (int pag)
{
  TSheet_field& pag_s = pags();
  TToken_string& riga = pag_s.row(pag);

  riga.destroy(9);
  riga.add(-1L, 9);   

// setta NUMVERS nel record
  _rel->pag(pag).put("NUMVERS", -1L);    
}
                                                         
//
// VERS_ATTACHED ( numvers )
//
// Determina se c'e' ALMENO UN pagamento collegato al versamento NUMVERS
//                                                         
bool TSchedaPercipienti::vers_attached(const long numvers)
{
  long numv = 0L;

// Aggiorna lo sheet dei pagamenti per questo versamento
  app().load_pag_sheet(numvers);                        

  for (int j = 0; j < _pags->items(); j++)
  {
// Leggo NUMVERS
    TToken_string& riga  = _pags->row(j);
    numv = riga.get_long(SS_POS_NVER);

    if (numv > 0L)
      if (numv == numvers) 
        return TRUE;
  }
  return FALSE;
}

// 
// CHECK_PAGAMENTI
// Questo serve solo a impedire di uscire senza aver collegato almeno
// un pagamento
//                 
bool TSchedaPercipienti::check_pagamenti(TMask_field& f, KEY k)
{
  const long  numvers = get_numvers(f);
  return app().vers_attached(numvers);
} 

void TSchedaPercipienti::setta_ritvers(TMask_field& f, const real& ritenuta) 
{
  TString80 rit_str(ritenuta.string());
  f.mask().set(F_RITVERS, rit_str);     
  f.mask().field(F_RITVERS).set_dirty(); // Forza on_hit()    
}

// Guardo se ho compilato la data OPP. il flag 1015
// Leggo la maschera o la riga dello ss
bool TSchedaPercipienti::compilato_vers(TMask_field& f)
{
  TString16 datav;
  char v1015;
  
  if (f.mask().is_running())
  {
    datav = f.mask().get(F_DATAVERS);
    v1015 = f.mask().get(F_VERS_1015)[0];
  }
  else             
  {
    TSheet_field& ver    = app().vers();   
    const int riga_corr  = ver.selected();
    TToken_string& riga  = ver.row(riga_corr);
    v1015                = riga.get(0)[0];
    datav                = riga.get(1);
    datav.trim();
  }
  return datav.not_empty() || v1015 == 'X';
}     

  
//
// GET_NUMVERS
//
// Determina il numero di versamento corrente, prendendolo :
//
//      dalla maschera, se e' running SENNO'
//      dalla riga corrente dello spreadsheet
//                                     
long TSchedaPercipienti::get_numvers(TMask_field& f)
{
  long numvers = 0L;
  
// Prendo il numvers da campo nascosto nella maschera
  if (f.mask().is_running())
    numvers = f.mask().get_long(VERF_NUMVERS);
  else             
  {
    TSheet_field& ver    = app().vers();   
    const int riga_corr  = ver.selected();
    TToken_string& riga  = ver.row(riga_corr);
    numvers = riga_corr + 1;
//    numvers              = riga.get_long(SS_POS_NUMVERS);
  }
  return numvers;
}     

bool TSchedaPercipienti::pag_azzera (TMask_field& f, KEY k)
{     
  if (k == K_SPACE)
    app()._azzerato_pag = TRUE;  // Messo a FALSE in pag_notify
                       // Serve per NON far riscrivere la % di ritenuta
  return TRUE;
}

bool TSchedaPercipienti::ver_azzera (TMask_field& f, KEY k)
{     
  long        numvers = get_numvers(f);
  int         nriga   = 0;      
  TNikArray_sheet& pags = *app()._pags;
  
  if (k == K_SPACE)
  {    
    app().load_pag_sheet(numvers);       

    for (int j = 0; j < pags.items(); j++)
    {
      TToken_string& riga  = pags.row(j);
      long numv = riga.get_long(SS_POS_NVER);

      if (numv > 0L)
        if (numv == numvers) 
        {
          nriga =  pags.row(j).get_int(SS_POS_NRIGA);      
          pags.row(j).add(-1L, SS_POS_NVER);            
          app().detach_pag_vers(nriga);
        }
    }
  }
  return TRUE;
}

//
// PAG_SELECT
//
// Collegamento tra versamenti e pagamenti
//
// Calcolo ritenuta = SUM(ritpag) {dei pagamenti collegati} 
//
// Usa: load_pag_sheet() attach_pag_vers() e detach_pag_vers()
//
bool TSchedaPercipienti::pag_select (TMask_field& f, KEY k)
{
  if (k == K_SPACE)
  {                           
    if (!app().compilato_vers(f)) 
      return f.warning_box("Inserire prima la data del versamento");

    long        numvers = get_numvers(f);
    long        numpag  = 0L;
    int         nriga   = 0;      
// 13.7.95 Ricalcola la ritenuta, azzerando contenuto precedente
    real		ritenuta = ZERO;
    TBit_array& selected = app()._selected; 
    
    selected.reset();

// Costruisce array_sheet dei pagamenti     
    app().load_pag_sheet(numvers);       
    
    TNikArray_sheet& ASpags = *app()._pags;
/*
    const int iPagsASheetItems = ASpags.items();
// Metto la 'X' per quelli gia' collegati (se e' acceso il bit[NUMPAG])
    for (int j = 0; j < iPagsASheetItems; j++)
      ASpags.check(j, selected[j]);*/
                                                   
// seleziona e aggiungi alle gia' selezionate 
    if (ASpags.run() == K_ENTER)
    {
      for (int j = 0; j < ASpags.items(); j++)
      {
        // get effettivo numero riga pag.
        nriga =  ASpags.row(j).get_int(AS_POS_NRIGA);
                              
        int mesec = -1;
        int annoc = -1; // competenza
                                      
        if (ASpags.checked(j)) 
        {
// Scrive nello spread-sheet e nella relazione
          app().attach_pag_vers(nriga, numvers); 

 // Scrive nell'array_sheet (e' da qui che leggo dopo)
          ASpags.row(j).add((long)numvers, AS_POS_NVER);
          
          TDate datapag(ASpags.row(j).get(1));
          if (mesec < 0)
          {
            mesec = datapag.month();
            annoc = datapag.year();
          }
          else
          {
            if (mesec != datapag.month() || annoc != datapag.year())
// TBI inserire un'altra riga di versamento (?)
            ;
          }
          selected.set(numpag);

          real dep(real::ita2eng(ASpags.row(j).get(AS_POS_RITPAG)));
          ritenuta    +=  dep;
        }
        else       // pags.checked()
        {
// resetta se era stato settato prima        
          if (selected[numpag])  
          {
            selected.reset(numpag);
            ASpags.row(j).add(-1L, AS_POS_NVER);
            app().detach_pag_vers(nriga);
          }
        }
      }
      setta_ritvers(f, ritenuta);
    }  // if k==K_ENTER
  }
  return TRUE;
}       

#define F_SER_VERS        209
#define F_ABI_VERS        210
#define F_NUM_VERS        211
#define F_CAB_VERS        212
#define F_QUIETANZA_VERS  213

void TSchedaPercipienti::work_tipoluogo(TMask_field& f)
{
  TMask&  m       = f.mask();
  char    tipo    = m.get(F_TIPOVERS)[0];
  char    luogo   = m.get(F_LUOVERS)[0];
  TSheet_field& ss = app().vers();
  const int  row   = ss.selected();
                        
  m.hide (-2);            // nasconde tutto                    
//  ss.enable_cell(row,4);    

  if (tipo == 'B')                     
  {
    m.show (-6);    // ABI e CAB
    m.enable(SM_PROGRBANCA); // abilita progressivo vers.banca
    ss.enable_cell(row,6);
  }
  else
  {
    m.disable(SM_PROGRBANCA);
    ss.disable_cell(row,6);    

    if (tipo == 'D')
    {
      if (luogo == 'T') 
      {
        m.show(-3);     // SOLO quietanza
        ss.disable_cell(row,4);
      }
      else 
      {
        m.show(-4);     // serie e numero
        ss.enable_cell(row,4);    
      }
    }
//    else        
    if (tipo == 'C')
    {
      m.show (-5);  // SOLO numero versamento
      ss.disable_cell(row,4); 
    } 
  }
}

bool TSchedaPercipienti::luo_hndl(TMask_field& f, KEY k)
{
  if (k == K_TAB)
    work_tipoluogo(f);
    
  if (k == K_ENTER)
  {
    work_tipoluogo(f);
    TMask&  m       = f.mask();
    char    tipo    = m.get(F_TIPOVERS)[0];
    char    luogo   = m.get(F_LUOVERS)[0];

// Se ho indicato il luogo => devo indicare anche il TIPO
    if (isalpha(luogo)) 
      return tipo == ' ' || tipo == '\0' ? 
        f.warning_box("Indicare il tipo del versamento") : TRUE;
  }
  return TRUE;
                               
}

bool TSchedaPercipienti::abicab_hndl(TMask_field& f, KEY k)
{
  if (f.to_check(k))                                           
  {
    TString16 park(f.get());
    TMask&  m       = f.mask();
    char    tipo    = m.get(F_TIPOVERS)[0];

// ABI/CAB solo se tipo e' B
    if (tipo != 'B')
      return TRUE;
          
    for (int i=0; i<park.len(); i++)
    {                                                                  
    	// controllo se codice CAB supera le 5 cifre
    	if (i > 5)
      {
        f.reset();
        return f.warning_box("Codice CAB non valido"); 
      }
      // controllo numericità del codice ABI/CAB
      if (!isdigit(park[i]))
        return f.warning_box("Il codice ABI/CAB deve essere numerico");
    }     
  }
  return TRUE;
}

bool TSchedaPercipienti::tipo_hndl(TMask_field& f, KEY k)
{
  if (k == K_TAB)
    work_tipoluogo(f);

  if (k == K_ENTER || k == K_TAB)
  {
    TMask&  m       = f.mask();
    char    tipo    = m.get(F_TIPOVERS)[0];
    char    luogo   = m.get(F_LUOVERS)[0];
    
// Se ho indicato il tipo => devo indicare anche il LUOGO
    if (isalpha(tipo)) 
      return luogo == ' ' || luogo == '\0' ? 
        f.warning_box("Indicare il luogo del versamento") : TRUE;
  }
  return TRUE;
}
                             
//
// VERS1015_HANDLER
//                             
bool TSchedaPercipienti::vers1015_handler(TMask_field& f, KEY k)
{
  if (k == K_ENTER)
  {
    TString16 datas      = f.mask().get(F_DATAVERS);
    const bool v1015     = f.mask().get_bool(F_VERS_1015);
    const bool attaccati = check_pagamenti(f,k);

    if (attaccati)
      if (!v1015 && datas.empty())
        return f.warning_box("Manca la data del versamento");
        
// Non considerare versamenti non significativi    
    if (v1015 || datas.not_empty())
      return attaccati ? TRUE : f.warning_box("Nessun pagamento collegato");

    const real rite (f.mask().get(F_RITVERS));
// Pero' se c'e' la ritenuta non lo far passare
    if (rite != ZERO)
      return f.warning_box("Manca la data oppure il flag di versamento 1015");
              
    return TRUE;
  }
          
  if (k == K_SPACE || k == K_F2)
  {
    TSheet_field& ss = app().vers();
    const bool v1015 = (f.get() == "X");
    const int  row   = ss.selected();
    int i;

// Disabilito tutto MA NON ritenuta        
    if (v1015) 
    {
// Se son gia' disabilitati non fare nulla
      if (ss.cell_disabled(row, 1)) 
        return TRUE;

      f.mask().reset(102);
      f.mask().reset(103);
      f.mask().reset(104);
      f.mask().reset(105);
      f.mask().reset(106);  
      
      f.mask().disable(102);
      f.mask().disable(103);            
      f.mask().disable(104);
      f.mask().disable(105);
      f.mask().disable(106);
                  
      for (i=1; i<6; i++)          
        ss.disable_cell(row,i);
    }
    else
    { 
      f.mask().enable(102);
      f.mask().enable(103);      
      f.mask().enable(104);
      f.mask().enable(105);
      f.mask().enable(106);
    
      for (i=1; i<6; i++)
        ss.enable_cell(row,i);    
    }
  }
  return TRUE;
}

//
// Quadro C e E1:   immissione per le sole persone fisiche
//
bool TSchedaPercipienti::check_causale(TMask_field& f, KEY k)
{
  TMask& m = f.mask();
  
  if (k == K_TAB && m.is_running())
//  if (f.to_check(k))
  {
    TFixed_string cod_caus(f.get(),3);
        
    if (cod_caus.empty())
    {
      KEY ke = m.last_key();
      if (ke != K_QUIT && ke != K_ESC)
        return f.warning_box("Manca la causale");
    }
    else
    {
      TString16   cod_qua  (m.get(F_CODQUA));
      char        tipo    = m.get(F_TIPOA)[0];

      if (cod_qua == "C" || cod_qua == "E1")
        if (tipo == 'G')
          return f.warning_box("Con il quadro C o E1 e' possibile l'immissione"
                               " per le sole persone fisiche");
      if (__bRicalcolaRigaPag)
      {                               
        real rInpsComplex, rInpsPerc;
        TSheet_field& pags = app().pags();      
        TMask& ssMask = pags.sheet_mask();       
        real rPercCassaPrev        = ZERO;
	      real rPercContrInps        = ZERO;
	      real rPercAssContrInps     = ZERO;
	      real rQuotaCommitContrInps = ZERO;
	      bool bContrInps=FALSE;

// aggiorna la riga ( collegamenti con 6(occas.) e 3(pag.) )        
        TString sPercRa(6);
        real rImpoCg = app().calcola_imponibile(__rCompensoCg);
        real rRiteCg = app().calcola_ritenuta(rImpoCg,sPercRa,rPercCassaPrev,
          rPercContrInps,rPercAssContrInps,rQuotaCommitContrInps,bContrInps); 
        TToken_string& tsRiga = pags.row(0);
        tsRiga.add(rImpoCg.string(), 3);
        tsRiga.add(sPercRa, 4);
        tsRiga.add(rRiteCg.string(), 5);                                   
// Calcola anche contributo INPS
        if (bContrInps)
        {
	        real rScorporaComp, rImpInps;
	        CalcolaInps(rPercCassaPrev,__rCompensoCg,rPercContrInps,rPercAssContrInps,
	                    rQuotaCommitContrInps,rInpsPerc,rInpsComplex);
	         
	        TString sInpsComp(rInpsComplex.string());
	        TString sInpsPerc(rInpsPerc.string());      
          tsRiga.add(sInpsPerc,6);
          tsRiga.add(sInpsComp,7);
        }                                        
// Calcola il netto                                     
        real rSpesa(tsRiga.get(2));
        real rNetto = __rCompensoCg-rRiteCg+rSpesa-rInpsPerc;
        tsRiga.add(rNetto.string(),8);
        pags.force_update(0);
// Per evitare che i valori vengano azzerati:
        __compe = __rCompensoCg;
        __impo  = rImpoCg;
        __percra = atof(sPercRa);
        __rite = rRiteCg.string();
      }
    }                            
  }
  return TRUE;
}

///////////////////////////////////////////////////////////////////////////
//
//  RIGA PAGAMENTI
//
///////////////////////////////////////////////////////////////////////////
//
// SPESA_HANDLER
//
// Forza il ricalcolo del netto se cambia la spesa
//
bool TSchedaPercipienti::spesa_handler(TMask_field& f, KEY k)
{
  if (k == K_TAB)
    f.mask().send_key(K_TAB, MPAG_NETTO);  // forza il ricalcolo del netto
  return TRUE;
}

// CHECK_RITENUTA
// o Controlla se la ritenuta e' corretta (SOLO SE != ZERO 22.7.96)
// o Ricalcola la ritenuta se e' stata vuotata
bool TSchedaPercipienti::check_ritenuta(TMask_field& f, KEY k)
{
  if (k == K_TAB)
  {
    TString rit(f.get());
    const bool changed_rit = __rite.not_empty() ? __rite != rit : FALSE;
    const real imponibile(f.mask().get(MPAG_IMPONIBILE));

    if (rit.empty())       
      calcola_ritenuta(f,imponibile);
    else
      if (changed_rit)
        f.mask().send_key(K_TAB, MPAG_NETTO);  // forza il ricalcolo del netto
  }

// Controlla solo se RITENUTA != ZERO
  if (k == K_ENTER)
  {                                
    TMask& m = f.mask();
    const bool forzatura = app().curr_mask().get_bool(F_FORCED);  
    real  perc_ra = (m.get_real(MPAG_PERCRA) );
    if (perc_ra == ZERO)
      perc_ra = 100.00;
    const real imponibile (m.get(MPAG_IMPONIBILE));
    real ritenuta (m.get(MPAG_RITPAG));

    if (ritenuta == ZERO)
      return TRUE;
      
    real rite = ZERO;
// Se non indico la percentuale => considero come 100%    
    if (perc_ra != ZERO)    
      rite  =  (imponibile * perc_ra) / 100.00;
    else
      rite = imponibile;

    rite.trunc();
    ritenuta.trunc();
    rite.round(0);
    ritenuta.round(0);              
    
#ifdef DBG
    TString rites(rite.string());
    TString riten(ritenuta.string());
#endif

// Segnala solo se la ritenuta calcolata non e' compresa in quella 
// letta piu' o meno 1    
    if ( (rite < ritenuta-1)  || (rite > ritenuta+1) )
    {
#ifdef DBG    
      f.warning_box("Ritenuta errata calcolo: %s trovo: %s", (const char*) rites, (const char*) riten);
#else
      f.warning_box("Ritenuta errata");  
#endif      
      return forzatura;
    }
  }
  return TRUE;
}

//
// CALCOLA_IMPONIBILE
//
// Chiamato dall'handler del COMPENSO
// Calcola l'imponibile SE il compenso e' diverso da ZERO
// e lo setta nella maschera
//                 
real TSchedaPercipienti::calcola_imponibile(TMask_field& f, const real& compenso, 
                                            const bool force)
{
  TMask& mm = app().curr_mask();
  TMask& lm = f.mask();
  real       quota_imp   = mm.get_real(F_QUOTAIMP);
  TString16   cod_qua    = mm.get(F_CODQUA);
  real        imponibile_calcolato = ZERO;
  const bool bContributoInps = mm.get_bool(F_FLAG_INPS);  
  const real imp_prec(lm.get(MPAG_IMPONIBILE));

// Ricalcolo sempre. NO! modifica del 4/10/95. Su richiesta di Omero
    if (imp_prec != ZERO && !force) 
      return imp_prec;

// Calcola imponibile                       
  if (compenso != ZERO) 
  {                       
    imponibile_calcolato = (compenso * quota_imp) / 100.00;
		
		// scorpora la percentuale cassa previdenza
    real rPercCassaPrev=ZERO;
    rPercCassaPrev = mm.get_real(F_CASSA_PREV);
    imponibile_calcolato = (imponibile_calcolato / (100.00 + rPercCassaPrev)) * 100.00;
   
    TString impost(imponibile_calcolato.string());
    lm.set(MPAG_IMPONIBILE, impost);
  }   
  return imponibile_calcolato;
}

bool TSchedaPercipienti::imponibile_handler(TMask_field& f, KEY k)
{                                  
  if (k == K_TAB)
  {
    const real imponibile(f.mask().get(MPAG_IMPONIBILE));
    const bool forza_ricalcolo = __impo != imponibile;
    if (__impo != imponibile) 
      __impo = imponibile;
    if (forza_ricalcolo)
      calcola_ritenuta(f, imponibile, forza_ricalcolo);  
  }
  return TRUE;
}

void CalcolaInps(const real& rPercCassaPrev,const real& rCompenso, 
  const real& rPercContrInps,const real &rPercAssContrInps,
  const real& rQuotaCommitContrInps, real& rInpsPerc,real& rInpsComplex)
{
  real rScorporaComp, rImpInps;
  rScorporaComp = (rCompenso / (100.00 + rPercCassaPrev)) * 100.00;
  rImpInps      = (rScorporaComp / 100.00) * rPercAssContrInps;
  rImpInps.round(0);
  rInpsComplex  = (rImpInps / 100.00 ) * rPercContrInps;
// Se zero si considera 2/3
  if (rQuotaCommitContrInps == ZERO)
    rInpsPerc     = rInpsComplex - ((rInpsComplex * 2)/3);
  else
    rInpsPerc     = rInpsComplex - ((rInpsComplex * rQuotaCommitContrInps)/100.00);
}        

//  
// Handler del COMPENSO
//
// "Calcola ritenuta quando inserisci il compenso"    
// chiama calcola_imponibile se compenso e' cambiato
//
bool TSchedaPercipienti::compenso_handler(TMask_field& f, KEY k)
{
  TMask& mm = app().curr_mask();  	// main mask
  TMask& lm = f.mask();				// local mask
  const bool forzatura = mm.get_bool(F_FORCED);  
  real  compenso (lm.get(MPAG_COMPENSO));        
  real        imponibile = ZERO;
  TString16 cod_qua(mm.get(F_CODQUA));  
  const bool bContributoInps = mm.get_bool(F_FLAG_INPS);  
  bool bCambiatoCompenso = FALSE;

  if (k == K_TAB)
  {
    if (__compe != ZERO && compenso == ZERO)
      app()._azzerato_pag = FALSE;

    if (compenso == ZERO) 
      return TRUE;

    bCambiatoCompenso = __compe != ZERO ? __compe != compenso : FALSE;
    if (__compe != compenso) 
      __compe = compenso; // per evitare di perdere l'imponibile

    imponibile = calcola_imponibile(f, compenso, bCambiatoCompenso);
    
#ifdef DBG
    tmp1 = imponibile.string();
    tmp2 = compenso.string();
    if (cod_qua != "E1")    
      if (imponibile > compenso)
        warning_box("Imponibile = %s - Compenso = %s", (const char*)tmp1,(const char*)tmp2 );
#endif

    calcola_ritenuta(f, imponibile, bCambiatoCompenso);

// "Solo per il quadro E1 l'imponibile puo' essere maggiore del compenso"
    if (cod_qua != "E1")
      if (imponibile > compenso)
      {
        f.warning_box("L'imponibile non puo' essere" 
                      " maggiore del compenso");
        return forzatura;
      }

// Calcolo contributo INPS
    if (bContributoInps)
    {
      real rInpsPercPrima = lm.get_real(MPAG_INPSPERC);
      real rInpsCompPrima = lm.get_real(MPAG_INPSCOMP); 
      real rScorporaComp, rImpInps, rInpsComplex, rInpsPerc;
      real rPercCassaPrev        = mm.get_real(F_CASSA_PREV);
      real rPercContrInps        = mm.get_real(F_PERC_INPS);
      real rPercAssContrInps     = mm.get_real(F_PERC_ASS_INPS);      
      real rQuotaCommitContrInps = mm.get_real(F_PERC_COMMIT_INPS);
      CalcolaInps(rPercCassaPrev,compenso,rPercContrInps,rPercAssContrInps,
        rQuotaCommitContrInps,rInpsPerc,rInpsComplex);
         
      TString sInpsComp(rInpsComplex.string());
      TString sInpsPerc(rInpsPerc.string());      
// Setto i compensi INPS solo se prima erano vuoti
      if (rInpsPercPrima == ZERO || bCambiatoCompenso)
        lm.set(MPAG_INPSPERC, sInpsPerc);
      if (rInpsCompPrima == ZERO || bCambiatoCompenso)        
        lm.set(MPAG_INPSCOMP, sInpsComp); 
    }
    lm.send_key(K_TAB, MPAG_NETTO);  // forza il ricalcolo del netto
  }             
  
  if (k == K_ENTER)
  {
    // "Solo per il quadro E1 l'imponibile puo' essere maggiore del compenso"
    if (cod_qua != "E1")
      if (imponibile > compenso)
      {
        f.warning_box("L'imponibile non puo' essere" 
                      " maggiore del compenso");
        return forzatura;
      }
  }
  return TRUE;
}

//
// CALCOLA_RITENUTA
//
// Calcola la ritenuta in base alla % r.a. indicata ( o, se vuota, a quella 
// della causale ) e setta il campo della maschera
//  
//  --[ NB ]--
//              Ricalcola solo se VUOTA            
//
bool TSchedaPercipienti::calcola_ritenuta(TMask_field& f, const real& imponibile, const bool forza, const real percent)
{
  TMask& m=f.mask();
  real rPercRaRiga  = m.get_real(MPAG_PERCRA);
  real rPercRaCaus  = app().curr_mask().get_real(F_PERRIT);
  const bool   azzerato = app()._azzerato_pag;
  const real rit_prec(m.get(MPAG_RITPAG));

  if (rit_prec != ZERO && !forza) 
    return FALSE;

  real rPerc = ZERO;
// Uso la percentuale della causale SE NON indicata qui E
// SE NON viene passata come parametro (in percra_handler quando si cambia
// l'aliquota)
  if (percent == ZERO)
    rPerc = rPercRaRiga != ZERO ? rPercRaRiga : rPercRaCaus;      
  else
    rPerc = percent;
//
// Faccio vedere % R.A. presa dalla causale se non l'ho indicata
// e se non ho premuto Azzera (1.12.95)
// Pero' se uno fa azzera e poi riscrive il compenso deve riapparire...
//          
//  const bool prendi_ra_da_causale = forza ? TRUE : perc_ra == ZERO && !azzerato;
  const bool prendi_ra_da_causale = rPercRaRiga == ZERO && !azzerato;  
  if (prendi_ra_da_causale)
  {
    TString quota_rast(rPercRaCaus.string());
    m.set(MPAG_PERCRA, quota_rast);
  }
    
// Calcolo ritenuta ...
  real rite = (imponibile * rPerc) / 100.00;
    
// .. riempie il campo corrispondente 
  TString ritest(rite.string());
  m.set(MPAG_RITPAG, ritest);  
  m.send_key(K_TAB, MPAG_NETTO);  // forza il ricalcolo del netto  
  return TRUE;
}

// 
// Handler della percentuale di r.a.
// ricalcolo la ritenuta quando cambia
//
bool TSchedaPercipienti::percra_handler(TMask_field& f, KEY k)
{
  if (k == K_TAB)
  {
    const real  compenso (f.mask().get(MPAG_COMPENSO));    
    const real  imponibile (f.mask().get(MPAG_IMPONIBILE));    
    real percra(f.get());
    const bool forza_ricalcolo = __percra != percra;
    if (__percra != percra) 
      __percra = percra;

    if (compenso != ZERO) 
    {
      if (forza_ricalcolo)
        calcola_ritenuta  (f, imponibile, forza_ricalcolo);    
    }
  }
  return TRUE;
}

bool TSchedaPercipienti::netto_handler(TMask_field& f, KEY k)
{
  if (k == K_TAB)
    calcola_netto(f);
  return TRUE;
}

// 
// Calcola e setta il NETTO
//                 
// Il netto e' ricalcolato e settato sempre visto che non e' gestibile
//
real TSchedaPercipienti::calcola_netto(TMask_field& f)
{
  real netto = ZERO;
  TMask& m = f.mask();    
  const real ritenuta (m.get(MPAG_RITPAG));
  const real compenso (m.get(MPAG_COMPENSO));
  const real spesa    (m.get(MPAG_SPESA));
  const real inpsperc (m.get(MPAG_INPSPERC));
      
  netto = compenso - ritenuta + spesa - inpsperc;
//  netto.trunc();      
  f.mask().set(MPAG_NETTO, netto.string());
  
  return netto;
}