// 772100.cpp - Stampa schede percipienti
#include <mask.h>   
#include <printapp.h>
#include <relation.h>
#include <config.h>
#include <tabutil.h>
#include <utility.h>
#include <sort.h>
#include <lffiles.h>
#include "scperc.h"
#include "rpag.h"
#include "rver.h"
#include <comuni.h>
#include <nditte.h>
#include <anagr.h>
#include <anafis.h>
#include "perc.h"
#include <mailbox.h>
#include <execp.h>

#include "772.h"
#include "772100.h"
#include "77lib.h"

//
// Lista modifiche                                         
//
// 23.11.95 Nella stampa a 198 una colonna sola comprendente quote e 
//          spese non soggette 
// 27.11.95 Scarta le schede con annodoc MAGGIORE di annodic
// 27.11.95 Se l'annopag e' successivo mette il pag. nei NON pagati e non lo stampa
//  7.12.95 Riparte da pag.1 con un nuovo percipiente
// 11. 1.96 Nel tot_comp_non_pagati somma anche i pagamenti di anni precedenti
// 11. 1.96 Scarta le schede SOLO SE non hanno NESSUN pag con annopag==annodic
//          non piu' in base  al loro annodoc
//

/****************************************************************************
 11.1.96
 Layout della stampa a 198
 I numeri indicati sono gia' calcolati come parametri per set_row() e set_header()
                                                                                                                                                 145
                                                                                80                                                               Somme o     D     
Cod.                                       43               60        70        Totale    Data       101          115     122         134        quote     T C          Serie Numero   183
Caus.   Descrizione     Data     Numero    Imponibili       Spese     Imposte   Documento Pagamento  Imponibili   %       Ritenute    Compensi   non sogg. C B Data     ABI   CAB      Importo versato
   3    8               24       33      41          53          65          77           90       99           112   118         130         142        155   159      168   174         186
II I__I I_15__________I I______I I_____I I_IMPONIB__II_SPESE____II_IMPOSTE__II_TOTDOC___I I______I I_IMPOPAG__I I___I I_RITPAG___II_COMPENS__II_NSOGG____I I I I______I I___I I_________I I_IMPVERS__I
                                                                                                                                                           157       

****************************************************************************/
void calcola_non_pagate(TSchedaP& sch_corr, real& comp_npag, real& spese_npag, const int anno_in_corso);

HIDDEN TString256  tmp;
HIDDEN const int   RIGHE_FOOTER = 2;
HIDDEN const char* P198_REAL_PICTURE = "############";

class TStampa_perc : public TPrintapp
{ 
  char  _liv;       // Se stampa a livello di studio
  int   _anno_dic;  // Anno dichiarazione nei paramentri utente o studio
  bool  _changed_perc;  // flag che segnala il passaggio a nuovo perc.    
  struct righe_pag
  {
    char   codq[3];
    char   codc[5];
    char   perc[7];
    real   totale;
    real   somme;
    real   quote;
    real   imp;
    real   rit;
    real   netto;
  };
  
  TRelation*        _rel;
  TCursor*          _cur;
  righe_pag*        _bil;
  TSort*            _sort;
  TVersamento_stampa  _stvers;
  const char*       _buf;
  TLocalisamfile*   _nditte, *_anag, *_rpag, *_rver, *_comuni;  
  TString16         _section;
  TConfig*          _cnf;
  TString   _ragsocER,_indER,_civER,_capER,_dencomER,_provER,_cofiER;
  TString   _ragsocPE,_indPE,_civPE,_capPE,_dencomPE,_provPE,_cofiPE;
  TString   _dencomnscER,_provnscER,_dencomnscPE,_provnscPE;
  TString   _datanascER,_datanascPE,_desc_cau,_numdoc;         
  TDate     _datadoc;
  int   _nprog;
  int _anno,_numcarat,_codcaus,_codtrib;
  long  _codditta,_codanagER,_codanagPE;
  char  _tipoa, _tipoaER;                             
  real  _impondoc,_spesedoc,_imposdoc,_totaledoc;
  real  _tot_comp,_tot_fatt;
  real  _tot_somme_non_soggette, _tot_comp_non_pagati; // tot.delle rimanenze di un percipiente
  real  _compenso_dovuto, _spese_dovute; // usati per calcolare rimanenza di una scheda
  bool  _rifai_sort,_stampa_modulo;
  int       _ind,_mesecomp,_annocomp;
  bool      _stampa_scheda; // stampo o no la scheda corrente
  bool      _almeno_una_scheda; // c'e' almeno una scheda stampabile
  bool        init_print();
  void      add(TVersamento& vers);
  bool      find(TVersamento& vers);

protected:
  virtual void on_config_change();
  virtual bool user_create() ;
  virtual bool user_destroy();
  virtual bool set_print(int m);
 
  virtual bool preprocess_page (int,int);
  virtual bool preprocess_print(int,int);
  virtual print_action postprocess_page (int,int);
  virtual void preprocess_header();

public:
  int  stampa_vers(TVersamento_stampa& vers, int riga, const int numvers, const real& ritenpag);
  void dati_erogante();
  void dati_percipiente();   
  int  stampa_dati_erog_perc();
  int  ricerca_causale(TString&,TString&);
  void setta_righe_documento();
  void setta_righe_pagamenti (TDate& datapag, const real& imponpag,const TString& percent,const real& ritenpag,const real& compenpag,const real& spesepag, const real& quotepag,int i);
  void setta_righe_versamenti(char luo, char tipo, TDate& dataver, const TString& serie, const TString& numero,const real& impvers,int j); 
  void do_sort(const TString&,int,const real&,const real&,const real&,const real&,const real&,const real&);    
  void setta_righe_documento_modulo();
  int  setta_righe_pagamenti_modulo(TDate& datapag, const real& imponpag,const TString& percent,const real& ritenpag,const real& compenpag,const real& spesepag, const real& quotepag,int j);
  int  setta_righe_versamenti_modulo(char luo,char tipo,TDate& dataver,const TString&,const TString&,const real&,int); 
  void init_sort();
  void riempi_record(const TString&,int,const real&,const real&,const real&,const real&,const real&,const real&,const real&);
  void set_bil_key(righe_pag* b,const char* codq,int codc,const real& perc);
  void set_bil_val(righe_pag* b, const real& totale = ZERO,const real& somme = ZERO,
                    const real& quote = ZERO,const real& imp = ZERO,
                    const real& rit = ZERO,const real& netto = ZERO);
  void intestazione_riepilogo(const bool redo_header=FALSE, const int start_riga=0);
  real fatture();        
  static bool codditta_hnd(TMask_field& f, KEY k);
    
// D = stampa ditta, S = stampa a livello di studio 
  TStampa_perc(char livello='D') : _liv(toupper(livello)) {}
};

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

void TStampa_perc::add(TVersamento& vers)
{
  _stvers.add(vers);
}

bool TStampa_perc::find(TVersamento& vers)
{
  return _stvers.find(vers);
}

bool TStampa_perc::codditta_hnd(TMask_field& f, KEY k)
{         
  if (k == K_TAB && !(f.mask().is_running()) )
  {
    TString16 codditta; codditta << app()._codditta;
    if (codditta != "0")        
    {
      f.set(codditta);
      f.check();
    }
  }   
  return TRUE;                                           
}

void TStampa_perc::init_sort()
{
  _sort->reset(sizeof(righe_pag));
  _sort -> addsortkey ((char*)&(_bil->codq) - (char*)&(_bil->codq),2);
  _sort -> addsortkey ((char*)&(_bil->codc) - (char*)&(_bil->codq),4);
  _sort -> addsortkey ((char*)&(_bil->perc) - (char*)&(_bil->codq),6);
  _sort -> init();
}

void TStampa_perc::set_bil_key(righe_pag* b,const char* codq,int codc,const real& perc)
{
  strcpy (b->codq, codq);
  sprintf(b->codc , "%4d", codc);
  TString16 pp(perc.string("###,@@"));
  sprintf(b->perc, "%s", (const char*)pp);
}

void TStampa_perc::set_bil_val(righe_pag* b, const real& totale, 
                                     const real& somme,const real& quote,
                                     const real& imp,const real& rit, const real& netto)
{
  b->totale  = totale;
  b->somme   = somme;
  b->quote   = quote;
  b->imp     = imp;
  b->rit     = rit;
  b->netto   = netto;  
}

void TStampa_perc::riempi_record(const TString& codq,int codc,const real& perc,
                                       const real& totale,const real& somme,
                                       const real& quote,const real& imp,
                                       const real& rit,const real& netto )
{
  set_bil_key(_bil, codq, codc, perc);
  set_bil_val(_bil, totale, somme, quote, imp, rit, netto);
  _sort->sort ((const char*) _bil);
}
                                                         
void TStampa_perc::do_sort(const TString& codqua,int codcaus,const real& perc,const real& spese,
                           const real& quote,const real& imp,const real& rit,const real& comp)
{
  real totale,netto;
  netto  = imp - rit;
  totale = comp + spese     ;
  riempi_record(codqua,codcaus,perc,totale,spese,quote,imp,rit,netto);
}
                                                         
int TStampa_perc::ricerca_causale(TString& desc,TString& codqua)
{                           
  TTable ca7 ("%CA7");   
  TString16 dep;
  int cod = 0;
  
  ca7.zero();
  dep.format("%02d", _codcaus);
  ca7.put("CODTAB", dep);      
  if (ca7.read() == NOERR)
  {
    desc   = ca7.get("S0");
    cod    = ca7.get_int("I0"); 
    codqua = ca7.get("S1");
  }                                           
  return cod;
}
                                         
bool TStampa_perc::preprocess_print(int file, int counter)
{
  if (file == LF_SCPERC)
  {
//    _tot_comp_testata  = ZERO;
//    _tot_spese_testata = ZERO;
    _tot_somme_non_soggette = _tot_comp_non_pagati = ZERO;
    _almeno_una_scheda = FALSE;
  }                   
  return TRUE;
}
                         
void TStampa_perc::setta_righe_documento()
{
  reset_print();
  TString spesedoc(20), imposdoc(20), totdoc(20), impondoc(20);
  
  spesedoc = _spesedoc.string(P198_REAL_PICTURE); 
  imposdoc = _imposdoc.string(P198_REAL_PICTURE); 
  totdoc   = _totaledoc.string(P198_REAL_PICTURE); 
  impondoc = _impondoc.string(P198_REAL_PICTURE); 
      
  if (_numcarat == 1)
  {
    set_row (1, "Documento del %10s", (const char*) _datadoc);
    set_row (1, "@26gNumero@33g%-7s",  (const char*) _numdoc);
    set_row (1, "@41gPeriodo di competenza %2d / %4d", _mesecomp,_annocomp);
    set_row (2, "Cod.");
    if (_codtrib != 0)
      set_row (2, "@5g%4d",              _codtrib);
    set_row (2, "@10g%.35s",           (const char*) _desc_cau);
    set_row (2, "@46gCompenso %12s",   (const char*)impondoc);
    set_row (2, "@69gSpese %12s",      (const char*)spesedoc);
    set_row (2, "@89gImposta %12s",    (const char*)imposdoc);
    set_row (2, "@111gTotale %12s",    (const char*)totdoc);
/*    set_row (2, "@46gCompenso %12r",   &_impondoc);
    set_row (2, "@69gSpese %12r",      &_spesedoc);
    set_row (2, "@89gImposta %12r",    &_imposdoc);
    set_row (2, "@111gTotale %12r",    &_totaledoc);*/
  }
  else
    if (_numcarat == 2)
    {
      reset_row(1);
      set_row (1, "@0g%02d",    _codcaus);
      set_row (1, "@3g%4d",     _codtrib);
      set_row (1, "@8g%.15s",   (const char*) _desc_cau);   
      TString16 dep(_datadoc.string(brief));
      set_row (1, "@24g%8s",    (const char*) dep);                     
      set_row (1, "@33g%-7s",    (const char*) _numdoc);
      set_row (1, "@41g%12s", (const char*)impondoc);
      set_row (1, "@53g%12s", (const char*)spesedoc);
      set_row (1, "@65g%12s", (const char*)imposdoc);
      set_row (1, "@77g%12s", (const char*)totdoc);
/*      set_row (1, "@41g%12r", &_impondoc);
      set_row (1, "@53g%12r", &_spesedoc);
      set_row (1, "@65g%12r", &_imposdoc);
      set_row (1, "@77g%12r", &_totaledoc); */
    }
}
      
void TStampa_perc::setta_righe_documento_modulo()
{
  reset_print();
  
  if (_numcarat == 1)
  {
    set_row (1, "@18g%10s",    (const char*) _datadoc);
    set_row (1, "@10g%7s",     (const char*) _numdoc);
    set_row (1, "@42g%.29s",   (const char*) _desc_cau);
    set_row (1, "@74g%12r",  &_impondoc);
    set_row (1, "@105g%12r", &_spesedoc);
    set_row (1, "@89g%12r",  &_imposdoc);
    set_row (3, "@14g%12r",  &_totaledoc);    
    set_row (4, "");
  }
  else
    if (_numcarat == 2)
    {
      set_row (1, "@0g%02d",    _codcaus);
      set_row (1, "@3g%4d",     _codtrib);
      set_row (1, "@8g%.15s",   (const char*) _desc_cau);
      TString16 dep(_datadoc.string(brief));
      set_row (1, "@24g%10s",   (const char*) dep);                     
      set_row (1, "@33g%-7s",    (const char*) _numdoc);
      set_row (1, "@41g%12r", &_impondoc);
      set_row (1, "@53g%12r", &_spesedoc);
      set_row (1, "@65g%12r", &_imposdoc);
      set_row (1, "@77g%12r", &_totaledoc);
    }
}

void TStampa_perc::setta_righe_pagamenti(TDate& datapag,const real& imponpag,
  const TString& percent,const real& ritenpag,const real& compenpag,
  const real& spesepag, const real& quotepag,int i)
{
  if (_numcarat == 1)
  {
    set_row (i, "%10s",       (const char*) datapag.string());
    set_row (i, "@11g%12r", &imponpag);
    set_row (i, "@24g%s", (const char*)percent);    
    set_row (i, "@30g%12r", &ritenpag);
    set_row (i, "@42g%12r", &compenpag);
    set_row (i, "@54g%12r", &spesepag);
    if (quotepag != ZERO)
        set_row (i, "@67g%12r", &quotepag);
  }
  else
    if (_numcarat == 2)
    {
      TString16 dep(datapag.string(brief));
      real quotepag198 = ZERO;
      set_row (i, "@90g%8s",    (const char*) dep);
      set_row (i, "@99g%12r", &imponpag);
      set_row (i, "@112g%s", (const char*)percent);
      set_row (i, "@118g%12r", &ritenpag);
      set_row (i, "@130g%12r", &compenpag);
// 23.11.95 
// Nella stampa a 198 una colonna sola comprendente quote e spese non soggette 
      quotepag198 = compenpag - imponpag + spesepag; 
      set_row (i, "@142g%12r", &quotepag198);
    }
} 
                        
int TStampa_perc::setta_righe_pagamenti_modulo(TDate& datapag,const real& imponpag,
 const TString& percent,const real& ritenpag,const real& compenpag,
 const real& spesepag, const real& quotepag,int i)
{
  if (_numcarat == 1)
  {
    set_row (i, "@29g%10s",   (const char*) datapag.string());
    i += 2;
    set_row (i, "@56g%s", (const char*)percent);
  }
  else
    if (_numcarat == 2)
    {
      TString16 dep(datapag.string(brief));  
      real quotepag198 = ZERO;
      set_row (i, "@89g%8s",    (const char*) dep);
      set_row (i, "@97g%12r", &imponpag);
      TString16 app (percent.left(4)); 
      app.ltrim();
      set_row (i, "@110g%s", (const char*)app);
      set_row (i, "@115g%12r", &ritenpag);
      set_row (i, "@127g%12r", &compenpag);
// 23.11.95 
// Nella stampa a 198 una colonna sola comprendente quote e spese non soggette 
      quotepag198 = compenpag - imponpag + spesepag; 
      set_row (i, "@139g%12r", &quotepag198);
    }
  return i;
} 

void TStampa_perc::setta_righe_versamenti(char luovers,char tipovers, TDate& dataver,
                                          const TString& serie,const TString& numero,
                                          const real& impvers,int j)
{
  if (_numcarat == 1)
  {
    set_row (j, "@84g%c",      luovers);    
    set_row (j, "@87g%c",      tipovers);
    set_row (j, "@91g%10s",    (const char*) dataver.string());
    set_row (j, "@102g%s",     (const char*) serie);
    set_row (j, "@108g%s",     (const char*) numero);
    set_row (j, "@120g%12r", &impvers);
  }
  else
    if (_numcarat == 2)
    {
      set_row (j, "@155g%c",     luovers);    
      set_row (j, "@157g%c",     tipovers);
      TString16 dep(dataver.string(brief));
      set_row (j, "@159g%8s",   (const char*) dep);
      set_row (j, "@168g%5s",   (const char*) serie);
      set_row (j, "@174g%-11s",  (const char*)numero);
      set_row (j, "@186g%12r",  &impvers);
    }
}
     
int TStampa_perc::setta_righe_versamenti_modulo(char luovers,char tipovers,TDate& dataver,
                                                const TString& serie,const TString& numero,
                                                const real& impvers,int j)
{
  if (_numcarat == 1)
  {     
    j += 2;
    set_row (j, "@80g%c",      luovers);    
    set_row (j, "@84g%c",      tipovers);         
    set_row (j, "@87g%10s",    (const char*) dataver.string());
  }
  else
    if (_numcarat == 2)
    {
      set_row (j, "@155g%c",     luovers);    
      set_row (j, "@157g%c",     tipovers);
      TString dep(dataver.string(brief));
      set_row (j, "@159g%8s",   (const char*) dep);
      set_row (j, "@168g%5s",    serie);
      set_row (j, "@174g%11s",    numero);
      set_row (j, "@186g%12r", &impvers);
    }
  return j;
}

int TStampa_perc::stampa_vers(TVersamento_stampa& ve, int nriga, const int numvers, const real& ritenpag)
{  
  TString16 serie, numero;
  int j = nriga;
  real  vers_stampa = ZERO;
    
  _rver->setkey(1);
  _rver->zero();
  _rver->put(SPR_CODDITTA,   _codditta);
  _rver->put(SPR_TIPOA,      _tipoa);
  _rver->put(SPR_CODANAGR,   _codanagPE);
  _rver->put(SPR_NPROG,      _nprog);
  _rver->put(VER_NRIGA,      numvers);
    
  if (_rver->read(_isequal) == NOERR)
  {    
    char    luovers  = _rver->get(VER_LUOVERS)[0];
    char    tipovers = _rver->get(VER_TIPOVERS)[0];
    TDate   dataver(_rver->get_date(VER_DATAVERS));
    serie    = _rver->get(VER_SERIE);      
    numero   = _rver->get(VER_NUMERO);
    real impvers  = _rver->get_real(VER_IMPVERS);

    ve.set(_codditta, _tipoa, _codanagPE, _nprog, numvers, impvers);

    const bool gia_visto = find(ve);
          
    if (gia_visto)
    {
      real vvee = ve.importo_versato_residuo();
      impvers = vvee;
    }

    vers_stampa = ve.vers_stampa(_rpag, numvers, impvers, ritenpag);

    if (_numcarat == 1 && !_stampa_modulo)
      if (j == 3)
      {
        set_row (j++, "@83gEstremi versamento@102gSerie@108gNumero");
        set_row (j++, "@83gTC DCB@91gData@102gABI@108gCAB@121gImp.versato");
      }

    if (_stampa_modulo)
      j = setta_righe_versamenti_modulo(luovers,tipovers,dataver,serie,numero,vers_stampa,j);
    else
      setta_righe_versamenti(luovers,tipovers,dataver,serie,numero,vers_stampa,j);
      
    j += _stampa_modulo ? 2 : 1;
  }
  return j;
}

void calcola_non_pagate(TSchedaP& sch, real& compensi_non_pagati, 
  real& spese_non_pagate, const int anno_in_corso)
{
  real  comp, spese;
  real  comp_doc, spese_doc, comp_pagato, spese_pagate;
  TDate data_pag;
  int anno_pag;
  
  comp = spese = ZERO;
  TLocalisamfile* rpag  = new TLocalisamfile(LF_RPAG);
  sch.read();             
//  anno_doc  = sch.anno_doc();
  comp_doc  = sch.compenso_doc();
  spese_doc = sch.spese_doc();
    
  rpag->zero();
  rpag->put(PAG_CODDITTA, sch.codditta());
  rpag->put(PAG_TIPOA,    sch.tipoa());   
  rpag->put(PAG_CODANAGR, sch.codanagr());
  rpag->put(PAG_NPROG,    sch.nprog()); 
  TRectype mst(rpag->curr()); 
  for (rpag->read(_isgteq); !rpag->eof(); rpag->next())
  {
    if (rpag->curr() > mst) break;
    comp_pagato  = rpag->get_real(PAG_COMPENSO);       
    spese_pagate = rpag->get_real(PAG_SPESA);
    data_pag   = rpag->get_date(PAG_DATAPAG);
    anno_pag   = data_pag.year();
    if (anno_pag <= anno_in_corso)
    {
      comp_doc  -= comp_pagato;
      spese_doc -= spese_pagate;
    }
  } 
  compensi_non_pagati = comp_doc;
  spese_non_pagate    = spese_doc;
}

bool TStampa_perc::preprocess_page(int file, int counter)
{      
  TString16 datapag,dataver;        
  TString16 codqua;
  real    imponpag,ritenpag,compenpag,spesepag,quotepag;  
  int     i, rigaver, numvers, anno_doc;
  bool pagato_anno_in_corso = FALSE;
  
  if (counter)
    return TRUE;

  if (!_stampa_modulo)
  {
    if (_numcarat == 1)
      i = rigaver = 3;
    else
      if (_numcarat == 2)
        i = rigaver = 1;
  }
  else
    i = rigaver = 1;
    
  if (file == LF_SCPERC)
  {
    reset_print();  
    TRectype sch_curr(current_cursor()->curr(LF_SCPERC));      
    _tipoa     = current_cursor()->curr(LF_SCPERC).get     (SPR_TIPOA)[0];
    _codanagPE = current_cursor()->curr(LF_SCPERC).get_long(SPR_CODANAGR);
    _nprog     = current_cursor()->curr(LF_SCPERC).get_int(SPR_NPROG); 
    _codcaus   = current_cursor()->curr(LF_SCPERC).get_int (SPR_CODCAUS);  
    _codtrib   = ricerca_causale(_desc_cau,codqua);
    _datadoc   = current_cursor()->curr(LF_SCPERC).get_date(SPR_DATADOC);
    _numdoc    = current_cursor()->curr(LF_SCPERC).get     (SPR_NUMDOC);
    _impondoc  = current_cursor()->curr(LF_SCPERC).get_real(SPR_COMPENSO);
    _spesedoc  = current_cursor()->curr(LF_SCPERC).get_real(SPR_SPESE);
    _imposdoc  = current_cursor()->curr(LF_SCPERC).get_real(SPR_IVA);
    _totaledoc = current_cursor()->curr(LF_SCPERC).get_real(SPR_TOTALE);
    _mesecomp  = current_cursor()->curr(LF_SCPERC).get_int (SPR_MESEC);
    _annocomp  = current_cursor()->curr(LF_SCPERC).get_int (SPR_ANNOC);

    anno_doc = _datadoc.year();

    _compenso_dovuto = _impondoc;
    _spese_dovute    = _spesedoc;
        
    TSchedaP scheda(sch_curr);
    bool esiste_pag_anno_in_corso = esiste_pag_in_anno(scheda, _anno_dic);
    _stampa_scheda = anno_doc <= _anno_dic && esiste_pag_anno_in_corso;

    TSchedaP sch_corr(_codditta, _tipoa, _codanagPE, _nprog);
    
    if (_stampa_scheda)
    {
      _tot_fatt  += _totaledoc;
      
      if (_stampa_modulo)
        setta_righe_documento_modulo();
      else  
        setta_righe_documento();

      _almeno_una_scheda = TRUE;
    }

    if (_rifai_sort)                        
    {
      init_sort();
      _rifai_sort = FALSE;
    }
        
    TRectype recpag(_rpag->curr());
    recpag.zero();
    recpag.put(SPR_CODDITTA,   _codditta);
    recpag.put(SPR_TIPOA,      _tipoa);
    recpag.put(SPR_CODANAGR,   _codanagPE);
    recpag.put(SPR_NPROG,      _nprog);
    
    _rpag->setkey(1);
    _rpag->zero();
    _rpag->curr() = recpag;

    TDate datapag;  
    TVersamento_stampa ve;
    bool aggiorna_totali = FALSE;
    for (_rpag->read(_isgteq); _rpag->good(); _rpag->next())
    {
      if (_rpag->curr() > recpag) 
        break;

      datapag = _rpag->get_date(PAG_DATAPAG);
      const int anno_pag = datapag.year();

      compenpag   = _rpag->get_real(PAG_COMPENSO);
      spesepag    = _rpag->get_real(PAG_SPESA);

// Aggiorna i tot. per questa scheda
      if (anno_pag <= _anno_dic)
      {
        _compenso_dovuto -= compenpag;
        _spese_dovute    -= spesepag;
        aggiorna_totali = TRUE;
      }
      
// 28.11.95 Se sono di anni precedenti non li stampo
// (v. prospetto di Omero)
// 10.1.96 pero' sommo compenso e spese nei non pagati
      if (anno_pag < _anno_dic)
        continue;

// Non devo stampare nulla, si resta nel ciclo solo per aggiornare i totali
      if (!_stampa_scheda)
        continue;                                                          
        
      pagato_anno_in_corso = anno_pag == _anno_dic;

      imponpag    = _rpag->get_real(PAG_IMPONIBILE);
      real r_perc;
      r_perc = _rpag->get_real(PAG_PERC);
      TString16 st_perc(r_perc.string("###,@@"));      
      ritenpag    = _rpag->get_real(PAG_RITENUTA);
      quotepag = compenpag - imponpag; 
      numvers     = _rpag->get_int(PAG_NUMVERS);       
      
// 27.11.95 se l'anno e' successivo deve restare nei NON pagati
// e non si stampa
      if (pagato_anno_in_corso)  
      { 
        if (_numcarat == 1 && !_stampa_modulo)
          if (i == 3)
          {
            set_row (i++, "Data@54gSpese@67gQuote");
            set_row (i++, "Pagamento@13gImponibili@27g%%@32gRitenute@45gCompensi@54gnon soggette@67gnon soggette");
          } 

        if (_stampa_modulo)
          i = setta_righe_pagamenti_modulo(datapag,imponpag,st_perc,ritenpag,compenpag,spesepag,quotepag,i);       
        else
          setta_righe_pagamenti(datapag,imponpag,st_perc,ritenpag,compenpag,spesepag,quotepag,i);

        i += _stampa_modulo ? 2 : 1;        
        do_sort(codqua,_codtrib,r_perc,spesepag,quotepag,imponpag,ritenpag,compenpag);

        if (numvers > 0) 
          rigaver = stampa_vers(ve, rigaver, numvers, ritenpag);
      } 
    }  // for (rpag.. legge pagamento successivo

// Aggiorna i totali delle spese e comp. ancora da pagare
    if (aggiorna_totali)
    {
      _tot_comp_non_pagati    += _compenso_dovuto;
      _tot_somme_non_soggette += _spese_dovute;
    }    

// Determina se questa e' l'ultima scheda di questo percipiente    
    current_cursor()->save_status();
    ++(*current_cursor());
    char tipoa   = current_cursor()->curr(LF_SCPERC).get_char(SPR_TIPOA);
    long codanag = current_cursor()->curr(LF_SCPERC).get_long(SPR_CODANAGR);  
    --(*current_cursor());
    current_cursor()->restore_status();

// Se e' l'ultima chiude il sort (cioe' il riepilogo)    
    if (_tipoa != tipoa || _codanagPE != codanag) 
      _sort->endsort();  
  }
  return TRUE;
}

real TStampa_perc::fatture()
{
  TLocalisamfile perc (LF_PERC);
  real fatt_bil;
  
  fatt_bil = ZERO;
  
  perc.setkey(1);
  perc.zero();
  perc.put(PRC_CODDITTA, _codditta);
  perc.put(PRC_TIPOA,    _tipoa);
  perc.put(PRC_CODANAGR, _codanagPE);
  if (perc.read() == NOERR)
    fatt_bil = perc.get_real(PRC_FATTBIL);
  
  return fatt_bil;
}

print_action TStampa_perc::postprocess_page(int file, int counter)
{                                                                      
  char   tipoa;
  long   codanag;
  bool   intesta_sort = TRUE;
  
  if (counter)
  {
    printer().formfeed();
    reset_print();     // per evitare che stampi di nuovo il totale prec.  
// 7.12.95 Riparto da pag.1 con un nuovo percipiente
    if (_changed_perc)
    {
      printer().setcurrentpage(1);
      _changed_perc = FALSE;
    }
    return NEXT_PAGE;
  }
  
  if (file == LF_SCPERC)
  { 
    if (!_stampa_scheda && !_almeno_una_scheda)
      return NEXT_PAGE;
      
    current_cursor()->save_status();
    ++(*current_cursor());
    tipoa   = current_cursor()->curr(LF_SCPERC).get_char(SPR_TIPOA);
    codanag = current_cursor()->curr(LF_SCPERC).get_long(SPR_CODANAGR);  
    --(*current_cursor());
    current_cursor()->restore_status();
    _changed_perc = _tipoa != tipoa || _codanagPE != codanag;

    if (_changed_perc) 
    {     
      TString16 codqua,codqua_t;
      int     codcau,codcau_t;
      real    totale,somme,quote,imp,rit,netto;
      real    totale_t,somme_t,quote_t,imp_t,rit_t,netto_t;
      TString key(20),keyp(20); 
      real    perc,perc_t;
      
      _almeno_una_scheda = FALSE;     
      reset_print();
      if (_tot_fatt != ZERO)
      {
        set_row (2, "@62gTotale fatturato@79g%12.0r", &_tot_fatt);
        set_row (2, "@93gComprensivo d'iva");
        _ind = 4;
      }
      else
//        _ind = 2;
        _ind = 3;
        
      struct righe_pag* bil = (struct righe_pag*) _buf; 
                                 
      _buf = _sort->retrieve();

      int righe_libbere = printer().rows_left();      

      if (_buf != NULL)
      {                                 
        do  
        {           
          bil = (struct righe_pag*) _buf;
          codqua = bil->codq;
          codcau = atoi(bil->codc);
          real dumb;
          const char* eng_perc = dumb.ita2eng(bil->perc);
          const double ppp = atof(eng_perc);
          perc   = ppp;
          totale = bil->totale;
          somme  = bil->somme;
          quote  = bil->quote;
          imp    = bil->imp;
          rit    = bil->rit;
          netto  = bil->netto;

          TString16 st_perc(perc.string("###,@@"));          
          if (!intesta_sort)
            key.format("%2s%4d%s", (const char*) codqua,codcau,(const char*)st_perc);
                        
          if (intesta_sort)
          {
            intestazione_riepilogo();
            righe_libbere -= 6;
            intesta_sort = FALSE;
            key.format("%2s%4d%s", (const char*) codqua,codcau,(const char*)st_perc);
            keyp.format("%2s%4d%s", (const char*) codqua,codcau,(const char*)st_perc);
          }
          
          if (key == keyp)
          {
            codqua_t = codqua;
            codcau_t = codcau;
            perc_t   = perc;
            totale_t += totale;
            somme_t  += somme;
            quote_t  += quote;
            imp_t    += imp;
            rit_t    += rit;
            netto_t  += netto;
          }
          else
          { 
            if (righe_libbere <= 1)
            {
              intestazione_riepilogo();
              righe_libbere = printer().formlen() - printer().headersize();
            }
            set_row (_ind, "%2s",        (const char*) codqua_t);
            set_row (_ind, "@4g%4d",     codcau_t);
            TString16 st_perc_t(perc_t.string("###,@@"));          
            set_row (_ind, "@10g%s", (const char*) st_perc_t);
            set_row (_ind, "@17g%12r", &totale_t);
            set_row (_ind, "@31g%12r", &somme_t);
            set_row (_ind, "@47g%12r", &quote_t);
            set_row (_ind, "@63g%12r", &imp_t);
            set_row (_ind, "@79g%12r", &rit_t);
            set_row (_ind, "@94g%12r", &netto_t);
            _ind++;           
            righe_libbere--;
            codqua_t = codqua;
            codcau_t = codcau;
            perc_t   = perc;
            totale_t = totale;
            somme_t  = somme;
            quote_t  = quote;
            imp_t    = imp;
            rit_t    = rit;
            netto_t  = netto;
          }
          keyp = key;
          _buf = _sort->retrieve();
        }
        while ( _buf != NULL);
      }
      
      set_row (_ind, "%2s",        (const char*) codqua_t);
      set_row (_ind, "@4g%4d",     codcau_t);
      TString16 st_perc_t(perc_t.string("###,@@"));          
      set_row (_ind, "@10g%s", (const char*)st_perc_t);
      set_row (_ind, "@17g%12r", &totale_t);
      set_row (_ind, "@31g%12r", &somme_t);
      set_row (_ind, "@47g%12r", &quote_t);
      set_row (_ind, "@63g%12r", &imp_t);
      set_row (_ind, "@79g%12r", &rit_t);
      set_row (_ind, "@94g%12r", &netto_t);
      _ind++;
// Prospetto delle sommee **NON PAGATE**      
//      _tot_comp_non_pagati     = _tot_comp_testata  - _tot_comp_pagati;
//      _tot_somme_non_soggette  = _tot_spese_testata - _tot_spese_pagate;
      
      real fatt_bil, totale_non_pagate;
      
      fatt_bil           = fatture();
      totale_non_pagate  = _tot_comp_non_pagati + _tot_somme_non_soggette;
      
      set_row (_ind++, "");
      
      if (fatt_bil != ZERO)
      {                                                                           
        set_row (_ind++, "***************************");
        set_row (_ind++, "*** FATTURE DA RICEVERE ***@30g%12.0r", &fatt_bil);
        set_row (_ind++, "***************************");
        set_row (_ind++, "");
      }
      
      set_row (_ind++, "**************       Compensi@42g%12.0r@56g+",           &_tot_comp_non_pagati);
      set_row (_ind++, "* NON PAGATE *       Somme non soggette@42g%12.0r@56g=", &_tot_somme_non_soggette);
      set_row (_ind++, "**************@42g----------------");
      set_row (_ind  , "                     Totale@42g%12.0r", &totale_non_pagate);
      
      _rifai_sort   = TRUE;
      _tot_comp     = ZERO;
      _tot_fatt     = ZERO;
      _tot_somme_non_soggette = _tot_comp_non_pagati = ZERO;
      
      return REPEAT_PAGE;
    }
  }
  return NEXT_PAGE;
}

void TStampa_perc::intestazione_riepilogo(const bool redo_header, const int start_riga)
{              
  TString sep(110);
  if (redo_header)
  {
    int ind = start_riga;
    sep.fill('_');
    set_header (ind++, (const char*) sep);
    set_header (ind++, "Q@4gCod.@31gSomme@47gQuote@95gNetto");
    set_header (ind++, "D@4gCaus.@13g%%@23gTotale@31gnon soggette@47gnon soggette@65gImponibili@83gRitenute@95gcorrisposto");
    set_header (ind++, (const char*) sep);
  }
  else
  {
    sep.fill('_');
    set_row (_ind++, (const char*) sep);
    set_row (_ind++, "Q@4gCod.@31gSomme@47gQuote@95gNetto");
    set_row (_ind++, "D@4gCaus.@13g%%@23gTotale@31gnon soggette@47gnon soggette@65gImponibili@83gRitenute@95gcorrisposto");
    set_row (_ind++, (const char*) sep);
  }
}                                

void TStampa_perc::on_config_change()
{ 
  TConfig conf(_liv == 'S' ? CONFIG_USER : CONFIG_STUDIO);
  _anno_dic = (int)conf.get_long(ANNO_SEL, _section); 
}

bool TStampa_perc::init_print()
{
  KEY tasto;
  TLocalisamfile* fl;    
  TMask msk ("772100a");

  _changed_perc = FALSE;
  printer().footerlen(RIGHE_FOOTER);
  msk.set_handler (F_CODDITTA, codditta_hnd);
      
  tasto = msk.run();

  if (tasto == K_ENTER)
  {
    char tipoa_da  = msk.get(F_TIPODA)[0];
    long cod_da    = msk.get_long(F_CODDA);
    char tipoa_a   = msk.get(F_TIPOA)[0];
    long cod_a     = msk.get_long(F_CODA);   
               
    _numcarat      = msk.get_int (F_CARATTERE);
    _stampa_modulo = msk.get_bool(F_MODULO);
    
//Crea il cursore su gruppo, conto e sottoconto del file RMOV
    reset_files();         //resetta l'albero di stampa
    add_file(LF_SCPERC);
 
    fl = &(current_cursor()->file(LF_SCPERC));
    TRectype da (fl->curr());
    TRectype a  (fl->curr());  

    da.zero();
    a.zero();
     
    da.put(SPR_CODDITTA, _codditta);        
    da.put(SPR_TIPOA,    tipoa_da);
    da.put(SPR_CODANAGR, cod_da);

    a.put(SPR_CODDITTA,  _codditta);        
    a.put(SPR_TIPOA,     tipoa_a);
    a.put(SPR_CODANAGR,  cod_a);

    current_cursor()->setregion(da, a);
                        
    _anno = _anno_dic;
    
    dati_erogante();
    _rifai_sort = TRUE;
  }                                   
  return tasto == K_ENTER;
}

bool TStampa_perc::set_print(int)
{
  long  codditta_prec;
  int   i = 0;

  if (_liv == 'S')
  {
    codditta_prec = get_firm_770();
    while ((_codditta = _cnf->get_long(DITTE_SEL, _section, i++)) != 0L) 
    {
      set_firm_770(_codditta);
// init_print ritorna TRUE solo se K_ENTER      
      if (init_print())
        print();
      else
        break;  
    }  
    set_firm_770(codditta_prec);
// Non richiamare di nuovo print()!    
    return FALSE;
  }
  else
    return init_print();
}

void TStampa_perc::preprocess_header()
{ 
  int riga;
  dati_percipiente();
  riga = stampa_dati_erog_perc();
}  

void TStampa_perc::dati_erogante()
{ 
  TString com,comnasc;           
  TDate   data;
       
  _nditte->setkey(1);
  _nditte->curr().zero();
  _nditte->curr().put(NDT_CODDITTA, _codditta);
  if (_nditte->read() == NOERR)
  {
    _tipoaER   = _nditte->get_char(NDT_TIPOA);
    _codanagER = _nditte->get_long(NDT_CODANAGR);
  }
 
  _anag->setkey(1);
  _anag->zero();
  _anag->put(ANA_TIPOA,    _tipoaER);
  _anag->put(ANA_CODANAGR, _codanagER);
  if (_anag->read() == NOERR)
  {  
    _ragsocER = _anag->get(ANA_RAGSOC);
    _cofiER   = _anag->get(ANA_COFI);
    
    if (_tipoaER == 'F')
    {
      TString80 nome = _ragsocER.mid(30);
      _ragsocER.cut(30);
      _ragsocER.trim(); nome.trim();
      _ragsocER << ' ' << nome;
    }
    
    com = _anag->get(ANA_COMRF);
    
    if (com != "")
    {
      _indER = _anag->get(ANA_INDRF);
      _civER = _anag->get(ANA_CIVRF);
      _capER = _anag->get(ANA_CAPRF);
    }
    else
    {
      _indER = _anag->get(ANA_INDRES);
      _civER = _anag->get(ANA_CIVRES);
      _capER = _anag->get(ANA_CAPRES);
      com    = _anag->get(ANA_COMRES);
    }
  }
   
  _comuni->setkey(1);
  _comuni->zero();
  _comuni->put(COM_COM,com);
  if (_comuni->read() == NOERR)
  {
    _dencomER = _comuni->get(COM_DENCOM);
    _provER   = _comuni->get(COM_PROVCOM);
  }
  
  if (_tipoaER == 'F')
  {
    TLocalisamfile anagfis(LF_ANAGFIS);
    
    anagfis.setkey(1);
    anagfis.zero();
    anagfis.put(ANF_CODANAGR, _codanagER);
    if (anagfis.read() == NOERR)
    {
      data = anagfis.get_date(ANF_DATANASC);
      _datanascER = data.string();
      comnasc   = anagfis.get     (ANF_COMNASC);
    }
    
    _comuni->setkey(1);
    _comuni->zero();
    _comuni->put(COM_COM,comnasc);
    if (_comuni->read() == NOERR)
    {
      _dencomnscER = _comuni->get(COM_DENCOM);
      _provnscER   = _comuni->get(COM_PROVCOM);
    }               
    _dencomnscER.rtrim();
    _provnscER.rtrim();
  }
  else
  {
    _dencomnscER = "";
    _provnscER   = "";
  }
  _indER.rtrim();
  _dencomER.rtrim();
}

void TStampa_perc::dati_percipiente()
{ 
  TString com; 
  TDate   data;  
  TString comnasc;
                 
  _anag->setkey(1);
  _anag->zero();
  _anag->put(ANA_TIPOA,    _tipoa);
  _anag->put(ANA_CODANAGR, _codanagPE);
  if (_anag->read() == NOERR)
  {  
    _ragsocPE = _anag->get(ANA_RAGSOC);
    _cofiPE   = _anag->get(ANA_COFI);
    
    if (_tipoa == 'F')
    {
      TString80 nome = _ragsocPE.mid(30);
      _ragsocPE.cut(30);
      _ragsocPE.trim(); nome.trim();
      _ragsocPE << ' ' << nome;
    }
    
    com = _anag->get(ANA_COMRF);
    
    if (com != "")
    {
      _indPE = _anag->get(ANA_INDRF);
      _civPE = _anag->get(ANA_CIVRF);
      _capPE = _anag->get(ANA_CAPRF);
    }
    else
    {
      _indPE = _anag->get(ANA_INDRES);
      _civPE = _anag->get(ANA_CIVRES);
      _capPE = _anag->get(ANA_CAPRES);
      com    = _anag->get(ANA_COMRES);
    }
  }
 
  _comuni->setkey(1);
  _comuni->zero();
  _comuni->put(COM_COM,com);
  if (_comuni->read() == NOERR)
  {
    _dencomPE = _comuni->get(COM_DENCOM);
    _provPE   = _comuni->get(COM_PROVCOM);
  }
  
  if (_tipoa == 'F')
  {
    TLocalisamfile anagfis(LF_ANAGFIS);
    
    anagfis.setkey(1);
    anagfis.zero();
    anagfis.put(ANF_CODANAGR, _codanagPE);
    if (anagfis.read() == NOERR)
    {
      data = anagfis.get_date(ANF_DATANASC);
      _datanascPE = data.string();
      comnasc   = anagfis.get     (ANF_COMNASC);
    }
    
    _comuni->setkey(1);
    _comuni->zero();
    _comuni->put(COM_COM,comnasc);
    if (_comuni->read() == NOERR)
    {
      _dencomnscPE = _comuni->get(COM_DENCOM);
      _provnscPE   = _comuni->get(COM_PROVCOM);
    }                  
    _dencomnscPE.rtrim();
    _provnscPE.rtrim();
  }
  else
  {
    _dencomnscPE = "";
    _provnscPE   = "";
  }              
  _indPE.rtrim();
  _dencomPE.rtrim();
}

int TStampa_perc::stampa_dati_erog_perc()
{ 
  int riga, riga2;  
  TString sep(200);

  reset_header();

  // Dati del soggetto erogante
  if (_stampa_modulo)
  {
    riga = 7;
    set_header (riga, "@12g%4d", _anno);    
    sep << "@#";
    sep.right_just(105); 
    set_header(riga,(const char*) sep);
    riga += 4; // da 7 a 11
    set_header (riga, "@10g%s",  (const char*) _ragsocER);
    riga += 3;
    set_header (riga++, "@10g%s %s", (const char*) _indER, (const char*) _civER);
    set_header (riga, "@10g%5s", (const char*) _capER);
    set_header (riga++, "@17g%s %s", (const char*) _dencomER, (const char*) _provER);
    set_header (riga++, "@10gxxx");
    set_header (riga++, "@10g%-16s", (const char*) _cofiER);
  }
  else
  {
// 7.12.95 Numeri di pagina qui!  
    riga = 1;
    set_header (riga++, _numcarat == 1 ? "SOGGETTO EROGANTE @122gPag. @#" : "SOGGETTO EROGANTE @188gPag. @#"); 
    set_header (riga++, "Codice@15g%5d", _codditta);
    set_header (riga++, "Denominazione@15g%s",  (const char*) _ragsocER);
    set_header (riga++, "Domicilio in@15g%s %s", (const char*) _indER, (const char*) _civER);
    set_header (riga,   "@15g%5s",               (const char*) _capER);
    set_header (riga++, "@21g%s %s",            (const char*) _dencomER, (const char*) _provER);
    set_header (riga++, "Codice fiscale@15g%-16s",(const char*) _cofiER);
    if (_tipoaER == 'F')
      set_header (riga++, "Luogo data di nascita@22g%s %s %10s", (const char*) _dencomnscER, (const char*) _provnscER, (const char*) _datanascER);
  }
  
// Dati del soggetto percipiente 
  if (_stampa_modulo)
  {
    set_header (11, "@65g%s",  (const char*) _ragsocPE);
    set_header (14, "@65g%s %s", (const char*) _indPE, (const char*) _civPE);
    set_header (15, "@65g%5s",                  (const char*) _capPE);
    set_header (15, "@72g%s %s",               (const char*) _dencomPE, (const char*) _provPE);
    set_header (17, "@65g%-16s",(const char*) _cofiPE); 
    set_header (23, "");
  }
  else
  {
    if (_numcarat == 1)
    {
      riga2 = 1;
      set_header (riga2++, "@66gSOGGETTO PERCIPIENTE"); 
      set_header (riga2++, "@66gCodice@81g%c %5d", _tipoa, _codanagPE);
      set_header (riga2++, "@66gDenominazione@81g%s",  (const char*) _ragsocPE);
      set_header (riga2++, "@66gDomicilio in@81g%s %s", (const char*) _indPE, (const char*) _civPE);
      set_header (riga2, "@81g%5s",                  (const char*) _capPE);
      set_header (riga2++, "@87g%s %s",               (const char*) _dencomPE, (const char*) _provPE);
      set_header (riga2++, "@66gCodice fiscale@81g%-16s",(const char*) _cofiPE); 
      if (_tipoa == 'F')
        set_header (riga2++, "@66gLuogo data di nascita@88g%s %s %s", (const char*) _dencomnscPE, (const char*) _provnscPE, (const char*) _datanascPE);
      else
        riga2++;
      set_header (riga2++, "Conto individuale percipiente anno %4d", _anno);
      TString app(132);
      app.fill('_');
      set_header(riga2++, (const char*) app);
    }                                             
    else
      if (_numcarat == 2)
      {                                 
        TString app(198);
        app.fill('_');
        riga2=1;        
        set_header (riga2++, "@110gSOGGETTO PERCIPIENTE"); 
        set_header (riga2++, "@110gCodice@125g%c %5d", _tipoa, _codanagPE);
        set_header (riga2++, "@110gDenominazione@125g%s",  (const char*) _ragsocPE);
        set_header (riga2++, "@110gDomicilio in@125g%s %s", (const char*) _indPE, (const char*) _civPE);
        set_header (riga2 /*5*/, "@125g%5s",                  (const char*) _capPE);
        set_header (riga2++ /*5*/, "@131g%s %s",               (const char*) _dencomPE, (const char*) _provPE);
        set_header (riga2++, "@110gCodice fiscale@125g%-16s",(const char*) _cofiPE); 
        if (_tipoa == 'F')
          set_header (riga2++, "@110gLuogo data di nascita@132g%s %s %s", (const char*) _dencomnscPE, (const char*) _provnscPE, (const char*) _datanascPE);
        else
          riga2++;           
        set_header (riga2++, "Conto individuale percipiente anno %4d", _anno);                                  
        set_header (riga2++, (const char*) app);
        set_header (riga2++, "@50gESTREMI DOCUMENTO @101gESTREMI PAGAMENTO @145gSomme e@157gD@165gESTREMI VERSAMENTO");
        set_header (riga2++, "Cod.@80gTotale@90gData@145gquote@155gT@157gC@168gSerie@174gNumero");
        set_header (riga2 /*13*/, "Caus.@8gDescrizione@24gData@33gNumero@43gImponibili@60gSpese@70gImposte@80gDocumento@90gPagamento@101gImponibili@115g%%@122gRitenute");
        set_header (riga2++ /*13*/, "@134gCompensi@145gnon sogg.@155gC@157gB@159gData@168gABI @174gCAB @183gImporto versato");
        set_header (riga2++, (const char*) app);
      }
  }
// ritorna la prima riga libera  
  return riga > riga2 ? riga : riga2;
}

/*
// Crea l'intestazione per la stampa a 132 e a 198 caratteri
void TStampa_perc::intesta_fissa()
{ 
  set_background();
  if (_numcarat == 1)
    set_background("W4l{1 10 132 10}");
  else if (_numcarat == 2)
         set_background("W4l{1 10 198 10} W4l{1 13 198 13}");
}
*/          

bool TStampa_perc::user_create()
{
  TToken_string exp;

// Parametri configurazione
  _section = name(); 
  _section.cut(2); 
  _cnf = new TConfig(CONFIG_USER, _section);
  _rel    = new TRelation (LF_SCPERC);
  _cur    = new TCursor(_rel,"",2);
  add_cursor(_cur);
  
  _nditte = new TLocalisamfile (LF_NDITTE);
  _comuni = new TLocalisamfile (LF_COMUNI);
  _anag   = new TLocalisamfile (LF_ANAG);
  _rpag   = new TLocalisamfile (LF_RPAG);
  _rver   = new TLocalisamfile (LF_RVER);
  _bil    = new righe_pag;
  _sort   = new TSort();

  _codditta = get_firm_770();

  return TRUE;
}

bool TStampa_perc::user_destroy()
{
  delete _rel;   
  delete _cur;
  delete _nditte;
  delete _anag;
  delete _comuni;
  delete _rpag;
  delete _rver;
  delete _bil;
  delete _sort;
  delete _cnf;

  return TRUE;
}

int m72100(int argc, char* argv[])
{
  TStampa_perc a(*argv[2]);
  a.run(argc, argv, "Stampa schede percipienti");
  return 0;
}
