#include <mask.h>
#include <printapp.h>
#include <progind.h>
#include <recarray.h>
#include <sort.h>
#include <tabutil.h>
#include <utility.h>

#include <causali.h>
#include <comuni.h>
#include <nditte.h>
#include <unloc.h>
#include <clifo.h>
#include <pconti.h>
#include <anagr.h>
#include <rmov.h>
#include <mov.h>
#include <saldi.h>

#include "cg1.h"
#include "cg1600.h"
#include "cglib.h"


class TRiga_sez_opp : public TObject
{
  TToken_string* _str;

public:
  int gruppo() const { return _str->get_int(0); }
  int conto() const { return _str->get_int(1); }
  long sottoc() const { return _str->get_long(2); }
  const char * sezione () { return _str->get(3); }
  const char * lettera () { return _str->get(4); }
  const char * num_rom () { return _str->get(5); }
  const char * numero () const { return _str->get(6); } 
  real saldo_conto () const {	return _str->get_real(7); }
  real saldo_conto_raf() const { return _str->get_real(8); }
  void incrementa_saldo(real& nuovo_saldo,real& nuovo_saldo_raf);
  TRiga_sez_opp(int g, int c, long s,
                const char * sezione, const char * lettera,
                const char * num_rom, const char * num, real& saldo, real& saldo_raf);
  virtual ~TRiga_sez_opp();
};

void TRiga_sez_opp::incrementa_saldo(real& sld,real& sld_raf) 
{
  real sld_prec     = saldo_conto();
  real sld_prec_raf = saldo_conto_raf();

	sld_prec     += sld;
  sld_prec_raf += sld_raf;
  _str->add(sld_prec.string(), 7); 
  _str->add(sld_prec_raf.string(), 8);
}

TRiga_sez_opp::TRiga_sez_opp(int g, int c, long s,
                             const char * sezione, const char * lettera,
                             const char * num_rom, const char * num, real& saldo, real& saldo_raf)
{
  _str = new TToken_string(30);
  _str->add(g); 
  _str->add(c); 
  _str->add(s);
  _str->add(sezione);
  _str->add(lettera);
  _str->add(num_rom);
  _str->add(num);
  _str->add(saldo.string());   
  _str->add(saldo_raf.string());
}

TRiga_sez_opp::~TRiga_sez_opp()
{
  delete _str;
}

class Righe_sez_opp : public TAssoc_array
{
public:
  TRiga_sez_opp* riga() { return (TRiga_sez_opp*) get(); }
  int gruppo() { return riga()->gruppo(); }
  int conto() { return riga()->conto(); }
  long sottoc() { return riga()->sottoc(); }
  const char * sezione () { return riga()->sezione(); }
  const char * lettera () { return riga()->lettera(); }
  const char * num_rom () { return riga()->num_rom(); }
  const char * numero () { return riga()->numero(); } 
  real saldo_conto () { return riga()->saldo_conto(); }
  real saldo_conto_raf () { return riga()->saldo_conto_raf(); }
  
  void  add (int g, int c, long s, 
             const char * sezione, const char * lettera,
             const char * num_rom, const char * num, real saldo, real saldo_raf);
};

void Righe_sez_opp::add(int g, int c, long s,
                        const char * sezione, const char * lettera,
                        const char * num_rom, const char * num, real saldo, real saldo_raf)
{
  TString80 key; key.format("%s%s%s%s",sezione,lettera,num_rom,num);
  
  TRiga_sez_opp* riga = (TRiga_sez_opp*)objptr(key);
  if (riga == NULL)
  {
    riga = new TRiga_sez_opp (g, c, s, sezione, lettera, num_rom, num, saldo, saldo_raf);
    TAssoc_array::add(key,riga);
  }
  else
  {
    riga->incrementa_saldo(saldo,saldo_raf);
  }
}

class TStampa_IVdirettiva : public TPrintapp
{
  static bool data_limite(TMask_field & f,KEY k);
  static bool tipo_stampa(TMask_field & f,KEY k);
  static bool data_bil_raff(TMask_field & f,KEY k);
  static bool tipo_bilancio(TMask_field & f,KEY k);  
  static bool data_inizio(TMask_field & f,KEY k);
  static bool anno_esercizio(TMask_field & f,KEY k);

  struct bil_ivd
  {
    char   sez;
    char   let;
    char   numr[5];
    char   num[7];
    char   gruppo[4];
    char   conto[4];
    char   sottoc[8];
    real   saldo;
    real   saldorafr;
    real   sld_prg_dare;
    real   sld_prg_avere;
    real   mov_dare;
    real   mov_avere;
    char   tipocf; 
    bool   conto_dettagliato;
  };

  bil_ivd*           _bil;
  TMask*             _msk;
  const char*        _buff;
  TSort*             _sort;
  Righe_sez_opp      _sezopps;
  TSaldi_list*       _listasld;
  TParagraph_string* _descr,*_d;                        
  TSaldo*            _sld; 
  bool               _noseparator;
	TTipo_data         _tipo_data;

  TDate _data_fine_es,_data_fine_ese_prec,_data_fine_raf,_data_fine_raf_prec;
  TDate _datastampa,_datalimite,_databilrafr,_datai,_datairaf;
  TDate _datainizio,_data_inizio_es,_data_inizio_raf;
  int   _annoese,_annoeserafr,_anno_esercizio,_anno_esercizio_raf;
  bool _competenza,_intera_struttura,_stampasaldizero,_stampacod,_stampa_modulo;
  bool _sbilancio_patr_gia_stampato,_attivo_o_passivo;
  bool _diffprod_fatto,_risimp_fatto;
  TString _classe_stampata, _classe_da_stampare,_numr_tot,_num_tot,_numr,_num;
  char _sez_da_stamp,_let_da_stamp,_sez_stamp,_let_stamp,_sez_tot,_let_tot,_let,_sez_saldo,_sez,_tot_sez_saldo;
  TString _numr_da_stamp,_num_da_stamp,_numr_stamp,_num_stamp,_descr_sez;
	char _sez_utile, _lett_utile;
	TString _classe_utile, _num_utile;
  int _tipo_bilancio, _tipo_stampa;
  int _cont_let,_cont_numr,_cont_num,_cont_gcs;
  int _stampa_mov_prov; 
  real _sale,_salerafr,_totale_ordine,_totale_economico;
  real _totale_ordine_raf,_totale_economico_raf;
  real _totale_numero,_totale_numr,_totale_lettera,_totale_sezione;
  real _totale_patrimoniale,_totale_attivita,_totale_passivita;
  real _totale_num_raf,_totale_numr_raf,_totale_let_raf,_totale_sez_raf;
  real _totale_patrim_raf,_totale_attiv_raf,_totale_passiv_raf;
  real _totale_ordine_attivo,_totale_ordine_passivo,_totale_ordine_attivo_raf;
  real _totale_ordine_passivo_raf;
  real _mov_periodo_dare,_mov_periodo_avere,_prg_prec_dare,_prg_prec_avere,_saldo_ini_dare,_saldo_ini_avere;
  real _sld_prg_dare,_sld_prg_avere,_mov_dare,_mov_avere;
  real _tot_num_saldo,_tot_numr_saldo,_tot_let_saldo,_tot_gen_saldo;
  real _tot_num_prg_d,_tot_numr_prg_d,_tot_let_prg_d,_tot_gen_prg_d;
  real _tot_num_prg_a,_tot_numr_prg_a,_tot_let_prg_a,_tot_gen_prg_a;
  real _tot_num_mov_d,_tot_numr_mov_d,_tot_let_mov_d,_tot_gen_mov_d;
  real _tot_num_mov_a,_tot_numr_mov_a,_tot_let_mov_a,_tot_gen_mov_a;
  real _tot_num_saldo_d,_tot_numr_saldo_d,_tot_let_saldo_d,_tot_gen_saldo_d;
  real _tot_num_saldo_a,_tot_numr_saldo_a,_tot_let_saldo_a,_tot_gen_saldo_a;
  real _totale_parziale,_totale_parziale_raf;  
  real _tot_parz_sld,_tot_parz_sld_d,_tot_parz_sld_a,_tot_parz_prg_d;
  real _tot_parz_prg_a,_tot_parz_mov_d,_tot_parz_mov_a;
  int _i;
  bool _reset_righe_stampa,_totale_attivita_gia_stampato,_totale_passivita_gia_stampato,_statopatr_no_stamp;
  bool _sbilancio_ordine, _quadratura, _prima_dopo;
  long _items_sort;

  TString tmp;  // Stringa per porcate galattiche

protected:
  virtual void on_config_change() {	_prima_dopo = ini_get_bool(CONFIG_DITTA, "cg1600", "PrimaDopoImposte");	}

public:
  int  date2esc(const TDate& d);
 // void esc2date(const int anno, TDate& d1, TDate& d2);
  
  bool menu (MENU_TAG m) { return TPrintapp::menu(m) ; }
  virtual bool user_create() ;
  virtual bool user_destroy();
  bool set_print(int);       
  
  virtual bool preprocess_page  (int,int);
  virtual print_action postprocess_page (int,int);
	virtual void postclose_print() { safe_delete(_sort); }

  virtual void set_page(int,int);

  bool preprocess_stampa_scalare(int);  
  bool preprocess_stampa_verifica(int);
  void crea_intestazione();
  void intesta_scalare();
  void intesta_verifica();
  void intesta_verifica_fissa();
  void init_sort();
  void crea_sort_tabella();
  void crea_sort_piano_conti_scalare();
  void crea_sort_piano_conti_verifica();
  void setta_righe_descr(TParagraph_string &, const char*);
  void setta_righe_descr_verifica(TParagraph_string &, const char*);
  void scrivi_record(const TString&,const TString&,const TString&, const TString&,int,int,long,const real&,const real&,const real&,const real&,const real&,const real&,char,bool conto_dettagliato = true);
  void riempi_record(const TString&,const TString&,const TString&, const TString&,int,int,long,const real&,const real&,const real&,const real&,const real&,const real&,char,bool conto_dettagliato = true);
  const TString & descrizione_ivd(char, char, int, const char *);
  void setta_righe(const char*);
  void setta_righe_verifica();     
  bool devo_stampare_risultato_prima_delle_imposte() const;
  void stampa_risultato_prima_delle_imposte();
  void stampa_totali();
  void stampa_totali_con_raffronto();
  void stampa_totali_verifica();
  bool calcola_saldo(real&, real&,int,int,long,int); 
  bool calcola(int g, int c, long s, const TDate& fine_es, const TDate& fine_es_prec, const char * filter = "");
  bool sottoc_clifo_scalare (int,int,int,int,real&,real&);
  void sottoc_clifo_verifica(int,int,int,char,TString&,TString&,TString&, TString&,int,bool);
  void stampa_saldo_132(const real&);
  void stampa_saldo_198(real&, real&);
  void set_bil_key(bil_ivd* b, char sezione, char lettera,
                   const char* numero_romano, const char * numero,
                   bool conti_ordine = true, int conto = 0,
                   int gruppo = 0, long sottoconto = 0L, char tipocf = ' ');
  void set_bil_val(bil_ivd* b, const real& saldo = ZERO, 
                   const real& saldorafr = ZERO,
                   const real& sld_prg_dare = ZERO,
                   const real& sld_prg_avere = ZERO,
                   const real& mov_dare = ZERO,
                   const real& mov_avere = ZERO,bool conto_dettagliato = true);
  TStampa_IVdirettiva() {}
};

HIDDEN inline TStampa_IVdirettiva & app() {return (TStampa_IVdirettiva&) main_app(); }

void TStampa_IVdirettiva::set_bil_key(bil_ivd* b, char sezione, char lettera,
                                     const char* numero_romano, const char * numero,
                                     bool conti_ordine, int gruppo, int conto,
                                     long sottoconto, char tipocf)

{
  b->sez = sezione;

  //Se esiste solamente la sezione,significa che e' un conto d'ordine
  //Forzo la lettera della classe a Z, per ottenere, grazie
  //all'ordinamento del sort, i record dei conti d'ordine per ultimi

  b->let = (conti_ordine && lettera == '\0' && sezione < '3') ? 'Z' : lettera;
  strcpy_s(b->numr, numero_romano);
  sprintf_s(b->num , "%-6s", numero);
  if (gruppo < 0)
  {
    strcpy_s(b->gruppo, "ZZZ");
    strcpy_s(b->conto, "ZZZ");
    strcpy_s(b->sottoc, "ZZZZZZ");
    b->tipocf = ' ';
  }
  else
    if (gruppo == 0)
    {
      strcpy_s(b->gruppo, "AAA");
      strcpy_s(b->conto, "AAA");
      strcpy_s(b->sottoc, "AAAAAA");
      b->tipocf = ' ';
    }
    else
    {
      sprintf_s(b->gruppo , "%3d", gruppo);
      sprintf_s(b->conto , "%3d", conto);
      sprintf_s(b->sottoc , "%6ld", sottoconto);
      b->tipocf = tipocf;
    }
}

void TStampa_IVdirettiva::set_bil_val(bil_ivd* b, const real& saldo, 
                                     const real& saldorafr,
                                     const real& sld_prg_dare,
                                     const real& sld_prg_avere,
                                     const real& mov_dare,
                                     const real& mov_avere,bool conto_dettagliato)
{
  b->saldo             = saldo;
  b->saldorafr         = saldorafr;
  b->sld_prg_dare      = sld_prg_dare;
  b->sld_prg_avere     = sld_prg_avere;
  b->mov_dare          = mov_dare;
  b->mov_avere         = mov_avere;                            
  b->conto_dettagliato = conto_dettagliato;
}

bool TStampa_IVdirettiva::data_limite (TMask_field& f, KEY key)
{
  if (key == K_ENTER)
  {
    TMask& m = f.mask();
    TDate datalim = m.get_date(F_DATALIM);
    const int tipostampa = m.get_int(F_TIPOSTAMPA);
    const int annoese  = m.get_int(F_ANNOESE);

    if (tipostampa == 1)
    {
      if (esercizi().exist(annoese))
      { 
				const TEsercizio & es = esercizio(annoese);

        app()._data_inizio_es  = es.inizio();
        app()._data_fine_es = es.fine();
        app()._anno_esercizio = annoese;
        if (datalim == botime)
          app()._datalimite = app()._data_fine_es;
        else
          if (esercizio(datalim).codice() != annoese)
            return f.error_box(TR("La data limite non appartiene all'esercizio indicato"));
          else
            app()._datalimite = datalim; 
      }
      else
        if (annoese == 0)
        {
					const TDate dataini = m.get_date(F_DATAINI);

					if (dataini.ok() && esercizi().exist(dataini))
						f.set(datalim = esercizio(dataini).fine());
          if (!datalim.ok())
            return f.error_box(TR("La data limite deve essere indicata obbligatoriamente"));
          if (!esercizi().exist(datalim))
						return f.error_box(TR("La data limite indicata non appartiene ad alcun esercizio attivo della ditta"));
					
					const TEsercizio & es = esercizio(datalim);   
					
					app()._data_inizio_es  = es.inizio();
          app()._data_fine_es = es.fine();
          app()._datalimite = datalim;
          app()._anno_esercizio = es.codice();
        }
    }
  }
  return true;
}

bool TStampa_IVdirettiva::data_bil_raff (TMask_field& f, KEY key)
{
  if (key == K_ENTER)
  {
		TMask & m = f.mask();
    const int tipobil    = atoi(m.get(F_TIPOBIL));
    const int tipostampa = atoi(m.get(F_TIPOSTAMPA));

    int annoese  = m.get_int(F_ANNOESE);
    const int annoraf  = m.get_int(F_ANNORAFFR);

		if (annoese == 0)
			annoese = esercizio(TDate(TODAY)).codice();

		const TEsercizio & es = esercizio(annoese);

		app()._data_inizio_es = es.inizio();
		app()._data_fine_es = es.fine();
		if (tipobil == 1)
    {  
      const TDate dataraf = m.get_date(F_DATABILRAF);
      const TDate datalim = m.get_date(F_DATALIM);

			if (annoraf == 0)
      {  
				const TDate inizio = datalim != botime ? esercizio(datalim).inizio(): esercizio(annoese).inizio();

				if (dataraf > inizio)
					return f.error_box(TR("La data bilancio da raffrontare non puo' essere maggiore o uguale alla data inizio esercizio in corso"));
        if (dataraf.ok())
        {
					const TEsercizio & esraf = esercizio(dataraf);

          app()._anno_esercizio_raf = esraf.codice();
					app()._databilrafr = dataraf;
					app()._data_inizio_raf = esraf.inizio();
					app()._data_fine_raf = esraf.fine();
        }
				else
				{
					app()._anno_esercizio_raf = 0;
					app()._databilrafr = botime;
					app()._data_inizio_raf = botime;
					app()._data_fine_raf = eotime;
				}
      }
      else
      { 
				if (esercizi().exist(annoraf))
				{
					const TEsercizio & esraf = esercizio(annoraf);

					app()._data_inizio_raf = esraf.inizio();
					app()._data_fine_raf = esraf.fine();

					if (dataraf == botime)
						app()._databilrafr = app()._data_fine_raf;

					else
						if (dataraf < app()._data_inizio_raf || dataraf > app()._data_fine_raf)
							return f.error_box(TR("La data bilancio da raffrontare deve appartenere all' esercizio da raffrontare"));
						else
							app()._databilrafr = dataraf;
					app()._anno_esercizio_raf = annoraf;
				}
				else
				{
					app()._anno_esercizio_raf = 0;
					app()._databilrafr = botime;
					app()._data_inizio_raf = botime;
					app()._data_fine_raf = eotime;
				}
      }
    }
  }   // IF (key == K_ENTER)
  return true;
}

bool anno_ese_raff (TMask_field& f, KEY key)
{
  if (key == K_ENTER)
  {
		TMask & m = f.mask();
    const int annoese = m.get_int(F_ANNOESE);
    const int annoraf = m.get_int(F_ANNORAFFR);

		if (annoraf != 0)
		{
			if (annoese != 0)
			{
				if (annoraf >= annoese)
					return f.error_box(TR("L' anno esercizio da raffrontare deve essere inferiore all' anno esercizio in corso"));

			}
			else
				if (annoese == 0)
				{
					const TDate datalim = m.get_date(F_DATALIM);

					if (datalim.ok() && annoraf >= esercizio(datalim).codice())
							return f.error_box(TR("L' anno esercizio da raffrontare deve essere inferiore all' anno di esercizio di appartenenza della data limite"));
				}
		}
  }
  return true;
}

bool TStampa_IVdirettiva::tipo_bilancio (TMask_field& f, KEY key)
{
  if (key == K_SPACE)
  {
		TMask & m = f.mask();
    const int tipo_bil    = m.get_int(F_TIPOBIL);   
    const int tipo_stampa = m.get_int(F_TIPOSTAMPA);
		const int anno        = m.get_int(F_ANNOESE);

		m.show(F_DATAINI, tipo_bil == 2 && tipo_stampa == 1);
		m.show(F_QUADRATURA, tipo_bil == 2 && tipo_stampa == 1 && m.get_int(F_ANNOESE) == 0);
  }
  return true;
}

bool TStampa_IVdirettiva::anno_esercizio (TMask_field& f, KEY key)
{
  if (f.running_check(key))
  { 
		TMask & m = f.mask();
		const int tipo_bil    = m.get_int(F_TIPOBIL);
    const int tipo_stampa = m.get_int(F_TIPOSTAMPA);
		const int anno = m.get_int(F_ANNOESE);

		m.show(F_DATAINI, tipo_bil == 2 && tipo_stampa == 1);
		m.show(F_QUADRATURA, tipo_bil == 2 && tipo_stampa == 1 && m.get_int(F_ANNOESE) == 0);
  }
 
  return true;
}

bool TStampa_IVdirettiva::tipo_stampa(TMask_field& f,KEY k)
{
  if (k == K_ENTER)
  {
		TMask & m = f.mask();
		const int tipo_stampa = m.get_int(F_TIPOSTAMPA);
    const int anno = m.get_int(F_ANNOESE);

    if (tipo_stampa == 2)
      if (anno == 0)
      {
        error_box(TR("Nella stampa all'ultima immissione l'anno esercizio e' obbligatorio"));
        return false;
      }  
  }
  if (k == K_SPACE)
  { 
		TMask & m = f.mask();
    const int anno = m.get_int(F_ANNOESE);
		const int tipo_bil    = m.get_int(F_TIPOBIL);   
		const int tipo_stampa = m.get_int(F_TIPOSTAMPA);

		m.show(F_DATAINI, tipo_bil == 2 && tipo_stampa == 1);
		m.show(F_QUADRATURA, tipo_bil == 2 && tipo_stampa == 1 && m.get_int(F_ANNOESE) == 0);
  }
  return true;
}

bool TStampa_IVdirettiva::data_inizio(TMask_field& f, KEY k)
{

  if (k == K_ENTER)
  {
		TMask & m = f.mask();
		int anno = m.get_int(F_ANNOESE);
		TDate data = f.get_date();
		const TDate datalim = m.get_date(F_DATALIM);

		if (!data.ok() && datalim.ok() && esercizi().exist(datalim))
		{
			f.set(data = esercizio(datalim).inizio());
			anno = esercizio(datalim).codice();
		}
    if (esercizi().exist(anno))
    {
			const TEsercizio & es = esercizio(anno);

      app()._data_inizio_es  = es.inizio();
      app()._data_fine_es = es.fine();
      app()._anno_esercizio = anno;

			if (!data.ok())
				app()._datainizio = app()._data_inizio_es;
			else
			{
				if (data < app()._data_inizio_es || data > app()._data_fine_es)
					return f.error_box(TR("La data non appartiene all' esercizio indicato"));
				else
					app()._datainizio = data;
			}
    }
    else
    {
      if (!data.ok())
        return f.error_box(TR("La data iniziale deve essere obbligatoriamente indicata"));
			if (esercizi().exist(data))
			{
				const TEsercizio & es = esercizio(data);

				app()._anno_esercizio = es.codice();
				app()._datainizio = data;
				app()._data_inizio_es = es.inizio();
				app()._data_fine_es = es.fine();
			}
			else
				return f.error_box(TR("La data limite indicata non appartiene ad alcun esercizio attivo della ditta"));
    }
  }  
  return true;
}

void TStampa_IVdirettiva::scrivi_record(const TString& sez,
                                       const TString& let,  const TString& numerorom,const TString & numero,
                                       int g,int c,long s,const real& saldo,const real& saldorafr,
                                       const real& sld_dare,const real& sld_avere,
                                       const real& mov_dare,const real& mov_avere,char tipocf,bool conto_dettagliato)
{
  //Se esiste solamente la sezione,significa che e' un conto d'ordine
  //Forzo la lettera della classe a Z, per ottenere, grazie
  //all'ordinamento del sort, i record dei conti d'ordine per ultimi

  set_bil_key(_bil, sez[0], let[0], numerorom, numero, true, g, c, s, tipocf);
  set_bil_val(_bil, saldo, saldorafr, sld_dare, sld_avere, mov_dare, mov_avere,conto_dettagliato);
  _sort->sort ((const char*) _bil);
}

void TStampa_IVdirettiva::riempi_record(const TString& sez,
                                       const TString& let,  const TString& numerorom,const TString & numero,
                                       int g,int c,long s,const real& saldo,const real& saldorafr,
                                       const real& sld_dare,const real& sld_avere,
                                       const real& mov_dare,const real& mov_avere,char tipocf,bool conto_dettagliato)
{

  if (_stampasaldizero || saldo != ZERO || saldorafr != ZERO)
  {
		set_bil_key(_bil, sez[0], let[0], numerorom, numero, false, g, c, s, tipocf);
    set_bil_val(_bil, saldo, saldorafr, sld_dare, sld_avere, mov_dare, mov_avere,conto_dettagliato);
    _sort->sort ((const char*) _bil);   
    _items_sort++;
  }
}

void TStampa_IVdirettiva::crea_sort_tabella()
{
  TRecnotype recno_prec=0l, recno_curr=0l;
  TString codtab_prec;
  TTable tabivd(TAB_IVD);
  TRecfield codtab_curr(tabivd.curr(),"CODTAB");
  TRecfield sezione   (tabivd.curr(),"CODTAB",0,0);
  TRecfield lettera   (tabivd.curr(),"CODTAB",1,1);
  TRecfield numerorom (tabivd.curr(),"CODTAB",2,5);
  TRecfield numero    (tabivd.curr(),"CODTAB",6,7);
  int preclen;
  bool FINITO=false;
  
  tabivd.first();
  codtab_prec = tabivd.get("CODTAB");
  
  // Compilo tanti record quante sono le classi IV direttiva trovate sulla
  // tabella %IVD, usando dei gruppi, conti e sottoconti fittizi. Successivamente
  // nel caso di stampa completa verranno stampati anche questi record; nel caso
  // di stampa non completa non verranno stampati.
  
  do
  {
    recno_prec  = tabivd.recno();
    tabivd.next();
    if (tabivd.eof())
    {
      tabivd.zero();
      FINITO=true;
    }
    recno_curr  = tabivd.recno();
    preclen = codtab_prec.len();
    if (!strncmp(codtab_curr,codtab_prec,preclen))
      codtab_prec = (const char *)codtab_curr;
    else
    {
      tabivd.readat(recno_prec);
      const char sez = *((const char*) sezione);
      const char let = *((const char*) lettera);
      const TString16  nrom((const char*)numerorom);
      const TString16 nu(numero);
      
      set_bil_key(_bil, sez, let,(const char*)nrom, nu, false,-1);
      set_bil_val(_bil);
      _sort->sort ((const char*) _bil);
      tabivd.readat(recno_curr);
      codtab_prec = (const char *)codtab_curr;
    }
  } while (!FINITO);
}

// Passo al sort tutti i record presenti su piano dei conti, aventi la classe
// IV direttiva CEE.

void TStampa_IVdirettiva::crea_sort_piano_conti_scalare()
{
  TLocalisamfile pconti(LF_PCON);
  TString sez,let,numerorom;
  TString sez_conto,let_conto,numr_conto,sez_opp,let_opp,numr_opp, numero, num_opp, num_conto;
  int     indbil;
  char    sezione,lettera,tmcf;
  int     g,c;
  long    s;
  bool    sez_opposta           = false;
  bool    no_sez_opposta        = false;
  bool    classe_conto          = false;
  bool    conto_dettagliato     = false;
  bool    stsottbil;
  int     gruppo_prec,conto_prec;
  real    saldo,saldo_raf,saldo_conto,saldo_conto_raf;
  real    saldo_conto_opp,saldo_conto_raf_opp;
  c         = 0;
  num_conto = 0;
  tmcf      = ' ';
  indbil    = 0;

  saldo_conto          = ZERO;
  saldo_conto_raf      = ZERO;
  saldo_conto_opp      = ZERO;
  saldo_conto_raf_opp  = ZERO;

  gruppo_prec          = -1;
  conto_prec           = -1;

  TProgind prog(pconti.items(),TR("Elaborazione in corso... prego attendere"),false);

  for (pconti.first(); !pconti.eof(); pconti.next())
  {
    prog.addstatus(1);
    g         = pconti.get_int (PCN_GRUPPO);
    c         = pconti.get_int (PCN_CONTO);
    s         = pconti.get_long(PCN_SOTTOCONTO);
    sez       = pconti.get(PCN_SEZIVD);
    let       = pconti.get(PCN_LETTIVD);
    sezione   = sez[0];
    lettera   = let[0];
    numerorom = pconti.get(PCN_NUMRIVD);
    numero    = pconti.get(PCN_NUMIVD);
    
		if (numero.full())
			int i = 1;
    saldo     = ZERO;
    saldo_raf = ZERO;

    //Anche se il conto non e' da dettagliare ma contiene la classe e' da
    //mandare ugualmente in stampa con il totale di tutti i suoi sottoconti letti
    
    if (classe_conto)
    {
      if (c != conto_prec && conto_prec != -1)
      {
        if (no_sez_opposta)
        {  
          riempi_record(sez_conto,let_conto,numr_conto,num_conto,gruppo_prec,conto_prec,0,saldo_conto,saldo_conto_raf,ZERO,ZERO,ZERO,ZERO,tmcf,conto_dettagliato);
          saldo_conto     = ZERO;
          saldo_conto_raf = ZERO;
          classe_conto    = false;
          no_sez_opposta  = false;
        }
        if (sez_opposta)
        {
          int items = _sezopps.items();
          _sezopps.restart();
          for (int i=0; i<items; i++)
          { 
            TRiga_sez_opp * lriga = _sezopps.riga();
            TString4 sez_opp  = lriga->sezione();
            TString4 let_opp  = lriga->lettera();
            TString4 numr_opp = lriga->num_rom();  
            if (numr_opp == " ")  //Sembrerebbe che il metodo sezione() quando il numero romano non esiste, ritorni
              numr_opp.ltrim();   //una TString contenente uno spazio e non un NULL, sconvolgendo l' ordinamento.
                                  //Per evitare tutto cio' aggiungo il metodo ltrim(), che toglie gli spazi.
                                  //Pero', essendo il numero romano un campo Zerofill, uso ltrim() solo se non c'e'.
            const TString16 num_opp(lriga->numero()); 
            real    saldo_conto = lriga->saldo_conto(); 
            real    saldo_conto_raf = lriga->saldo_conto_raf();
            riempi_record(sez_opp,let_opp,numr_opp,num_opp,gruppo_prec,conto_prec,0,saldo_conto,saldo_conto_raf,ZERO,ZERO,ZERO,ZERO,tmcf,conto_dettagliato);
          }
          sez_opposta = false;
            
          _sezopps.destroy();
        }
      }
    }

    //Senza questo controllo conto_prec quando viene letto un gruppo verrebbe
    //settato a 0 (il conto non c'e'), quindi nella eventuale lettura del conto
    //nel ciclo successivo, qualsiasi conto sarebbe diverso da quello precedente.
    
    if (g != gruppo_prec)
      conto_prec = -1;
    else
      conto_prec = c;

    gruppo_prec = g;
    
    // Se si tratta di un conto e contiene la classe, allora lo passo al sort.
    // Gli eventuali sottoconti avranno la stessa classe.
    
    if ((g != 0) && (c != 0) && (s == 0))
    {
      stsottbil   = !pconti.get_bool(PCN_STSOTTBIL);
      tmcf        = pconti.get     (PCN_TMCF)[0];
      indbil      = pconti.get_int (PCN_INDBIL);

      //Se sono nello stesso gruppo, ma ho un conto diverso da quello precedentemente
      //analizzato, e se questi contiene la classe IV dir. CEE,
      //allore devo controllare se va dettagliato (STSOTTBIL) 

      if (sez.not_empty() && sez != "0")
      {
        if (!stsottbil || tmcf == 'C' || tmcf == 'F')
          conto_dettagliato = false;
        else
          conto_dettagliato = true;

        sez_conto  = sez;
          
        if (let.not_empty())
          let_conto  = let;
        else
          if ((sez == "1")||(sez == "2"))
            let_conto  = "Z";
          else
            let_conto = let;
          
        numr_conto   = numerorom;
        num_conto    = numero;
        classe_conto = true;

        if (tmcf == 'C' || tmcf == 'F')
        {
          if (sottoc_clifo_scalare(g, c,_anno_esercizio,indbil,saldo_conto,saldo_conto_raf))
          {
            if (sez == "2")  //Se la sezione e 2 cambio segno comunque
            { 
              saldo_conto = -saldo_conto;  
              saldo_conto_raf = -saldo_conto_raf;
            }
            no_sez_opposta = true;   
          }
        }
      }
      else
      {
        classe_conto      = false; // Metto conto dettagliato = true perche' potrebbero esserci dei sottoconti
        conto_dettagliato = true;  // di questo conto che hanno la classe e quindi vanno stampati.
      }
    }
    
    // Se si tratta di un sottoconto e contiene la classe, allora lo passo al sort.

    if ((g != 0) && (c != 0) && (s != 0))
    {       
      bool rec_es_corr = false;
      bool rec_es_prec = false;
      
      if (!calcola_saldo(saldo,saldo_raf,g,c,s,indbil))
        continue;

      // classe_conto indica se il conto precedentemente letto conteneva
      // la classe. In caso affermativo anche questo sottoconto appena
      // letto avra' la stessa classe del conto.
      
      if (classe_conto)
      {
        sez_opp = pconti.get(PCN_SEZIVDOPP);
        if (sez_opp.not_empty() && sez_opp != "0")
        {    
          let_opp     = pconti.get(PCN_LETTIVDOPP);
          numr_opp    = pconti.get(PCN_NUMRIVDOPP);
          num_opp     = pconti.get_int(PCN_NUMIVDOPP);
                                                          
          if (sez_conto == "1")
          { 
            rec_es_corr = saldo < ZERO;
            if (rec_es_corr)
							saldo = -saldo;

            rec_es_prec = saldo_raf < ZERO;    
						if (rec_es_prec)
							saldo_raf = -saldo_raf;
          }
					else
						if (sez_conto == "2")  
						{
							rec_es_corr = saldo > ZERO;
							rec_es_prec = saldo_raf > ZERO;
						}       
          
          if (rec_es_corr && rec_es_prec)  
          { 
            if (conto_dettagliato)  
            {             
              _sezopps.add(g,c,s,sez_opp,let_opp,numr_opp,num_opp,saldo,saldo_raf);
              riempi_record(sez_opp,let_opp,numr_opp,num_opp,g,c,s,saldo,saldo_raf,ZERO,ZERO,ZERO,ZERO,tmcf);
              sez_opposta = true;
            } 
            else
              sez_opposta = false;
          }  
          else
            if (rec_es_corr)
            { 
              if (conto_dettagliato)
              { 
                _sezopps.add(g,c,s,sez_opp,let_opp,numr_opp,num_opp,saldo,ZERO);
                riempi_record(sez_opp,let_opp,numr_opp,num_opp,g,c,s,saldo,ZERO,ZERO,ZERO,ZERO,ZERO,tmcf);
                if (saldo_raf != ZERO)  
                {
                  if (sez_conto == "2")  
                    if (saldo_raf < ZERO)
                      saldo_raf = -saldo_raf;
                  
                  riempi_record(sez_conto,let_conto,numr_conto,num_conto,g,c,s,ZERO,saldo_raf,ZERO,ZERO,ZERO,ZERO,tmcf);
                  saldo_conto_raf += saldo_raf;
                  no_sez_opposta = true;
                }
                sez_opposta = true;
              }                    
              else
                sez_opposta = false;
            }
            else 
              if (rec_es_prec)
              { 
                if (conto_dettagliato)
                {
                  _sezopps.add(g,c,s,sez_opp,let_opp,numr_opp,num_opp,ZERO,saldo_raf);
                  riempi_record(sez_opp,let_opp,numr_opp,num_opp,g,c,s,ZERO,saldo_raf,ZERO,ZERO,ZERO,ZERO,tmcf);
                  if (saldo != ZERO)  
                  { 
                    if (sez_conto == "2")
                      if (saldo < ZERO)
                        saldo = -saldo;
                        
                    riempi_record(sez_conto,let_conto,numr_conto,num_conto,g,c,s,saldo,ZERO,ZERO,ZERO,ZERO,ZERO,tmcf);
                    saldo_conto     += saldo;
                    no_sez_opposta = true;
                  }
                  sez_opposta = true;
                }                    
                else
                  sez_opposta = false;
              }
              else
              { 
                if (sez_conto == "2")
                {
                  if (saldo < ZERO)
                    saldo = -saldo;
                  if (saldo_raf < ZERO)
                    saldo_raf = -saldo_raf;
                }
                if (conto_dettagliato) 
                  riempi_record(sez_conto,let_conto,numr_conto,num_conto,g,c,s,saldo,saldo_raf,ZERO,ZERO,ZERO,ZERO,tmcf);
         
                saldo_conto     += saldo;
                saldo_conto_raf += saldo_raf;
                no_sez_opposta   = true;
              }
        }
        else
        { 
          if (sez_conto == "2")
          {
            saldo = -saldo;
            saldo_raf = -saldo_raf;
          }
          if (conto_dettagliato) 
            riempi_record(sez_conto,let_conto,numr_conto,num_conto,g,c,s,saldo,saldo_raf,ZERO,ZERO,ZERO,ZERO,tmcf);
         
          saldo_conto     += saldo;
          saldo_conto_raf += saldo_raf;
          no_sez_opposta   = true;
        }
      }
      else
      {
        sez_opp = pconti.get(PCN_SEZIVDOPP);
        if (sez_opp.not_empty() && sez_opp != "0")
        {    
          let_opp     = pconti.get(PCN_LETTIVDOPP);
          numr_opp    = pconti.get(PCN_NUMRIVDOPP);
          num_opp     = pconti.get(PCN_NUMIVDOPP);
          
          if (sez == "1")
					{
						rec_es_corr = saldo < ZERO;
						if (rec_es_corr)
							saldo = -saldo;

						rec_es_prec = saldo_raf < ZERO;
		        if (rec_es_prec)
							saldo_raf = -saldo_raf;
					}
					else
						if (sez == "2")
						{
							rec_es_corr = saldo > ZERO;
							rec_es_prec = saldo_raf > ZERO;
						}
          
          if (rec_es_corr && rec_es_prec)  
            riempi_record(sez_opp,let_opp,numr_opp,num_opp,g,c,s,saldo,saldo_raf,ZERO,ZERO,ZERO,ZERO,tmcf);
          else
            if (rec_es_corr)
            {
              riempi_record(sez_opp,let_opp,numr_opp,num_opp,g,c,s,saldo,ZERO,ZERO,ZERO,ZERO,ZERO,tmcf);
              if (saldo_raf != ZERO)
              { 
                if (sez == "2")
                  if (saldo_raf < ZERO)
                    saldo_raf = -saldo_raf;
                riempi_record(sez,let,numerorom,numero,g,c,s,ZERO,saldo_raf,ZERO,ZERO,ZERO,ZERO,tmcf);
              }  
            }
            else 
              if (rec_es_prec) 
              {
                riempi_record(sez_opp,let_opp,numr_opp,num_opp,g,c,s,ZERO,saldo_raf,ZERO,ZERO,ZERO,ZERO,tmcf);
                if (saldo != ZERO)
                {
                  if (sez == "2")
                    if (saldo < ZERO)
                      saldo = -saldo;
                  riempi_record(sez,let,numerorom,numero,g,c,s,saldo,ZERO,ZERO,ZERO,ZERO,ZERO,tmcf);
                }  
              }
              else
                if (sez.not_empty() && sez != "0")   
                { 
                  if (sez == "2")
                  {
                    if (saldo < ZERO)
                      saldo = -saldo;
                    if (saldo_raf < ZERO)
                      saldo_raf = -saldo_raf;
                  }
                  riempi_record(sez,let,numerorom,numero,g,c,s,saldo,saldo_raf,ZERO,ZERO,ZERO,ZERO,tmcf);
                }  
        }
        else
          if (sez.not_empty() && sez != "0")
          {  
            if (sez == "2")
            {
              saldo = -saldo;
              saldo_raf = -saldo_raf;
            }
            riempi_record(sez,let,numerorom,numero,g,c,s,saldo,saldo_raf,ZERO,ZERO,ZERO,ZERO,tmcf);
          }  
      }
    }
  }

  conto_prec = 0;

  if (classe_conto)
  {
    if (c != conto_prec && conto_prec != -1)
    {
      if (no_sez_opposta)
      {
        riempi_record(sez_conto,let_conto,numr_conto,num_conto,gruppo_prec,c,0,saldo_conto,saldo_conto_raf,ZERO,ZERO,ZERO,ZERO,tmcf,conto_dettagliato);
        saldo_conto     = ZERO;
        saldo_conto_raf = ZERO;
        classe_conto    = false;
        no_sez_opposta  = false;
      }
      if (sez_opposta)
      {
        int items = _sezopps.items();
        _sezopps.restart();
        for (int i=0; i<items; i++)
        { 
          TRiga_sez_opp * lriga = _sezopps.riga();
          TString sez_opp  = lriga->sezione();
          TString let_opp  = lriga->lettera();
          TString numr_opp = lriga->num_rom(); 
          if (numr_opp == " ")
            numr_opp.ltrim();
          const TString16 num_opp(lriga->numero());
          real    saldo_conto = lriga->saldo_conto(); 
          real    saldo_conto_raf = lriga->saldo_conto_raf();
          riempi_record(sez_opp,let_opp,numr_opp,num_opp,gruppo_prec,conto_prec,0,saldo_conto,saldo_conto_raf,ZERO,ZERO,ZERO,ZERO,tmcf,conto_dettagliato);
        }
        sez_opposta = false;
          
        _sezopps.destroy();
      }
    }
  }
}

void TStampa_IVdirettiva::crea_sort_piano_conti_verifica()
{
  TLocalisamfile pconti(LF_PCON);
  TString sez,let,numerorom;
  TString sez_conto,let_conto,numr_conto, numero, num_conto;
  char sezione,lettera,tmcf;
  int g,c;
  long s;
  bool classe_conto           = false;
  bool conto_dettagliato      = false;
  bool stsottbil;
  int gruppo_prec,conto_prec, indbil;
  real saldo,sld_prg_dare,sld_prg_avere,mov_dare,mov_avere;
  real saldo_conto,sld_prg_dare_conto,sld_prg_avere_conto,mov_dare_conto,mov_avere_conto;

  _sld->set_annoes(_anno_esercizio);

  saldo_conto         = ZERO;
  sld_prg_dare_conto  = ZERO;
  sld_prg_avere_conto = ZERO;
  mov_dare_conto      = ZERO;
  mov_avere_conto     = ZERO;
 
  indbil      = 0;
  gruppo_prec = -1;
  conto_prec  = -1;
  c           = 0;
  num_conto   = 0;
  tmcf        = ' ';

  TProgind prog(pconti.items(),TR("Elaborazione in corso... prego attendere"),false);

  for (pconti.first(); !pconti.eof(); pconti.next())
  {
    prog.addstatus(1);
    g         = pconti.get_int (PCN_GRUPPO);
    c         = pconti.get_int (PCN_CONTO);
    s         = pconti.get_long(PCN_SOTTOCONTO);
    sez       = pconti.get(PCN_SEZIVD);
    let       = pconti.get(PCN_LETTIVD);
    sezione   = sez[0];
    lettera   = let[0];
    numerorom = pconti.get(PCN_NUMRIVD);
    numero    = pconti.get(PCN_NUMIVD);
     
    saldo         = ZERO;
    sld_prg_dare  = ZERO;
    sld_prg_avere = ZERO;
    mov_dare      = ZERO;
    mov_avere     = ZERO;
    
    //Senza questo controllo conto_prec quando viene letto un gruppo verrebbe
    //settato a 0 (il conto non c'e'), quindi nella eventuale lettura del conto
    //nel ciclo successivo, qualsiasi conto sarebbe diverso da quello precedente.
    
    if (g != gruppo_prec)
      conto_prec = -1;
    else
      conto_prec = c;

    gruppo_prec = g;
    
    if (classe_conto)
    {
      if (c != conto_prec && conto_prec != -1)
      {
        riempi_record(sez_conto,let_conto,numr_conto,num_conto,gruppo_prec,conto_prec,0,saldo_conto,ZERO,sld_prg_dare_conto,sld_prg_avere_conto,mov_dare_conto,mov_avere_conto,tmcf,conto_dettagliato);
        saldo_conto            = ZERO;
        sld_prg_dare_conto     = ZERO;
        sld_prg_avere_conto    = ZERO;
        mov_dare_conto         = ZERO;
        mov_avere_conto        = ZERO;
        classe_conto           = false;
      }
    }

    // Se si tratta di un conto e contiene la classe, allora lo passo al sort.
    // Gli eventuali sottoconti avranno la stessa classe.
    
    if ((g != 0) && (c != 0) && (s == 0))
    {
      stsottbil   = !pconti.get_bool(PCN_STSOTTBIL);
      tmcf        = pconti.get(PCN_TMCF)[0];
      indbil      = pconti.get_int(PCN_INDBIL);

      //Se sono nello stesso gruppo, ma ho un conto diverso da quello precedentemente
      //analizzato , se contiene la classe IV dir. CEE
      //allora devo controllare se va dettagliato (STSOTTBIL)

      if (sez.not_empty() && sez != "0")
      {   
        if ((tmcf == 'C') || (tmcf == 'F'))
        {  
          sottoc_clifo_verifica(g, c,_anno_esercizio, tmcf,sez,let,numerorom, numero,indbil,stsottbil);
          continue;
        }
        else 
          if (!stsottbil)
            conto_dettagliato = false;
          else
            conto_dettagliato = true;

        sez_conto  = sez;
          
        if (let.not_empty())
          let_conto = let;
        else
          if ((sez == "1")||(sez == "2"))
            let_conto = "Z";
          else
            let_conto = let;
          
        numr_conto   = numerorom;
        num_conto    = numero;
        classe_conto = true;
      }
      else
      {
        classe_conto      = false; // Metto conto dettagliato = true perche' potrebbero esserci dei sottoconti
        conto_dettagliato = true;  // di questo conto che hanno la classe e quindi vanno stampati.
      }
    }
    // Se si tratta di un sottoconto e contiene la classe, allora lo passo al sort.

    if ((g != 0) && (c != 0) && (s != 0))
    {
    // classe_conto indica se il conto precedentemente letto conteneva la classe,
    // ma quest' ultima non era presente a livello di gruppo. In caso affermativo
    // anche questo sottoconto appena letto avra' la stessa classe del conto.

      if (_tipo_stampa == 1)
      {
				if (calcola(g, c, s, _data_fine_es, _data_fine_ese_prec))
				{
					if (_datainizio == _data_inizio_es)
					{
						sld_prg_dare = _saldo_ini_dare;
						sld_prg_avere = _saldo_ini_avere;
						mov_dare = _mov_periodo_dare;
						mov_avere = _mov_periodo_avere;
						saldo = sld_prg_dare - sld_prg_avere + mov_dare - mov_avere;
					}
					else
						if (_datainizio > _data_inizio_es)
						{
							sld_prg_dare = _prg_prec_dare;
							sld_prg_avere = _prg_prec_avere;
							mov_dare = _mov_periodo_dare;
							mov_avere = _mov_periodo_avere;
							saldo = sld_prg_dare - sld_prg_avere + mov_dare - mov_avere;
						}
				}
			}
      else 
				if (_tipo_stampa == 2)
				{
					if (_sld->ultima_immissione_verifica(_anno_esercizio, g, c, s, indbil, _stampa_mov_prov) && (!_intera_struttura || (!_stampasaldizero)))
					{
						real saldoini = _sld->saldoini();

						//fine modifica 11/11/1997
						if (saldoini > ZERO)
						{
							sld_prg_dare = saldoini;
							sld_prg_avere = ZERO;
						}
						else
						{
							sld_prg_dare = ZERO;
							sld_prg_avere = -saldoini;
						}
						mov_dare = _sld->prgdare();
						mov_avere = _sld->prgavere();
						saldo = sld_prg_dare - sld_prg_avere + mov_dare - mov_avere;
					}
				}
      if (classe_conto)
      {
        if (conto_dettagliato)
          riempi_record(sez_conto,let_conto,numr_conto,num_conto,g,c,s,saldo,ZERO,sld_prg_dare,sld_prg_avere,mov_dare,mov_avere,tmcf);

        if (saldo != ZERO || !_stampasaldizero) //Se non deve stampare i conti con saldo a zero, non aggiornare il totale del conto
        {
          saldo_conto         += saldo;
          sld_prg_dare_conto  += sld_prg_dare;
          sld_prg_avere_conto += sld_prg_avere;
          mov_dare_conto      += mov_dare;
          mov_avere_conto     += mov_avere;
        }
      }
      else
      {
        if (sez.not_empty() && sez != "0")
          scrivi_record(sez,let,numerorom,numero,g,c,s,saldo,ZERO,sld_prg_dare,sld_prg_avere,mov_dare,mov_avere,tmcf);
      }
    }
  }

  conto_prec = 0;

  if (classe_conto)
  {
    if (c != conto_prec && conto_prec != -1)
    {
      riempi_record(sez_conto,let_conto,numr_conto,num_conto,gruppo_prec,c,0,saldo_conto,ZERO,sld_prg_dare_conto,sld_prg_avere_conto,mov_dare_conto,mov_avere_conto,tmcf,conto_dettagliato);
      saldo_conto            = ZERO;
      sld_prg_dare_conto     = ZERO;
      sld_prg_avere_conto    = ZERO;
      mov_dare_conto         = ZERO;
      mov_avere_conto        = ZERO;
      classe_conto           = false;
    }
  }
}


void TStampa_IVdirettiva::sottoc_clifo_verifica(int g,int c,int anno,char tipocf,TString& sez,TString& let,TString& numerorom, TString& numero,int indbil,bool stsottbil)
{
  long s;
  _listasld = new TSaldi_list (g,c,anno);
  real saldo,sld_prg_dare,sld_prg_avere,mov_dare,mov_avere;
  real saldo_conto,sld_prg_dare_conto,sld_prg_avere_conto,mov_dare_conto,mov_avere_conto;
  real app;
  TString sez_conto,let_conto,numr_conto, num_conto;

  saldo_conto         = ZERO;
  sld_prg_dare_conto  = ZERO;
  sld_prg_avere_conto = ZERO;
  mov_dare_conto      = ZERO;
  mov_avere_conto     = ZERO;
  
  int items = _listasld->items();

  sez_conto  = sez;
    
  if (let.not_empty())
    let_conto = let;
  else
    if ((sez == "1")||(sez == "2"))
      let_conto = "Z";
    else
      let_conto = let;
    
  numr_conto = numerorom;
  num_conto  = numero;
  
  _listasld->restart();
    
  for (int i=0 ; i < items; i++)
  {
    const TRectype* r=_listasld->saldi();
    if (r == NULL) break;
        
    s = r->get_long(SLD_SOTTOCONTO);
      
    saldo         = ZERO;
    sld_prg_dare  = ZERO;
    sld_prg_avere = ZERO;
    mov_dare      = ZERO;
    mov_avere     = ZERO;
    app           = ZERO;
      
     if (_tipo_stampa == 1)
     {
			 if (calcola(g, c, s, _data_fine_es, _data_fine_ese_prec))
			 {
				 if (_datainizio == _data_inizio_es)
				 {
					 sld_prg_dare = _saldo_ini_dare;
					 sld_prg_avere = _saldo_ini_avere;
					 mov_dare = _mov_periodo_dare;
					 mov_avere = _mov_periodo_avere;
					 saldo = sld_prg_dare - sld_prg_avere + mov_dare - mov_avere;

				 }
				 else
					 if (_datainizio > _data_inizio_es)
					 {
						 sld_prg_dare = _prg_prec_dare;
						 sld_prg_avere = _prg_prec_avere;
						 mov_dare = _mov_periodo_dare;
						 mov_avere = _mov_periodo_avere;
						 saldo = sld_prg_dare - sld_prg_avere + mov_dare - mov_avere;
					 }
			 }
    }
    else 
      if (_tipo_stampa == 2)
			{
				//modifica 05/04/1994
        if (_stampa_mov_prov & 0x1)
					if (!_sld->ultima_immissione_verifica(_anno_esercizio,g,c,s,indbil,_stampa_mov_prov))
					{
						if (indbil == 1 || indbil == 2 || indbil == 5)      
							app = _sld->saldofin_esprec(_anno_esercizio,g,c,s);
					}
		      else app = _sld->saldoini();
	        //fine modifica  
        if (app < ZERO)
        {
          app           = -app;
          sld_prg_dare  = ZERO;
          sld_prg_avere = app;
        }
        else
        {
          sld_prg_dare  = app;
          sld_prg_avere = ZERO;
        }
        mov_dare  = _sld->prgdare();
        mov_avere = _sld->prgavere();
        saldo     = sld_prg_dare-sld_prg_avere+mov_dare-mov_avere;
      }  
    
    if (stsottbil)
      riempi_record(sez_conto,let_conto,numr_conto,num_conto,g,c,s,saldo,ZERO,sld_prg_dare,sld_prg_avere,mov_dare,mov_avere,tipocf);
    if (saldo != ZERO || !_stampasaldizero)  //Se non deve stampare i conti con saldo a zero, non aggiornare il totale del conto
    {
      saldo_conto         += saldo;
      sld_prg_dare_conto  += sld_prg_dare;
      sld_prg_avere_conto += sld_prg_avere;
      mov_dare_conto      += mov_dare;
      mov_avere_conto     += mov_avere;
    }
  }
  if (items > 0)
    riempi_record(sez_conto,let_conto,numr_conto,num_conto,g,c,0,saldo_conto,ZERO,sld_prg_dare_conto,sld_prg_avere_conto,mov_dare_conto,mov_avere_conto,tipocf,stsottbil);
  saldo_conto         = ZERO;
  sld_prg_dare_conto  = ZERO;
  sld_prg_avere_conto = ZERO;
  mov_dare_conto      = ZERO;
  mov_avere_conto     = ZERO;

  delete _listasld;
}

bool TStampa_IVdirettiva::sottoc_clifo_scalare(int g,int c,int anno,int indbil,real& saldo_conto,real& saldo_conto_raf)
{
  long s;
  int aep = 0;

  if (anno > 0) 
  {
    TEsercizi_contabili ec;
    aep = ec.pred(anno);
  }
  _listasld = new TSaldi_list (g,c,anno,aep);

  real saldo,saldo_raf;
  bool trovato = false;

  int items = _listasld->items();

  for (int i=0 ; i < items; i++)
  {
    const TRectype* r=_listasld->saldi(); 
    if (r == NULL) break;
    
    s = r->get_long(SLD_SOTTOCONTO);
      
    saldo         = ZERO;
    saldo_raf     = ZERO;
      
    if (!calcola_saldo(saldo,saldo_raf,g,c,s,indbil))
      continue;

    saldo_conto += saldo;
    saldo_conto_raf += saldo_raf;  
    trovato = true;
  }
  delete _listasld;
  return trovato;    
}

//La funzione calcola_saldo calcola il saldo dell'esercizio in corso e di
//quello da raffrontare. Inoltre ritorna vero se il sottoconto e' movimentato
//e falso se non e' movimentato, e quindi non deve essere stampato.

bool TStampa_IVdirettiva::calcola_saldo(real& saldo, real& saldo_raf,int g,int c,long s,int indbil)
{
  bool no_movimentato     = true;
  bool no_movimentato_raf = true; 
  bool esiste = false;
  TString saldostr,saldo_rafstr;
	  
  _sld->set_annoes(_anno_esercizio);
  if (_tipo_bilancio == 1)
  {
    if (_tipo_stampa == 1)   //bilancio per data limite
    {
      esiste = _sld->data_limite_bilancio(_tipo_data, g, c, s, _datai, _datalimite, indbil, _stampa_mov_prov);
      saldo = _sld->saldo();
          
			if (!esiste) // && (!_sld->esiste_saldo()) //|| !_sld->significativo()))
				no_movimentato = true;
			else
				if (_stampasaldizero)
					no_movimentato = (saldo == ZERO) && (!_sld->esiste_saldo()); //|| !_sld->significativo());                          
        else
						no_movimentato = saldo==ZERO;
    }
    else
			if (_tipo_stampa == 2)
			{
				if (!_sld->ultima_immissione_bilancio(_anno_esercizio, g, c, s, indbil, _stampa_mov_prov))
					no_movimentato = (!_sld->esiste_saldo()); //|| !_sld->significativo());
				else
					no_movimentato = false;
         
				saldo = _sld->saldo();  
			}
    saldostr = saldo.string();
    
    if (_annoeserafr != 0 || _databilrafr != botime)
    {
      _sld->set_annoes(_anno_esercizio_raf);

      if (_databilrafr != _data_fine_raf) //(_tipo_stampa == 1) bilancio per data limite
      {
        esiste = _sld->data_limite_bilancio(_tipo_data, g, c, s, _datairaf, _databilrafr, indbil, _stampa_mov_prov);
        saldo_raf = _sld->saldo();  
           
        if (!esiste  && (!_sld->esiste_saldo() || !_sld->significativo())) 
          no_movimentato_raf = true;
        else   
          if (_stampasaldizero)
          {
            if (saldo_raf == ZERO)
            {
              if (!_sld->esiste_saldo() || !_sld->significativo())
                no_movimentato_raf = true;
              else
                no_movimentato_raf = false;
            }                          
            else
              no_movimentato_raf = false;
          }  
          else
          { 
            if (saldo_raf == ZERO)
              no_movimentato_raf = true;
            else
              no_movimentato_raf = false;   
          }
      }
      else
				if (_databilrafr == _data_fine_raf) 
				{     
					if (!_sld->ultima_immissione_bilancio(_anno_esercizio_raf,g,c,s,indbil,_stampa_mov_prov, false))  // W96SALDI : ho aggiunto il parametro false
					{                                                                                                // per dire che nel calcola del saldo non deve
						if (!_sld->esiste_saldo() || !_sld->significativo())                                           // includere il saldo di chiusura
							no_movimentato_raf = true;
						else
							no_movimentato_raf = false;
					}
					else
						no_movimentato_raf = false;  
        
					saldo_raf = _sld->saldo();  
				} 
      saldo_rafstr = saldo_raf.string();
    }
  }
  if ((no_movimentato) && (no_movimentato_raf)) 
    return false;
  else
    return true;
}

bool TStampa_IVdirettiva::calcola(int g, int c, long s,
	const TDate& fine_es, const TDate& fine_es_prec, const char * filter)
{
	TDecoder causali(LF_CAUSALI, CAU_MOVAP);
	bool    conto_mov = false;

	_mov_periodo_dare = ZERO;
	_mov_periodo_avere = ZERO;
	_prg_prec_dare = ZERO;
	_prg_prec_avere = ZERO;
	_saldo_ini_dare = ZERO;
	_saldo_ini_avere = ZERO;

	TCursor cur(new TRelation(LF_RMOV), filter, 2);
	TRectype& rmov = cur.file().curr();

	rmov.put(RMV_GRUPPO, g);
	rmov.put(RMV_CONTO, c);
	rmov.put(RMV_SOTTOCONTO, s);
	cur.setregion(rmov, rmov);

	const TRecnotype items = cur.items();

	cur.freeze();

	for (cur = 0L; cur.pos() < items; ++cur) 
	{
		const int annoe = rmov.get_int(RMV_ANNOES);
		const long numreg = rmov.get_long(RMV_NUMREG);
		const TRectype& mov = cache().get(LF_MOV, numreg);
		const TString4 sezione = rmov.get(RMV_SEZIONE);
		const real importo = rmov.get_real(RMV_IMPORTO);
		const TString4 provvis = mov.get(MOV_PROVVIS);
		const TString& codcaus = mov.get(MOV_CODCAUS);
		const char movap = toupper(causali.decode(codcaus)[0]);

		if (movap == 'C' &&   // la causale e' di chiusura
			!_quadratura)     // Non e' richiesta la quadratura con il Libro Giornale (Modifica
			continue;           // del 18-06-96 richiesta da Patrizia in seguito alla modifica dei SALDI
		if (importo == ZERO)
			continue;

		//calcolo i movimenti del periodo

		const TDate data = get_date_mov(mov, _tipo_data);

		if (data.ok() && (data >= _datainizio) && (data <= _datalimite))
			if ((movap == 'A' && _data_inizio_es != _datainizio) || (movap != 'A'))
				if (check_mov(_stampa_mov_prov, provvis))
				{
					conto_mov = true;
					if (sezione == "D")
						_mov_periodo_dare += importo;
					else
						_mov_periodo_avere += importo;
				}

		//il saldo inizio es. e' dato dall'importo dare - importo avere di quei movimenti che hanno causale == apertura e data reg >= data inizio es. e <= data limite sup.

		if (_datainizio == _data_inizio_es) //calcolo il saldo iniziale
		{
			if ((_stampa_mov_prov & 0x1) && (movap == 'A'))
			{
				if (data >= _data_inizio_es && data <= _datalimite)
				{
					if (sezione == "D")
						_saldo_ini_dare += importo;
					else
						_saldo_ini_avere += importo;
					conto_mov = true;
				}
			}
		}
		else
			if (_datainizio > _data_inizio_es) //calcolo i progressivi precedenti
				if ((data >= _data_inizio_es) && (data < _datainizio))
					if (check_mov(_stampa_mov_prov, provvis))
					{
						if (sezione == "D")
							_prg_prec_dare += importo;
						else
							_prg_prec_avere += importo;

						conto_mov = true;
					}
		if ((_stampa_mov_prov & 0x1) && (_saldo_ini_dare == ZERO) && (_saldo_ini_avere == ZERO))
		{
			TBill conto(g, c, s);
			int indbil = conto.indicatore_bilancio();

			if ((indbil == 1) || (indbil == 2) || (indbil == 5))
			{
				TSaldo saldo;
				const int annoes = esercizi().date2esc(fine_es);
				real si = saldo.saldofin_esprec(annoes, g, c, s);

				if (si > ZERO)
				{
					_saldo_ini_dare = si;
					conto_mov = true;
				}
				else
					if (si < ZERO)
					{
						_saldo_ini_avere = -si;
						conto_mov = true;
					}
			}
		}
	}
	return conto_mov || (_intera_struttura || _stampasaldizero);
}  

bool TStampa_IVdirettiva::set_print(int)
{
  KEY tasto = _msk->run(); 
  if (tasto == K_ENTER) 
  {  
    _datastampa       = _msk->get(F_DATASTAMPA);    
    _annoese          = _msk->get_int(F_ANNOESE);
    _annoeserafr      = _msk->get_int(F_ANNORAFFR);
    _intera_struttura = _msk->get_bool(F_STAMPAINT);
    _stampasaldizero  = !_msk->get_bool(F_STAMPAMOV);
    _stampacod        = _msk->get_bool(F_STAMPACOD);
    _stampa_modulo    = _msk->get_bool(F_STAMPAMODULO);
    _tipo_bilancio    = _msk->get_int(F_TIPOBIL);
		_stampa_mov_prov  = _msk->get_bool(F_NORMALI) ? 0x1 : 0;
		_stampa_mov_prov |= _msk->get_bool(F_PROVVM) ? 0x2 : 0;
		_stampa_mov_prov |= _msk->get_bool(F_PROVVB) ? 0x4 : 0;
		_stampa_mov_prov |= _msk->get_bool(F_PROVVC) ? 0x8 : 0;
		_quadratura       = _msk->get_bool(F_QUADRATURA);
    _noseparator      = _msk->get_bool(F_SEPARATOR);
		_tipo_data = (_annoese == 0 ? Registrazione : (_msk->get_bool(F_COMPCR) ? CostiRicavi : Competenza));
    _tipo_stampa = _msk->get_int(F_TIPOSTAMPA);
    if (_tipo_stampa == 2)
    {
      _anno_esercizio     = _annoese;
      _anno_esercizio_raf = _annoeserafr;
    } 
    _cont_let  = 0;
    _cont_numr = 0;
    _cont_num  = 0;
    _cont_gcs  = 0;
    _reset_righe_stampa = true;
    if (_tipo_bilancio == 1)
      set_real_picture("###.###.###.###.###");  
    else 
    {
      if (_noseparator)                       
        set_real_picture("################");  
      else
        set_real_picture("####.###.###.###");  
    }  
    set_magic_currency(true);
    
    set_print_zero(true);
  
    _totale_attivita_gia_stampato  = false;
    _totale_passivita_gia_stampato = false;
    _statopatr_no_stamp            = true;   
    _diffprod_fatto                = true;            
    _risimp_fatto                  = false;
    _sbilancio_ordine              = false;   
    _sbilancio_patr_gia_stampato   = false;
    _attivo_o_passivo              = false;
  
    _sez_stamp  = ' ';
    _let_stamp  = ' ';
    _numr_stamp = "";
    _num_stamp  = "";
    _sez_tot    = ' ';
    _let_tot    = ' ';
    _numr_tot   = "";
    _num_tot    = "";
   
    _sale = _salerafr = _totale_ordine = _totale_economico = ZERO;
    _totale_ordine_raf = _totale_economico_raf = _totale_numero = ZERO;
    _totale_numr = _totale_lettera = _totale_sezione = ZERO;
    _totale_patrimoniale = _totale_attivita = _totale_passivita = ZERO;
    _totale_num_raf = _totale_numr_raf = _totale_let_raf = ZERO;
    _totale_sez_raf = _totale_patrim_raf = _totale_attiv_raf = ZERO;
    _totale_passiv_raf = _totale_ordine_attivo = _totale_ordine_passivo = ZERO;
    _totale_ordine_attivo_raf = _totale_ordine_passivo_raf = ZERO;
    _mov_periodo_dare = _mov_periodo_avere = _prg_prec_dare = ZERO;
    _prg_prec_avere = _saldo_ini_dare = _saldo_ini_avere = ZERO;
    _sld_prg_dare = _sld_prg_avere = _mov_dare = _mov_avere = ZERO;
    _tot_num_saldo = _tot_numr_saldo = _tot_let_saldo = _tot_gen_saldo = ZERO;
    _tot_num_prg_d = _tot_numr_prg_d = _tot_let_prg_d = _tot_gen_prg_d = ZERO;
    _tot_num_prg_a = _tot_numr_prg_a = _tot_let_prg_a = _tot_gen_prg_a = ZERO;
    _tot_num_mov_d = _tot_numr_mov_d = _tot_let_mov_d = _tot_gen_mov_d = ZERO;
    _tot_num_mov_a = _tot_numr_mov_a = _tot_let_mov_a = _tot_gen_mov_a = ZERO;
    _tot_num_saldo_d = _tot_numr_saldo_d = _tot_let_saldo_d = ZERO;
    _tot_gen_saldo_d = _tot_num_saldo_a = _tot_numr_saldo_a = ZERO;
    _tot_let_saldo_a = _tot_gen_saldo_a = _totale_parziale = ZERO;
    _totale_parziale_raf = _tot_parz_sld = _tot_parz_sld_d = ZERO;
    _tot_parz_sld_a = _tot_parz_prg_d = _tot_parz_prg_a = ZERO;
    _tot_parz_mov_d = _tot_parz_mov_a = ZERO;
    
    _datai    = _data_inizio_es;
    _datairaf = _data_inizio_raf;

  
  // Se si tratta di stampa intera struttura allora passo al sort anche tutte 
  // le classi presenti sulla tabella IV dir. CEE, altrimenti passo solamente
  // le classi associate ai conti/sottoconti del Piano dei conti.
    
    _items_sort = 0;
    
    init_sort();
    if (_intera_struttura)
      crea_sort_tabella();
    if (_tipo_bilancio == 1)
      crea_sort_piano_conti_scalare();
    else
      crea_sort_piano_conti_verifica();
    _sort->endsort();
  
    crea_intestazione();
    delete _bil;
    return true;
  }
  return false;
}

// Lo so, fa schifo: ma mi sono adeguato (Guy)
bool TStampa_IVdirettiva::devo_stampare_risultato_prima_delle_imposte() const
{
	if (_risimp_fatto)
		return false;
		if (_sez_da_stamp > _sez_utile)
			return true;
	if (_sez_da_stamp == _sez_utile && _let_da_stamp >= _lett_utile && _classe_da_stampare >= _classe_utile && atoi(_num_da_stamp) >= atoi(_num_utile))
		return true;
	if (_sez_da_stamp == _sez_utile && _let_da_stamp == _lett_utile && _classe_da_stampare >= _classe_utile && atoi(_num_da_stamp) >= atoi(_num_utile))
		return true;
	if (_sez_da_stamp == _sez_utile && _let_da_stamp == _lett_utile && _classe_da_stampare == _classe_utile && atoi(_num_da_stamp) >= atoi(_num_utile))
		return true;
	return false;

}

void TStampa_IVdirettiva::stampa_risultato_prima_delle_imposte()
{ 
  if (!_risimp_fatto)
  {                
    const bool raff = _annoeserafr > 0 || _databilrafr.ok();
  
    if (_let_da_stamp == 'E' && atoi(_num_da_stamp) > 21 &&       // questa prima parte e' sempre true!
        !_totale_parziale.is_zero() && !_totale_parziale_raf.is_zero())
    {
      set_row (_i,"@4g%s@81g%r", TR("Totale delle partite straordinarie"), &_totale_parziale);
      if (raff)
        set_row (_i,"@111g%r", &_totale_parziale_raf);
      _i++;  
    }
    
    // Guy was here 05/03/2004: La prima imposta a volte e' gia' stata sommata
    const real te = _totale_economico - (_prima_dopo ? _sale : ZERO);

    set_row (_i,"@4g%s@81g%r", TR("Risultato prima delle imposte"), &te);

    if (raff)
    {
      // Guy was here 10/03/2004: La prima imposta a volte e' gia' stata sommata anche qui
      const real te = _totale_economico_raf - (_prima_dopo ? _salerafr : ZERO);
      
      set_row (_i,"@111g%r", &te);
    }
    _i++;  
    _risimp_fatto = true;
  }
}

void TStampa_IVdirettiva::stampa_totali()
{
  bool gia_stampato_conto_ord = false;
  const char* diff_prod = "9B";
  
  TString16 classe;    
  classe.format("%c%c%8s%s", _sez_da_stamp,_let_da_stamp,(const char*)_numr_da_stamp,(const char*)_num_da_stamp);
  
  _num  = _num_tot;
  _numr = _numr_tot;
  _let  = _let_tot;

  if (_buff == NULL) 
  {
    _num_tot  = "";
    _numr_tot = "";
    _let_tot  = ' ';
    _sez_tot  = ' ';
  }    
      
  if ((_sez_stamp == '1' || _sez_stamp == '2') && _let_stamp != 'Z')  
    _attivo_o_passivo = true;
        
  if (_num_da_stamp!=_num_tot)
  {       
    if (_let_stamp != 'Z')
    {
      if (_sez_stamp != '5')
        if (_cont_gcs != 0)
        {
          //Fai il totale del numero arabo e stampalo 
          if (_num.not_empty())
          {
            set_row (_i,FR("@18gTotale@25g%s)"), num2str(_num));
            set_row (_i++,"@81g%r", &_totale_numero);
          }
        }
    }

    _cont_gcs = 0;
    _totale_numero = 0;
  }
  if (_numr_da_stamp!=_numr_tot)
  {
    if (_let_stamp != 'Z')
    {
      if (_sez_stamp != '5')
      {
        if (_cont_gcs != 0)
        {
          //Fai il totale del numero arabo e stampalo 
          if (_num.not_empty())
          {
            set_row (_i,FR("@18gTotale@25g%s)"), num2str(_num));
            set_row (_i++,"@81g%r", &_totale_numero); 
          }
        }
        if (_cont_num != 0)//(_cont_num >= 2)
        {
          //Fai il totale del numero romano e stampalo
          int numeror = atoi(_numr);
          TString numrom  = itor(numeror); 
          if (numrom.not_empty())
          {
            set_row (_i,FR("@14gTotale@21g%s"), (const char*) numrom);
            set_row (_i++,"@81g%r", &_totale_numr);
          }
        }
      }
    }
    _cont_gcs = 0;
    _cont_num = 0;
    _totale_numero = 0;
    _totale_numr = 0;
  }   
  if (_let_da_stamp!=_let_tot)
  { 
    if (_sez_stamp == '9')
    {
      TString16 classe;
      
      classe.format("%c%c%8s%s",_sez_stamp,_let_stamp,(const char*)_numr_stamp,(const char*)_num_stamp);
       
      if (_cont_gcs != 0)
      {
        //Fai il totale del numero arabo e stampalo
        if (_num.not_empty())
        {
          set_row (_i,FR("@18gTotale@25g%s)"), num2str(_num));
          set_row (_i++,"@81g%r", &_totale_numero);
        }
      }
      if (_cont_num != 0)
      {
        //Fai il totale del numero romano e stampalo  
        const int numeror = atoi(_numr);
        if (numeror > 0)
        {
          TString numrom  = itor(numeror);
          set_row (_i,FR("@14gTotale@21g%s"), (const char*) numrom);

          set_row (_i++,"@81g%r", &_totale_numr);
        }
      }
      if (_cont_numr != 0)
      {
        //Fai il totale della lettera e stampalo  
        if (_let_stamp == 'D')
          set_row (_i,FR("@4gTotale delle rettifiche"));
        else          
          if (_let != ' ')
            if (_sez_stamp == '9' && _let_stamp != 'E')
              set_row (_i,FR("@3gTotale@10g%c)"), _let);
            else  
              if (_sez_stamp != '9')
                set_row (_i,FR("@3gTotale@10g%c)"), _let);
        if (_let != ' ')
        {
          if (_sez_stamp == '9' && _let_stamp != 'E')  
            set_row (_i++,"@81g%r", &_totale_lettera);
          else
            if (_sez_stamp != '9')                    
              set_row (_i++,"@81g%r", &_totale_lettera);    
        }
      }
      
      if (classe > diff_prod && _diffprod_fatto)
      { 
        if (_let_tot == 'A' || _let_tot == 'B') //Solo se esiste una delle due lettere
        {               
          set_row (_i++,FR("@4gDifferenza tra valore e costi della produzione@81g%r"), &_totale_economico);
          _diffprod_fatto = false;
        }
      }
    }
    else
    {
    if (_let_stamp != 'Z')
    {
      if (_sez_stamp != '5')
      {
        if (_cont_gcs != 0)
        {
          //Fai il totale del numero arabo e stampalo 
          if (_num.not_empty())
          {
            set_row (_i,FR("@18gTotale@25g%s)"), num2str(_num));
            set_row (_i++,"@81g%r", &_totale_numero);
          }
        }
        if (_cont_num != 0)
        {    
          //Fai il totale del numero romano e stampalo
          int numeror = atoi(_numr);
          TString numrom  = itor(numeror); 
          if (numrom.not_empty())
          {
            set_row (_i,FR("@14gTotale@21g%s"), (const char*) numrom);
            set_row (_i++,"@81g%r", &_totale_numr);
          }
        }
        if (_cont_numr != 0)
        {
          //Fai il totale della lettera e stampalo 
          if (_let != ' ')
          {
            set_row (_i,FR("@3gTotale@10g%c)"), _let);
            set_row (_i++,"@81g%r", &_totale_lettera);
          }
        }
      }   
    }
    
    if ((_sez_stamp == '1')&&(_let_da_stamp == 'Z'))
    {
			char app = ' ';
			set_row(_i++, "@0g%c", app);
			set_row (_i,TR("TOTALE ATTIVO"));
      set_row (_i++,"@81g%r", &_totale_sezione);
      _totale_attivita = _totale_sezione;
      _totale_sezione = ZERO;
      _totale_attivita_gia_stampato = true;
    }
    
    if ((_sez_stamp == '2')&&(_let_da_stamp == 'Z'))
    {
			char app = ' ';
			set_row(_i++, "@0g%c", app);
			set_row (_i,TR("TOTALE PASSIVO"));
      set_row (_i++,"@81g%r", &_totale_sezione);
      _totale_passivita = _totale_sezione;
      _totale_sezione = ZERO;
      _totale_passivita_gia_stampato = true;
    }
    
    if ((_sez_stamp == '1')&&(_let_stamp == 'Z'))
    {
      char app = ' ';
      set_row (_i++,"@0g%c", app);
      set_row (_i,TR("TOTALE CONTI D'ORDINE ATTIVI")); 
      set_row (_i++,"@81g%r", &_totale_ordine_attivo);
      gia_stampato_conto_ord = true;
    }
    
    if ((_sez_stamp == '2')&&(_let_stamp == 'Z'))
    {
      char app = ' ';
      set_row (_i++,"@0g%c", app);
      set_row (_i,TR("TOTALE CONTI D'ORDINE PASSIVI"));
      set_row (_i++,"@81g%r", &_totale_ordine_passivo);
      _i++;
      
      if (!_attivo_o_passivo)
      {
        real totale  = _totale_ordine_attivo - _totale_ordine_passivo;    

				if (totale != ZERO)
        {
          set_row (_i++,TR("SALDO CONTI D'ORDINE"));
          set_row (_i,TR("SBILANCIO"));           
          set_row (_i++,"@81g%r", &totale); 
        }
        _totale_ordine_attivo = ZERO;
        _totale_ordine_passivo = ZERO;
        _sbilancio_ordine = true;
      }
      gia_stampato_conto_ord = true;
    }
    }
    _cont_gcs = 0;
    _cont_num = 0;
    _cont_numr = 0;
    _totale_numero  = 0;
    _totale_numr    = 0;
    _totale_lettera = 0;
  }     
  if (_sez_da_stamp != _sez_tot)
  {
    if (_let_stamp != 'Z')
    {
      if (_sez_stamp != '5')
      {
        if (_cont_gcs != 0)
        {
          //Fai il totale del numero arabo e stampalo
          if (_num.not_empty())
          {
            set_row (_i,FR("@18gTotale@25g%s)"), num2str(_num));
            set_row (_i++,"@81g%r", &_totale_numero);
          }
        }
        if (_cont_num != 0)
        {
          //Fai il totale del numero romano e stampalo
          int numeror = atoi(_numr);
          TString numrom  = itor(numeror);
          if (numrom.not_empty())
          {
            set_row (_i,FR("@14gTotale@21g%s"), (const char*) numrom);
            set_row (_i++,"@81g%r", &_totale_numr);
          }
        }
        if (_cont_numr != 0)
        {
          //Fai il totale della lettera e stampalo
          if (_let != ' ')
          {   
            if ((_sez_stamp == '9' && _let_stamp != 'E') || (_sez_stamp != '9'))
            {
              set_row (_i,FR("@3gTotale@10g%c)"), _let);
              set_row (_i++,"@81g%r", &_totale_lettera);
            }
          }
        }
      }
    }

    if (!_totale_attivita_gia_stampato)
      if ((_sez_stamp == '1') && (_let_stamp != 'Z'))
      {
        char app = ' ';
        set_row (_i++,"@0g%c", app);
        set_row (_i,TR("TOTALE ATTIVO"));
        set_row (_i++,"@81g%r", &_totale_sezione);
        _totale_attivita = _totale_sezione;
        _totale_sezione = ZERO;
      }
    
    if (!_totale_passivita_gia_stampato)
      if ((_sez_stamp == '2') && (_let_stamp != 'Z'))
      {
				char app = ' ';
				set_row(_i++, "@0g%c", app);
        set_row (_i,TR("TOTALE PASSIVO"));
        set_row (_i++,"@81g%r", &_totale_sezione);
        _totale_passivita = _totale_sezione;
        _totale_sezione = ZERO;
      }  
    
    if (!gia_stampato_conto_ord)
    {  
      if (_sez_stamp == '2')
      {
        if (!_sbilancio_patr_gia_stampato)
        {                              
          _totale_patrimoniale = _totale_attivita - _totale_passivita;
          if (_totale_patrimoniale != ZERO)
          { 
            char app = ' ';
            set_row (_i++,"@0g%c", app);
            set_row (_i++,TR("SALDO STATO PATRIMONIALE"));
            set_row (_i,TR("SBILANCIO (ATTIVO - PASSIVO)"));
            set_row (_i++,"@81g%r", &_totale_patrimoniale);
            _totale_patrimoniale = ZERO;   
          }      
          _sbilancio_patr_gia_stampato = true;
        }
      }
      if ((_sez_stamp == '1')&&(_let_stamp == 'Z'))
      {
        char app = ' ';
        set_row (_i++,"@0g%c", app);
        set_row (_i,TR("TOTALE CONTI D'ORDINE ATTIVI"));
        set_row (_i++,"@81g%r", &_totale_ordine_attivo);
      }
      if ((_sez_stamp == '2')&&(_let_stamp == 'Z'))
      {
        char app = ' ';
        set_row (_i++,"@0g%c", app);
        set_row (_i,TR("TOTALE CONTI D'ORDINE PASSIVI"));  
        set_row (_i++,"@81g%r", &_totale_ordine_passivo);  
        _i++;   
        if (!_sbilancio_ordine)
        {
          real totale = _totale_ordine_attivo - _totale_ordine_passivo;   

					if (totale != ZERO)
          {                           
            set_row (_i++,"@0g%c", app);
            set_row (_i++,TR("SALDO CONTI D'ORDINE"));
            set_row (_i,TR("SBILANCIO"));    
            set_row (_i++,"@81g%r", &totale);   
            _sbilancio_ordine = true;
          }
          _totale_ordine_passivo = ZERO; 
          _totale_ordine_attivo = ZERO; 
        }
      }
    }

    if (_sez_stamp == '2')
    {  
      char app = ' ';
       
      if (!_sbilancio_patr_gia_stampato)
      {
        _totale_patrimoniale = _totale_attivita - _totale_passivita;  
        if (_totale_patrimoniale != ZERO)
        {
          set_row (_i++,"@0g%c", app);
          set_row (_i++,TR("SALDO STATO PATRIMONIALE"));
          set_row (_i,TR("SBILANCIO (ATTIVO - PASSIVO)"));
          set_row (_i++,"@81g%r", &_totale_patrimoniale);
          _totale_patrimoniale = ZERO;   
        }
      }
      if (!_sbilancio_ordine)
      {
        real totale = _totale_ordine_attivo - _totale_ordine_passivo;

				if (totale != ZERO && !_sbilancio_ordine)
        {   
          set_row (_i++,"@0g%c", app);
          set_row (_i++,TR("SALDO CONTI D'ORDINE"));
          set_row (_i,TR("SBILANCIO"));    
          set_row (_i++,"@81g%r", &totale);
        }
      }
    }
    if (_sez_stamp == '5')
    {
      char app = ' ';
      set_row (_i++,"@0g%c", app);
      set_row (_i,TR("TOTALE CONTI D'ORDINE"));
      set_row (_i++,"@81g%r", &_totale_ordine);
      _totale_ordine = ZERO;
    }
    
    if (_sez_stamp == '9')
    { 
      if (_buff == NULL) 
      {  
        if ((_let_stamp == 'A' || _let_stamp == 'B') && _diffprod_fatto)//Solo se esiste una delle due lettere
        {               
          set_row (_i++,FR("@4gDifferenza tra valore e costi della produzione@81g%r"), &_totale_economico);
          _diffprod_fatto = false;
        }
      }  
      
      char app = ' ';
      set_row (_i++,"@0g%c", app);  
      if (_totale_economico != ZERO)
      {
        set_row (_i,TR("RISULTATO CONTO ECONOMICO"));
        set_row (_i++,"@81g%r", &_totale_economico);
        _totale_economico = ZERO;
      }
    }
    _cont_gcs = 0;
    _cont_num = 0;
    _cont_numr = 0;
    _cont_let = 0;
    _totale_numero  = 0;
    _totale_numr    = 0;
    _totale_lettera = 0;
  }
}

void TStampa_IVdirettiva::stampa_totali_con_raffronto()
{
  bool gia_stampato_conto_ord = false;
  const char* const diff_prod = "9B";

  TString16 classe;
  classe.format("%c%c%8s%s", _sez_da_stamp,_let_da_stamp,(const char*)_numr_da_stamp,(const char*)_num_da_stamp);
  
  _num  = _num_tot;
  _numr = _numr_tot;
  _let  = _let_tot;
  
  if (_buff == NULL) 
  {
    _num_tot  = "";
    _numr_tot = "";
    _let_tot  = ' ';
    _sez_tot  = ' ';
  }    
   
  if ((_sez_stamp == '1' || _sez_stamp == '2') && _let_stamp != 'Z')  
    _attivo_o_passivo = true;
     
  if (_num_da_stamp!=_num_tot)
  {
    if (_let_stamp != 'Z')
    {
      if (_sez_stamp != '5' && _cont_gcs != 0)
      {
        //Fai il totale del numero arabo e stampalo
        if (_num.not_empty())
        {
          set_row (_i,FR("@18gTotale %s)"), num2str(_num));
          set_row (_i,"@81g%r", &_totale_numero);
          set_row (_i++,"@111g%r", &_totale_num_raf);
        }
      }
    }  

    _cont_gcs = 0;
    _totale_numero  = 0;
    _totale_num_raf = 0;
  }
  if (_numr_da_stamp!=_numr_tot)
  {
    if (_let_stamp != 'Z')
    {
      if (_sez_stamp != '5')
      { 
        if (_cont_gcs != 0)
        {
          //Fai il totale del numero arabo e stampalo
          if (_num.not_empty())
          {
            set_row (_i,FR("@18gTotale %s)"), num2str(_num));
            set_row (_i,"@81g%r", &_totale_numero);
            set_row (_i++,"@111g%r", &_totale_num_raf);
          }
        }
        
        if (_cont_num != 0)
        {
          //Fai il totale del numero romano e stampalo
          int numeror = atoi(_numr);
          TString16 numrom  = itor(numeror);
          if (numrom.not_empty())
          {
            set_row (_i,FR("@14gTotale %s"), (const char*) numrom);
            set_row (_i,"@81g%r", &_totale_numr);
            set_row (_i++,"@111g%r", &_totale_numr_raf);
          }
        }
      }
    }
    _cont_gcs = 0;
    _cont_num = 0;
    _totale_numero   = 0;
    _totale_numr     = 0;
    _totale_num_raf  = 0;
    _totale_numr_raf = 0;
  }   
  if (_let_da_stamp!=_let_tot)
  {
    if (_sez_stamp == '9')
    {
      TString16 classe;
      
      classe.format("%c%c%8s%s",_sez_stamp,_let_stamp,(const char*)_numr_stamp,(const char*)_num_stamp);
       
      if (_cont_gcs != 0)
      {
        //Fai il totale del numero arabo e stampalo
        if (_num.not_empty())
        {
          set_row (_i,FR("@18gTotale %s)"), num2str(_num)); 
          set_row (_i++,"@81g%r", &_totale_numero);
        }
      }
      if (_cont_num != 0)
      {
        //Fai il totale del numero romano e stampalo
        int numeror = atoi(_numr);
        TString numrom  = itor(numeror);
        if (numrom.not_empty())
        {
          set_row (_i,FR("@14gTotale %s"), (const char*) numrom);
          set_row (_i++,"@81g%r", &_totale_numr);
        }
      }
      if (_cont_numr != 0)
      {
        //Fai il totale della lettera e stampalo  
        if (_let_stamp == 'D')
          set_row (_i,FR("@4gTotale delle rettifiche"));
        else
        {
          if (_let != ' ')
            if (_sez_stamp == '9' && _let_stamp != 'E')
              set_row (_i,FR("@3gTotale %c)"), _let); 
            else
              if (_sez_stamp != '9')
                set_row (_i,FR("@3gTotale %c)"), _let);
          set_row (_i,FR("@3gTotale %c)"), _let);
        }
        if (_let != ' ')
        {
          if (_sez_stamp == '9' && _let_stamp != 'E')
          {        
            set_row (_i,"@81g%r", &_totale_lettera);  
            set_row (_i++,"@111g%r", &_totale_let_raf);   
          }
          else
            if (_sez_stamp != '9')
            {
              set_row (_i,"@81g%r", &_totale_lettera);  
              set_row (_i++,"@111g%r", &_totale_let_raf); 
            }
        }
      } 
      if (classe > diff_prod && _diffprod_fatto)
      { 
        if (_let_tot == 'A' || _let_tot == 'B')
        {               
          set_row (_i++,FR("@4gDifferenza tra valore e costi della produzione@81g%r@111g%r"), &_totale_economico,&_totale_economico_raf);
          _diffprod_fatto = false;
        }
      }
      
    }
    else
    {
    if (_let_stamp != 'Z')
    {
      if (_sez_stamp != '5')
      {
        if (_cont_gcs != 0)
        {
          //Fai il totale del numero arabo e stampalo
          if (_num.not_empty())
          {
            set_row (_i,FR("@18gTotale@25g%s)"), num2str(_num));
            set_row (_i,"@81g%r", &_totale_numero);
            set_row (_i++,"@111g%r", &_totale_num_raf); 
          }
        }
        if (_cont_num != 0)
        {
          //Fai il totale del numero romano e stampalo
          int numeror = atoi(_numr);
          TString numrom  = itor(numeror);
          if (numrom.not_empty())
          {
            set_row (_i,FR("@14gTotale@21g%s"), (const char*) numrom);
            set_row (_i,"@81g%r", &_totale_numr);
            set_row (_i++,"@111g%r", &_totale_numr_raf);
          }
        }
        if (_cont_numr != 0)
        {
          //Fai il totale della lettera e stampalo
          if (_let != ' ')
          {
            set_row (_i,FR("@3gTotale %c)"), _let);
            set_row (_i,"@81g%r", &_totale_lettera);
            set_row (_i++,"@111g%r", &_totale_let_raf);  
          }
        }
      }
    }
    
    if ((_sez_stamp == '1')&&(_let_da_stamp == 'Z'))
    {
      char app = ' ';
      set_row (_i++,"@0g%c", app);
      set_row (_i,TR("TOTALE ATTIVO"));   
      set_row (_i,"@81g%r", &_totale_sezione);
      set_row (_i++,"@111g%r", &_totale_sez_raf);
      _totale_attivita = _totale_sezione;
      _totale_attiv_raf = _totale_sez_raf;
      _totale_sezione = ZERO;
      _totale_sez_raf = ZERO;
      _totale_attivita_gia_stampato = true;
    }
    
    if ((_sez_stamp == '2')&&(_let_da_stamp == 'Z'))
    {
			char app = ' ';
			set_row(_i++, "@0g%c", app);
      set_row (_i,TR("TOTALE PASSIVO"));
      set_row (_i,"@81g%r", &_totale_sezione);
      set_row (_i++,"@111g%r", &_totale_sez_raf);
      _totale_passivita = _totale_sezione;
      _totale_passiv_raf = _totale_sez_raf;
      _totale_sezione = ZERO;
      _totale_sez_raf = ZERO;
      _totale_passivita_gia_stampato = true;
    }
    
    if ((_sez_stamp == '1')&&(_let_stamp == 'Z'))
    {
      char app = ' ';
      set_row (_i++,"@0g%c", app);
      set_row (_i,TR("TOTALE CONTI D'ORDINE ATTIVI"));
      set_row (_i,"@81g%r", &_totale_ordine_attivo);
      set_row (_i++,"@111g%r", &_totale_ordine_attivo_raf);
      gia_stampato_conto_ord = true;
    }
    
    if ((_sez_stamp == '2')&&(_let_stamp == 'Z'))
    {
      char app = ' ';
      set_row (_i++,"@0g%c", app);
      set_row (_i,TR("TOTALE CONTI D'ORDINE PASSIVI"));
      set_row (_i,"@81g%r", &_totale_ordine_passivo);
      set_row (_i++,"@111g%r", &_totale_ordine_passivo_raf);
      _i++; 
      gia_stampato_conto_ord     = true;
      if (!_attivo_o_passivo)
      {
        real totale  = _totale_ordine_attivo - _totale_ordine_passivo; 
        real tot_raf = _totale_ordine_attivo_raf - _totale_ordine_passivo_raf; 

				if (totale != ZERO || tot_raf != ZERO)
        {
          set_row (_i++,TR("SALDO CONTI D'ORDINE"));
          set_row (_i,TR("SBILANCIO"));     
          set_row (_i,"@81g%r", &totale); 
          set_row (_i++,"@111g%r", &tot_raf);
        }
        _totale_ordine_attivo      = ZERO;
        _totale_ordine_attivo_raf  = ZERO;
        _totale_ordine_passivo     = ZERO;
        _totale_ordine_passivo_raf = ZERO; 
        _sbilancio_ordine = true;
        _sbilancio_patr_gia_stampato = true; //Se passa di qui non ci sono ne attivi ne passivo
      }
    }
    }
    _cont_gcs = 0;
    _cont_num = 0;
    _cont_numr = 0;
    _totale_numero   = 0;
    _totale_numr     = 0;
    _totale_lettera  = 0;
    _totale_num_raf  = 0;
    _totale_numr_raf = 0;
    _totale_let_raf  = 0;
  }     
  if (_sez_da_stamp != _sez_tot)
  {
    if (_let_stamp != 'Z')
    { 
      if (_sez_stamp != '5')
      {
        if (_cont_gcs != 0)
        {
          //Fai il totale del numero arabo e stampalo
          if (_num.not_empty())
          {
            set_row (_i,FR("@18gTotale %s)"), num2str(_num));
            set_row (_i,"@81g%r", &_totale_numero);
            set_row (_i++,"@111g%r", &_totale_num_raf);
          }
        }
        if (_cont_num != 0)
        {
          //Fai il totale del numero romano e stampalo
          int numeror = atoi(_numr);
          TString numrom  = itor(numeror);       
          if (numrom.not_empty())
          {
            set_row (_i,FR("@14gTotale %s"), (const char*) numrom);
            set_row (_i++,"@81g%r", &_totale_numr);
            set_row (_i++,"@111g%r", &_totale_numr_raf);
          }
        }
        if (_cont_numr != 0)
        {
          //Fai il totale della lettera e stampalo
          if (_let != ' ')
          { 
            if (_sez_stamp == '9' && _let_stamp != 'E')
            {
              set_row (_i,FR("@3gTotale %c)"), _let);
              set_row (_i++,"@81g%r", &_totale_lettera);
              set_row (_i++,"@111g%r", &_totale_let_raf);
            }
            else
              if (_sez_stamp != '9')
              {
                set_row (_i,FR("@3gTotale %c)"), _let);
                set_row (_i++,"@81g%r", &_totale_lettera);
                set_row (_i++,"@111g%r", &_totale_let_raf);
              }
          }
        }
      }
    }

    if (!_totale_attivita_gia_stampato)
      if ((_sez_stamp == '1') && (_let_stamp != 'Z'))
      {
        char app = ' ';
        set_row (_i++,"@0g%c", app);
        set_row (_i,TR("TOTALE ATTIVO"));
        set_row (_i,"@81g%r", &_totale_sezione);
        set_row (_i++,"@111g%r", &_totale_sez_raf);
        _totale_attivita = _totale_sezione;
        _totale_attiv_raf = _totale_sez_raf;
        _totale_sezione = ZERO;
        _totale_sez_raf = ZERO;
        _totale_attivita_gia_stampato = true;
      }
    
    if (!_totale_passivita_gia_stampato)
      if ((_sez_stamp == '2') && (_let_stamp != 'Z'))
      {
				char app = ' ';
				set_row(_i++, "@0g%c", app);
        set_row (_i,TR("TOTALE PASSIVO"));
        set_row (_i,"@81g%r", &_totale_sezione);
        set_row (_i++,"@111g%r", &_totale_sez_raf);
        _totale_passivita = _totale_sezione;
        _totale_passiv_raf = _totale_sez_raf;
        _totale_sezione = ZERO;
        _totale_sez_raf = ZERO;
        _totale_passivita_gia_stampato = true;
      }  
    
    if (!gia_stampato_conto_ord)
    { 
      if (_sez_stamp == '2')
      {
        if (!_sbilancio_patr_gia_stampato)
        {
          _totale_patrimoniale = _totale_attivita - _totale_passivita;
          _totale_patrim_raf   = _totale_attiv_raf - _totale_passiv_raf;
          if (_totale_patrimoniale != ZERO || _totale_patrim_raf != ZERO)
          { 
            char app = ' ';
            set_row (_i++,"@0g%c", app);
            set_row (_i++,TR("SALDO STATO PATRIMONIALE"));
            set_row (_i,TR("SBILANCIO (ATTIVO - PASSIVO)"));
            set_row (_i,"@81g%r", &_totale_patrimoniale);
            set_row (_i++,"@111g%r", &_totale_patrim_raf);
            _totale_patrimoniale = 0;
            _totale_patrim_raf   = 0;
          }
          _sbilancio_patr_gia_stampato = true; 
        }
      } 
      if ((_sez_stamp == '1')&&(_let_stamp == 'Z'))
      {
        char app = ' ';
        set_row (_i++,"@0g%c", app);
        set_row (_i,TR("TOTALE CONTI D'ORDINE ATTIVI"));
        set_row (_i,"@81g%r", &_totale_ordine_attivo);   
        set_row (_i++,"@111g%r", &_totale_ordine_attivo_raf);
      }
      
      if ((_sez_stamp == '2')&&(_let_stamp == 'Z'))
      {
        char app = ' ';
        set_row (_i++,"@0g%c", app);
        set_row (_i,TR("TOTALE CONTI D'ORDINE PASSIVI"));
        set_row (_i,"@81g%r", &_totale_ordine_passivo);  
        set_row (_i++,"@111g%r", &_totale_ordine_passivo_raf);
        _i++;  
        if (!_sbilancio_ordine)
        {
          real totale  = _totale_ordine_attivo - _totale_ordine_passivo; 
          real tot_raf = _totale_ordine_attivo_raf - _totale_ordine_passivo_raf;

					if (totale != ZERO || tot_raf != ZERO)
          {                                 
            set_row (_i++,"@0g%c", app);
            set_row (_i++,TR("SALDO CONTI D'ORDINE"));
            set_row (_i,TR("SBILANCIO"));    
            set_row (_i,"@81g%r", &totale); 
            set_row (_i++,"@111g%r", &tot_raf); 
            _sbilancio_ordine = true;
          }
          _totale_ordine_attivo      = ZERO;
          _totale_ordine_attivo_raf  = ZERO;
          _totale_ordine_passivo     = ZERO;
          _totale_ordine_passivo_raf = ZERO; 
          _sbilancio_ordine = true; 
        }
      }
    }

    if (_sez_stamp == '2')
    {
      char app = ' ';  
      if (!_sbilancio_patr_gia_stampato)
      {                                             
        _totale_patrimoniale = _totale_attivita - _totale_passivita;
        _totale_patrim_raf   = _totale_attiv_raf - _totale_passiv_raf; 
        if (_totale_patrimoniale != ZERO || _totale_patrim_raf != ZERO)
        {
          set_row (_i++,"@0g%c", app);
          set_row (_i++,TR("SALDO STATO PATRIMONIALE"));
          set_row (_i,TR("SBILANCIO (ATTIVO - PASSIVO)"));
          set_row (_i,"@81g%r", &_totale_patrimoniale);
          set_row (_i++,"@111g%r", &_totale_patrim_raf);
          _totale_patrimoniale = 0;
          _totale_patrim_raf   = 0;
        } 
      }
      if (!_sbilancio_ordine)
      {
        real totale  = _totale_ordine_attivo - _totale_ordine_passivo; 
        real tot_raf = _totale_ordine_attivo_raf - _totale_ordine_passivo_raf;

				if ((totale != ZERO || tot_raf != ZERO) && !_sbilancio_ordine)
        {                               
          set_row (_i++,"@0g%c", app);
          set_row (_i++,TR("SALDO CONTI D'ORDINE"));
          set_row (_i,TR("SBILANCIO"));    
          set_row (_i,"@81g%r", &totale); 
          set_row (_i++,"@111g%r", &tot_raf);
        }
      }  
    }
    if (_sez_stamp == '5')
    {
      char app = ' ';
      set_row (_i++,"@0g%c", app);
      set_row (_i,TR("TOTALE CONTI D'ORDINE"));
      set_row (_i,"@81g%r", &_totale_ordine);
      set_row (_i++,"@111g%r", &_totale_ordine_raf);
      _totale_ordine = 0;
      _totale_ordine_raf = 0;
    }
    if (_sez_stamp == '9')
    {     
      if (_buff == NULL) 
      { 
        if ((_let_stamp == 'A' || _let_stamp == 'B') && _diffprod_fatto)
        {               
          set_row (_i++,FR("@4gDifferenza tra valore e costi della produzione@81g%r@111g%r"), &_totale_economico,&_totale_economico_raf);
          _diffprod_fatto = false;
        }
      }
      char app = ' ';
      set_row (_i++,"@0g%c", app);   
      if (_totale_economico != ZERO || _totale_economico_raf != ZERO)
      {
        set_row (_i,TR("RISULTATO CONTO ECONOMICO"));
        set_row (_i,"@81g%r", &_totale_economico);
        set_row (_i++,"@111g%r", &_totale_economico_raf);
        _totale_economico = ZERO;
        _totale_economico_raf = ZERO;
      }
    }
    _cont_gcs = 0;
    _cont_num = 0;
    _cont_numr = 0;
    _cont_let = 0;
    _totale_numero   = 0;
    _totale_numr     = 0;
    _totale_lettera  = 0;
    _totale_num_raf  = 0;
    _totale_numr_raf = 0;
    _totale_let_raf  = 0;
  }
}  

void TStampa_IVdirettiva::stampa_totali_verifica()
{
  const char* const ris_imp = "9E        21";
  bool total_printed = false;
  
	_num  = _num_tot;
  _numr = _numr_tot;
  _let  = _let_tot;
  _sez  = _sez_tot;

  if (_buff == NULL) 
  {
    _num_tot  = "";
    _numr_tot = "";
    _let_tot  = ' ';
    _sez_tot  = ' ';
  }    

  if (_num_da_stamp!=_num_tot)
  {
    if (_cont_gcs != 0)
    {
      //Fai il totale del numero arabo e stampalo
      if (((_sez == '1')||(_sez == '2')||(_sez == '9'))&&(_let != 'Z'))
      {    
        if (_num.not_empty())
        {
          set_row (_i,FR("@8gTotale@15g%s)"), num2str(_num));
          total_printed = true;
        }  
      }
      else
        if (_num.not_empty())         
        {
          set_row (_i,FR("@8gTotale"));   
          total_printed = true;
        }  
      
      if (_num.not_empty())
      { 
        if (_tot_num_prg_d != ZERO)   
          set_row (_i,"@47g%r", &_tot_num_prg_d);
        if (_tot_num_prg_a != ZERO)   
          set_row (_i,"@64g%r", &_tot_num_prg_a);
				if (_tot_num_mov_d != ZERO)
					set_row (_i,"@81g%r", &_tot_num_mov_d);
				if (_tot_num_mov_a != ZERO)
					set_row (_i,"@98g%r", &_tot_num_mov_a);
	      if (!_stampa_modulo)
          stampa_saldo_132(_tot_num_saldo);
		    else
          stampa_saldo_198(_tot_num_saldo_d,_tot_num_saldo_a);
      } 
      if (_sez_stamp == '9')
      {
        TString16 classe;

        classe.format("%c%c%8s%s", _sez_da_stamp,_let_da_stamp,(const char*)_numr_da_stamp,(const char*)_num_da_stamp);
      
        if (classe > ris_imp && !_risimp_fatto)
        { 
          if (_num_tot == "20" || _num_tot == "21")
          {                     
            set_row (_i,FR("@4gTotale delle partite straordinarie"));
            if (_tot_parz_prg_d != ZERO)   
              set_row (_i,"@47g%r", &_tot_parz_prg_d);
            if (_tot_parz_prg_a != ZERO)   
              set_row (_i,"@64g%r", &_tot_parz_prg_a);
						if (_tot_parz_mov_d != ZERO)
							set_row (_i,"@81g%r", &_tot_parz_mov_d);
						if (_tot_parz_mov_a != ZERO)
							set_row (_i,"@98g%r", &_tot_parz_mov_a);
            _risimp_fatto = true;  
            if (_num.not_empty())  
						{
	            if (!_stampa_modulo)
                stampa_saldo_132(_tot_parz_sld);
		          else
                stampa_saldo_198(_tot_parz_sld_d,_tot_parz_sld_a);
            } 
          }
        }
      }
    }
    _cont_gcs = 0;
    _tot_num_prg_d = ZERO;
    _tot_num_prg_a = ZERO;
    _tot_num_mov_d = ZERO;
    _tot_num_mov_a = ZERO;
    _tot_num_saldo = ZERO;
  }
  if (_numr_da_stamp!=_numr_tot)
  {
    if (_cont_gcs != 0)
    {
      //Fai il totale del numero arabo e stampalo
      if (((_sez == '1')||(_sez == '2')||(_sez == '9'))&&(_let != 'Z'))
      { 
        if (_num.not_empty())
        {                      
          if (total_printed) _i++;
          set_row (_i,FR("@8gTotale@15g%s)"), num2str(_num));
          total_printed = true;
        }  
      }
      else    
        if (_num.not_empty())
        { 
          if (total_printed) _i++;
          set_row (_i,FR("@8gTotale"));
          total_printed = true;
        }  
          
      if (_num.not_empty())
      {    
        if (_tot_num_prg_d != ZERO)   
          set_row (_i,"@47g%r", &_tot_num_prg_d);
        if (_tot_num_prg_a != ZERO)   
          set_row (_i,"@64g%r", &_tot_num_prg_a);
				if (_tot_num_mov_d != ZERO)
					set_row (_i,"@81g%r", &_tot_num_mov_d);
				if (_tot_num_mov_a != ZERO)
					set_row (_i,"@98g%r", &_tot_num_mov_a);
				if (!_stampa_modulo)
          stampa_saldo_132(_tot_num_saldo);
	      else
          stampa_saldo_198(_tot_num_saldo_d,_tot_num_saldo_a);
      }
    }
    if (_cont_num != 0)
    {
      //Fai il totale del numero romano e stampalo
      int numeror = atoi(_numr);
      TString numrom  = itor(numeror);  
      if (numrom.not_empty())
      {   
        if (total_printed) _i++;
        set_row (_i,FR("@8gTotale@15g%s"), (const char*) numrom);
        total_printed = true;
        
        if (_tot_numr_prg_d != ZERO)   
          set_row (_i,"@47g%r", &_tot_numr_prg_d);
        if (_tot_numr_prg_a != ZERO)   
          set_row (_i,"@64g%r", &_tot_numr_prg_a);
				if (_tot_numr_mov_d != ZERO)
	        set_row (_i,"@81g%r", &_tot_numr_mov_d);
				if (_tot_numr_mov_a != ZERO)
					set_row (_i,"@98g%r", &_tot_numr_mov_a);
				if (!_stampa_modulo)
          stampa_saldo_132(_tot_numr_saldo);
				else
          stampa_saldo_198(_tot_numr_saldo_d,_tot_numr_saldo_a);
      }
    }
    _cont_gcs = 0;
    _cont_num = 0;
    _tot_num_prg_d  = ZERO;
    _tot_num_prg_a  = ZERO;
    _tot_num_mov_d  = ZERO;
    _tot_num_mov_a  = ZERO;
    _tot_num_saldo  = ZERO;
    _tot_numr_prg_d = ZERO;
    _tot_numr_prg_a = ZERO;
    _tot_numr_mov_d = ZERO;
    _tot_numr_mov_a = ZERO;
    _tot_numr_saldo = ZERO;      
  }   
  if ((_let_da_stamp!=_let_tot) || (_sez_da_stamp != _sez_tot))
  {
    if (_cont_gcs != 0)
    {
      //Fai il totale del numero arabo e stampalo
      if (((_sez == '1')||(_sez == '2')||(_sez == '9'))&&(_let != 'Z'))
      {  
        if (_num.not_empty())        
        {
          if (total_printed) _i++;
          set_row (_i,FR("@8gTotale@15g%s)"), num2str(_num));
          total_printed = true;
        }  
      }
      else
        if (_num.not_empty())
        {
          if (total_printed) _i++;
          set_row (_i,FR("@8gTotale"));
          total_printed = true;
        }  
  
      if (_num.not_empty())
      {
        if (_tot_num_prg_d != ZERO)   
          set_row (_i,"@47g%r", &_tot_num_prg_d);
        if (_tot_num_prg_a != ZERO)   
          set_row (_i,"@64g%r", &_tot_num_prg_a);
				if (_tot_num_mov_d != ZERO)
					set_row (_i,"@81g%r", &_tot_num_mov_d);
				if (_tot_num_mov_a != ZERO)
					set_row (_i,"@98g%r", &_tot_num_mov_a);
	      if (!_stampa_modulo)
          stampa_saldo_132(_tot_num_saldo);
		    else
          stampa_saldo_198(_tot_num_saldo_d,_tot_num_saldo_a);
      } 
    }
    if (_cont_num != 0)
    {
      //Fai il totale del numero romano e stampalo
      int numeror = atoi(_numr);
      TString numrom  = itor(numeror);
      if (numrom.not_empty())
      {
        if (total_printed) _i++;
        set_row (_i, FR("@8gTotale@15g%s"), (const char*)numrom);
        total_printed = true;
        
        if (_tot_numr_prg_d != ZERO)   
          set_row (_i,"@47g%r", &_tot_numr_prg_d);
        if (_tot_numr_prg_a != ZERO)   
          set_row (_i,"@64g%r", &_tot_numr_prg_a);
				if (_tot_numr_mov_d != ZERO)
					set_row (_i,"@81g%r", &_tot_numr_mov_d);
				if (_tot_numr_mov_a != ZERO)
					set_row (_i,"@98g%r", &_tot_numr_mov_a);
	      if (!_stampa_modulo)
          stampa_saldo_132(_tot_numr_saldo);
	      else
          stampa_saldo_198(_tot_numr_saldo_d,_tot_numr_saldo_a);
      }
    }
    if (_cont_numr != 0)
    {
      //Fai il totale della lettera e stampalo   
      if (_let != ' ')
      { 
        if (_sez_stamp == '9' && _let_stamp != 'E')
        {                  
          if (total_printed) _i++;
          set_row (_i,FR("@8gTotale@15g%c)"), _let);
          total_printed = true;

          if (_tot_let_prg_d != ZERO)   
            set_row (_i,"@47g%r", &_tot_let_prg_d);
          if (_tot_let_prg_a != ZERO)   
            set_row (_i,"@64g%r", &_tot_let_prg_a);
					if (_tot_let_mov_d != ZERO)
	          set_row (_i,"@81g%r", &_tot_let_mov_d);
					if (_tot_let_mov_a != ZERO)
						set_row (_i,"@98g%r", &_tot_let_mov_a);
        }
        else
          if (_sez_stamp != '9')
          {                    
            if (total_printed) _i++;
            set_row (_i,FR("@8gTotale@15g%c)"), _let);
            total_printed = true;
            
            if (_tot_let_prg_d != ZERO)   
              set_row (_i,"@47g%r", &_tot_let_prg_d);
            if (_tot_let_prg_a != ZERO)   
              set_row (_i,"@64g%r", &_tot_let_prg_a);
						if (_tot_let_mov_d != ZERO)
							set_row (_i,"@81g%r", &_tot_let_mov_d);
						if (_tot_let_mov_a != ZERO)
							set_row (_i,"@98g%r", &_tot_let_mov_a);
          }
      }

      if (!_stampa_modulo)
      {
        if (_let != ' ') 
          if (_sez_stamp == '9' && _let_stamp != 'E')  
            stampa_saldo_132(_tot_let_saldo);
          else
            if (_sez_stamp != '9')
              stampa_saldo_132(_tot_let_saldo);
      }
      else
      {   
        if (_let != ' ')                       
          if (_sez_stamp == '9' && _let_stamp != 'E')
            stampa_saldo_198(_tot_let_saldo_d,_tot_let_saldo_a);
          else
            stampa_saldo_198(_tot_let_saldo_d,_tot_let_saldo_a);
      } 
    }
    _cont_gcs = 0;
    _cont_num = 0;
    _cont_numr = 0;
    _tot_num_prg_d  = ZERO;
    _tot_num_prg_a  = ZERO;
    _tot_num_mov_d  = ZERO;
    _tot_num_mov_a  = ZERO;
    _tot_num_saldo  = ZERO;
    _tot_numr_prg_d = ZERO;
    _tot_numr_prg_a = ZERO;
    _tot_numr_mov_d = ZERO;
    _tot_numr_mov_a = ZERO;
    _tot_numr_saldo = ZERO;      
    _tot_let_prg_d  = ZERO;
    _tot_let_prg_a  = ZERO;
    _tot_let_mov_d  = ZERO;
    _tot_let_mov_a  = ZERO;
    _tot_let_saldo  = ZERO;      
  }     
}

void TStampa_IVdirettiva::stampa_saldo_198(real& saldo_d,real& saldo_a)
{ 
	set_row(_i, "@46g!@80g!@114g!");
	if (saldo_d != ZERO)
		set_row(_i, "%r@132g%r", &saldo_d);
	if (saldo_a != ZERO)
		set_row(_i, "@132g%r", &saldo_a);
	saldo_d = saldo_a = ZERO;
}

void TStampa_IVdirettiva::stampa_saldo_132(const real& saldo)
{
  real sld;
  if (saldo < ZERO)
  {           
    sld = -saldo;
    _tot_sez_saldo = 'A';
  }
  else
  {
    sld = saldo;
    _tot_sez_saldo = 'D';
  }

  set_row (_i,"@46g!@80g!@114g!");
  if (!sld.is_zero())
    set_row (_i,"%r@131g%c", &sld, _tot_sez_saldo);
}

print_action TStampa_IVdirettiva::postprocess_page(int file, int counter)
{ 
  struct bil_ivd* bil = (struct bil_ivd*) _buff;                              

  bil = (struct bil_ivd*) _buff;

  if (_tipo_bilancio == 1)
  {
    if (_sez_da_stamp != _sez_stamp)
    {
      if (_sez_da_stamp == '5')
      { 
        if (!_intera_struttura)
        {
          if (bil->gruppo[0] != 'Z')
          {    
            reset_print();
            _i = 1;
            setta_righe(TR("CONTI D'ORDINE"));
            _reset_righe_stampa = false;
          }
        }
        else
        {
          reset_print();
          _i = 1;
          setta_righe(TR("CONTI D'ORDINE"));
          _reset_righe_stampa = false;
        }  
      }
      if (_sez_da_stamp == '9')
      {                      
        if (!_intera_struttura)
        {
          if (bil->gruppo[0] != 'Z')
          {
            reset_print();
            _i = 1;
            setta_righe(TR("CONTO ECONOMICO"));
            _reset_righe_stampa = false; 
          }
        } 
        else
        {
          reset_print();
          _i = 1;
          setta_righe(TR("CONTO ECONOMICO"));
          _reset_righe_stampa = false;
        }   
      }
    }

    set_auto_ff(false);
  }

  if (_buff == NULL) 
    return NEXT_PAGE;

  _sale     = 0;
  _salerafr = 0;

  return REPEAT_PAGE;
}

bool TStampa_IVdirettiva::preprocess_page(int file, int counter)
{      
  
  bool ok = false;
  if (_tipo_bilancio == 1)
    ok = preprocess_stampa_scalare(counter);
  else
    ok = preprocess_stampa_verifica(counter);

  return ok;
}

bool TStampa_IVdirettiva::preprocess_stampa_scalare(int counter)
{ 
  struct bil_ivd* bil = (struct bil_ivd*) _buff;
  int     g,c;
  long    s;
  bool    fai = true;
  TString saldostr,saldo_rafstr;    
  bool conto_dettagliato = true;
  
  if (!counter)
  {
    reset_print();
    _i = 1;
  }

  if (_reset_righe_stampa)
  {
    reset_print();
    _i = 1;
  }
  else
    _reset_righe_stampa = true;
  
  if (counter)
  {
    if (!_intera_struttura)
    {
      if (bil->gruppo[0] != 'Z')
      {
        _sez_stamp  = bil->sez;
        _let_stamp  = bil->let;
        _numr_stamp = bil->numr;
        _numr_stamp.ltrim();
        _num_stamp  = bil->num;
        _num_stamp.trim();
        _sez_tot  = bil->sez;
        _let_tot  = bil->let;
        _numr_tot = bil->numr;
        _numr_tot.ltrim();
        _num_tot  = bil->num;
        _num_tot.trim();
      }
    }
    else
    {
      _classe_stampata.format("%c%c%8s%s",bil->sez,bil->let,bil->numr,bil->num);
      _sez_stamp = bil->sez;
      _let_stamp = bil->let;
      _numr_stamp = bil->numr;
      _numr_stamp.ltrim();
      _num_stamp  = bil->num;
      _num_stamp.trim();
      _sez_tot = bil->sez;
      _let_tot = bil->let;
      _numr_tot = bil->numr;
      _numr_tot.ltrim();
      _num_tot = bil->num;
      _num_tot.trim();
    }
  }

  _buff = _sort->retrieve();

  if (_buff == NULL)
  {
    if (_annoeserafr == 0 && _databilrafr == botime)
      stampa_totali();
    else
      stampa_totali_con_raffronto();
    _sez_da_stamp = ' ';
    _sez_stamp    = ' ';
    return true;
  }

  if (_buff != NULL)
  {
    bil = (struct bil_ivd*) _buff;
    _classe_da_stampare.format("%c%c%8s%s",bil->sez,bil->let,bil->numr,bil->num);
    _sez_da_stamp  = bil->sez;
    _let_da_stamp  = bil->let;
    _numr_da_stamp = bil->numr;
    _numr_da_stamp.ltrim();
    _num_da_stamp  = bil->num;
    _num_da_stamp.trim();
    g = atoi(bil->gruppo);
    c = atoi(bil->conto);
    s = atol(bil->sottoc);      
    conto_dettagliato = bil->conto_dettagliato;

    if (_intera_struttura)
      fai = true;
    else
    {
      if (bil->gruppo[0] != 'Z')
        fai = true;
      else
        fai = false;
    }

    if (counter)
    {
      if (fai)
      {
        if (_annoeserafr == 0 && _databilrafr == botime)
          stampa_totali(); 
        else
          stampa_totali_con_raffronto();       
      }
    }

    //Fare ricerca di dataregmov

    if (!_intera_struttura)
    {
      if (bil->gruppo[0]=='Z')
        return false;
      
      _sale = bil->saldo;
      if (_annoeserafr != 0 || _databilrafr != botime)
        _salerafr = bil->saldorafr;
    }
    else
    {
      if (bil->gruppo[0]=='Z')
        if (_classe_da_stampare == _classe_stampata)
          return false;

      _sale = bil->saldo;
      if (_annoeserafr != 0 || _databilrafr != botime)
        _salerafr = bil->saldorafr;
    }  
    
    saldostr = _sale.string();
    saldo_rafstr = _salerafr.string();
    
    // Faccio passare solo i sottoconti o i conti non dettagliati (che non hanno sottoconti)
    // perchè l' importo dei conti dettagliati non è altri che il totale degli importi di
    // tutti i suoi sottoconti; dunque se li sommassi anche loro, sommerei l'importo due volte.
    // Pero' devo ricordarmi di cambiare ugualmente segno ai conti che vanno dettagliati.
    
    if (g != 0 && c != 0 && s == 0 && conto_dettagliato)
      if (_sez_da_stamp == '9') 
      {
        _sale = -_sale;
        if (_annoeserafr != 0 || _databilrafr != botime)
          _salerafr = -_salerafr;
      }

       
    if ((g != 0 && c != 0 && s != 0)||(g != 0 && c != 0 && s == 0 && !conto_dettagliato))
    {      
      
      if (_sez_da_stamp == '9')
          _sale = -_sale;

      _totale_numero  += _sale;
      _totale_numr    += _sale;
      _totale_lettera += _sale;
      if ((_sez_da_stamp == '1')||(_sez_da_stamp == '2'))
      {
        if (_let_da_stamp != 'Z')
          _totale_sezione += _sale;
        else
        {
          if (_sez_da_stamp == '1')
            _totale_ordine_attivo += _sale;
          else
            if (_sez_da_stamp == '2')
              _totale_ordine_passivo += _sale;
        }
      }
      
      if (_sez_da_stamp == '5')
        _totale_ordine += _sale;

      if (_sez_da_stamp == '9') 
      {
        _totale_economico += _sale; 
        if (_let_da_stamp == 'E' && (_num_da_stamp == "20" || _num_da_stamp == "21"))
          _totale_parziale += _sale;
      }  

      if (_annoeserafr != 0 || _databilrafr != botime)
      {
        if (_sez_da_stamp == '9')
            _salerafr = -_salerafr;

        _totale_num_raf  += _salerafr;
        _totale_numr_raf += _salerafr;
        _totale_let_raf  += _salerafr;
        if ((_sez_da_stamp == '1')||(_sez_da_stamp == '2'))
        {
          if (_let_da_stamp != 'Z')
            _totale_sez_raf  += _salerafr;
          else
          {
            if (_sez_da_stamp == '1')
              _totale_ordine_attivo_raf += _salerafr;
            else
              if (_sez_da_stamp == '2')
                _totale_ordine_passivo_raf += _salerafr;
          }
        }      

        if (_sez_da_stamp == '5')
          _totale_ordine_raf += _salerafr;

        if (_sez_da_stamp == '9') 
        {
          _totale_economico_raf += _salerafr; 
          if (_let_da_stamp == 'E' && (_num_da_stamp == "20" || _num_da_stamp == "21"))
            _totale_parziale_raf += _salerafr;
        }  
      }
    }
    return true;
  }
  else
    return false;  
}

bool TStampa_IVdirettiva::preprocess_stampa_verifica(int counter)
{ 
  struct bil_ivd* bil = (struct bil_ivd*) _buff;
  int     g,c;
  long    s;
  bool    fai = true;
  bool    conto_dettagliato = true;

  if (!counter)
  {
    reset_print();
    _i = 1;
  }
  if (_reset_righe_stampa)
  {
    reset_print();
    _i = 1;
  }
  else
    _reset_righe_stampa = true;
  if (counter)
  {
    if (!_intera_struttura)
    {
      if (bil->gruppo[0] != 'Z')
      {
        _sez_stamp  = bil->sez;
        _let_stamp  = bil->let;
        _numr_stamp = bil->numr;
        _numr_stamp.ltrim();
        _num_stamp  = bil->num;
        _num_stamp.trim();
        _sez_tot  = bil->sez;
        _let_tot  = bil->let;
        _numr_tot = bil->numr;
        _numr_tot.ltrim();
        _num_tot  = bil->num;
        _num_tot.trim();
      }
    }
    else
    {
      _classe_stampata = format ("%c%c%8s%s",bil->sez,bil->let,bil->numr,bil->num);
      _sez_stamp  = bil->sez;
      _let_stamp  = bil->let;
      _numr_stamp = bil->numr;
      _numr_stamp.ltrim();
      _num_stamp  = bil->num;
      _num_stamp.trim();
      _sez_tot  = bil->sez;
      _let_tot  = bil->let;
      _numr_tot = bil->numr;
      _numr_tot.ltrim();
      _num_tot  = bil->num;
      _num_tot.trim();
    }
  }
  _buff = _sort->retrieve();
  if (_buff == NULL) 
  {
    stampa_totali_verifica();
    set_row (_i,FR("@0g****** ******** TOTALE GENERALE")); 
    if (_tot_gen_prg_d != ZERO)   
      set_row (_i,"@47g%r", &_tot_gen_prg_d);
    if (_tot_gen_prg_a != ZERO)   
      set_row (_i,"@64g%r", &_tot_gen_prg_a);
		if (_tot_gen_mov_d != ZERO)
			set_row (_i,"@81g%r", &_tot_gen_mov_d);
		if (_tot_gen_mov_a != ZERO)
			set_row (_i,"@98g%r", &_tot_gen_mov_a);
    
    if (!_stampa_modulo)
      stampa_saldo_132(_tot_gen_saldo);
    else
      stampa_saldo_198(_tot_gen_saldo_d,_tot_gen_saldo_a);
    
    //modifica 05/04/1995
    if ((_tipo_stampa == 1 && _datainizio == _data_inizio_es) || _tipo_stampa == 2)
    {                        
			const real tot_d = _tot_gen_prg_d + _tot_gen_mov_d;
			const real tot_a = _tot_gen_prg_a + _tot_gen_mov_a;

			_i++;
      if (_tipo_stampa == 1 && _datainizio == _data_inizio_es)
        set_row(_i,FR("****** ******** TOTALE CON MOVIM. DI APERTURA@46g!@80g!@81g%r@98g%r@114g!"),&tot_d, &tot_a);
      else
        set_row(_i,FR("****** ******** TOTALE CON SALDI INIZIALI@46g!@80g!@81g%r@98g%r@114g!"),&tot_d, &tot_a);
    }
    //fine modifica
    
    _sez_da_stamp = ' ';
    _sez_stamp    = ' '; 
    return true;
  }      
  if (_buff != NULL)
  {
    bil = (struct bil_ivd*) _buff;
    _classe_da_stampare = format ("%c%c%8s%s",bil->sez,bil->let,bil->numr,bil->num);
    _sez_da_stamp  = bil->sez;
    _let_da_stamp  = bil->let;
    _numr_da_stamp = bil->numr;
    _numr_da_stamp.ltrim();
    _num_da_stamp  = bil->num;
    _num_da_stamp.trim();
    g = atoi(bil->gruppo);
    c = atoi(bil->conto);
    s = atol(bil->sottoc);  
    conto_dettagliato = bil->conto_dettagliato;

    if (_intera_struttura)
      fai = true;
    else
    {
      if (bil->gruppo[0] != 'Z')
        fai = true;
      else
        fai = false;
    }

    if (counter)
    {
      if (fai)
        stampa_totali_verifica(); 
    }

    _sale          = bil->saldo;
    _sld_prg_dare  = bil->sld_prg_dare;
    _sld_prg_avere = bil->sld_prg_avere;
    _mov_dare      = bil->mov_dare;
    _mov_avere     = bil->mov_avere;
    
    if (!_intera_struttura)
    {
      if (bil->gruppo[0]=='Z')
        return false;
    }
    else
    {
      if (bil->gruppo[0]=='Z')
        if (_classe_da_stampare == _classe_stampata)
          return false;
    }
    if (!_stampasaldizero && _sale.is_zero())
      return false;

    if ((g != 0) && (c != 0) && (s == 0) && (conto_dettagliato))
    {
      if (_sale < ZERO)
      {
        _sale = -_sale;
        _sez_saldo = 'A';
      }
      else
        _sez_saldo = 'D';
    }
    
    if ((g != 0 && c != 0 && s != 0)||(g != 0 && c != 0 && s == 0 && !conto_dettagliato))
    {
      _tot_num_saldo  += _sale;
      _tot_numr_saldo += _sale;
      _tot_let_saldo  += _sale;
      _tot_gen_saldo  += _sale;
      if (_sez_da_stamp == '9') 
        if (_let_da_stamp == 'E' && (_num_da_stamp == "20" || _num_da_stamp == "21"))
          _tot_parz_sld += _sale;

      if (_sale < ZERO)
      {
        _sale = -_sale;
        _sez_saldo = 'A';
        if (_stampa_modulo)
        {
          _tot_num_saldo_a  += _sale;
          _tot_numr_saldo_a += _sale;
          _tot_let_saldo_a  += _sale;
          _tot_gen_saldo_a  += _sale;
          if (_sez_da_stamp == '9') 
            if (_let_da_stamp == 'E' && (_num_da_stamp == "20" || _num_da_stamp == "21"))
              _tot_parz_sld_a += _sale;
        }
      }
      else
      {
        _sez_saldo = 'D';
        if (_stampa_modulo)
        {
          _tot_num_saldo_d  += _sale;
          _tot_numr_saldo_d += _sale;
          _tot_let_saldo_d  += _sale;
          _tot_gen_saldo_d  += _sale;
          if (_sez_da_stamp == '9') 
            if (_let_da_stamp == 'E' && (_num_da_stamp == "20" || _num_da_stamp == "21"))
              _tot_parz_sld_d += _sale;

        }
      }
      
      if (_datainizio == _data_inizio_es)
      {
        //modifica del 27/11/1995
        if (_tipo_stampa == 2)
        {
         real saldo_num = _sld_prg_dare - _sld_prg_avere;

				 if (saldo_num > ZERO)
           _tot_num_prg_d += saldo_num;
         else
         {
          saldo_num = -saldo_num;
          _tot_num_prg_a  += saldo_num;
         }
         real saldo_numr = _sld_prg_dare - _sld_prg_avere;

				 if (saldo_numr > ZERO)
           _tot_numr_prg_d += saldo_numr;
         else                     
         {
          saldo_numr = -saldo_numr;
          _tot_numr_prg_a += saldo_numr;
         }

				 real saldo_let = _sld_prg_dare - _sld_prg_avere;

				 if (saldo_let > ZERO)
           _tot_let_prg_d  += saldo_let;
         else
         {
          saldo_let = -saldo_let;
          _tot_let_prg_a  += saldo_let;
         }
         
				 real saldo_gen = _sld_prg_dare - _sld_prg_avere;
         
				 if (saldo_gen > ZERO)
           _tot_gen_prg_d  += saldo_gen;
         else                                       
         {
          saldo_gen = -saldo_gen;
          _tot_gen_prg_a  += saldo_gen;
         }
        } 
        else
					if (_tipo_stampa == 1)
					{ 
						_tot_num_prg_d += _sld_prg_dare;
						_tot_num_prg_a += _sld_prg_avere;
						_tot_numr_prg_d += _sld_prg_dare;
						_tot_numr_prg_a += _sld_prg_avere;
						_tot_let_prg_d += _sld_prg_dare;
						_tot_let_prg_a += _sld_prg_avere;
						_tot_gen_prg_d += _sld_prg_dare;
						_tot_gen_prg_a += _sld_prg_avere;
					}
      }
      else
      { 
        _tot_num_prg_d  += _sld_prg_dare;
        _tot_numr_prg_d += _sld_prg_dare;
        _tot_let_prg_d  += _sld_prg_dare;
        _tot_gen_prg_d  += _sld_prg_dare;
        _tot_num_prg_a  += _sld_prg_avere;
        _tot_numr_prg_a += _sld_prg_avere;
        _tot_let_prg_a  += _sld_prg_avere;
        _tot_gen_prg_a  += _sld_prg_avere;      
      } 
      _tot_num_mov_d  += _mov_dare;
      _tot_numr_mov_d += _mov_dare;
      _tot_let_mov_d  += _mov_dare;
      _tot_gen_mov_d  += _mov_dare;
      _tot_num_mov_a  += _mov_avere;
      _tot_numr_mov_a += _mov_avere;
      _tot_let_mov_a  += _mov_avere; 
      _tot_gen_mov_a  += _mov_avere;
      if (_sez_da_stamp == '9') 
        if (_let_da_stamp == 'E' && (_num_da_stamp == "20" || _num_da_stamp == "21"))
        {
          _tot_parz_prg_d += _sld_prg_dare;
          _tot_parz_prg_a += _sld_prg_avere;
          _tot_parz_mov_d += _mov_dare;
          _tot_parz_mov_a += _mov_avere;         
        } 
    }
    return true;
  }
  else
    return false;  
}

void TStampa_IVdirettiva::set_page(int file, int counter)
{ 
  if (_tipo_bilancio == 1)  // Bilancio scalare
  {
    if (_sez_da_stamp != _sez_stamp)
    {
      // Controllo se devo stampare STATO PATRIMONIALE
      if (_statopatr_no_stamp && (_sez_da_stamp=='1')||((_sez_da_stamp=='2')))
      {
        setta_righe (TR("STATO PATRIMONIALE"));
        _statopatr_no_stamp = false;
      }
      else  // Guy was here: aggiunto else 18/02/2004 altrimenti fa due volte la setta righe
      {
        if (_sez_da_stamp == '2')
          setta_righe("");
      }
      if ((_sez_da_stamp == '5') || (_sez_da_stamp == '9'))
        set_auto_ff(true);
    }
    else
    {
      if (_buff != NULL)
        setta_righe("");
    }
  }
  else
  {
    if (_buff != NULL)
      setta_righe_verifica();
  }
}

void TStampa_IVdirettiva::setta_righe(const char * titolo)
{
  struct bil_ivd* bil = (struct bil_ivd*) _buff;
  int numeror, gruppo, conto;
  char sezione,lettera;
  long sottoc;
  TString numrom,numr, numero;
  bool stampa_classe = true;
  
  sezione = bil->sez;
  lettera = bil->let;
  numr = bil->numr;
  numeror = atoi(bil->numr);
  numrom  = itor(numeror);
  numero  = bil->num;
	numero.trim();
  gruppo  = atoi(bil->gruppo);
  conto   = atoi(bil->conto);
  sottoc  = atol(bil->sottoc);
  
  //Se la classe prelevata dal record corrente del sort e' diversa dalla classe
  //prelevata dal record precedente, allora stampo la nuova classe con i relativi
  //sottoconti. In caso contrario continuo a stampare solo i sottoconti.
  
  if (_sez_da_stamp != _sez_stamp)   // Cambio sezione
  {
    set_row (_i++, "@0g%s", titolo);
    set_row(_i++,"@0g ");
         
    if (_sez_da_stamp == '1')
    {
      set_row (_i++,"@0g ");   
      if (_let_da_stamp == 'Z')
      {
        set_row (_i++,FR("@0gCONTI D'ORDINE ATTIVI"));
        stampa_classe = false;
      } 
      else
        set_row (_i++,FR("@10gATTIVO"));
			//set_row(_i, FR("@100gDATA1"));
			//set_row(_i, FR("@120gDATA2"));
      set_row (_i++,"@0g ");
    }
        
    if (_sez_da_stamp == '2')
    {
      set_row(_i++,"@0g "); 
      if ((_let_da_stamp == 'Z'))
      {
        set_row (_i++,FR("@0gCONTI D'ORDINE PASSIVI"));
        stampa_classe = false;
      }
      else
        set_row (_i++,FR("@0gPASSIVO"));
      set_row(_i++,"@0g ");
    }

    if (stampa_classe)
    {
      if ((_sez_da_stamp=='1')||(_sez_da_stamp=='2')||(_sez_da_stamp== '9'))
      { 
        if (!_intera_struttura || (_intera_struttura && bil->gruppo[0] != 'Z'))
        {        
          _cont_let  = 1;
          _cont_numr = 1;
          _cont_num  = 1;
          _cont_gcs  = 0;
        }
        if (lettera > ' ')
        {
          set_row(_i,"@0g%c@1g)", lettera);                              
					TParagraph_string s(descrizione_ivd(sezione,lettera, 0, ""), 40);
          setta_righe_descr(s ,"@3g%s");
        }
        if (numrom.not_empty())
        {
          set_row(_i,"@3g%8s@12g-", (const char*) numrom);
					TParagraph_string s(descrizione_ivd(sezione,lettera,numeror, ""), 40);
          setta_righe_descr(s, "@14g%s");
        }
        if (numero.not_empty())
        {
          if (devo_stampare_risultato_prima_delle_imposte())
            stampa_risultato_prima_delle_imposte();          
          
          set_row(_i,"@13g%s)", num2str(numero));
          TParagraph_string s(descrizione_ivd(sezione,lettera,numeror, numero), 32);

          setta_righe_descr(s, "@27g%s");
        }
      }
    }
  }
  else
    if ((_let_da_stamp!=_let_stamp)&&(_sez_da_stamp==_sez_stamp))
    {
      if ((_sez_da_stamp == '1')&&(_let_da_stamp == 'Z'))
      {
        set_row (_i++,"@0g ");   
        set_row (_i++,FR("@0gCONTI D'ORDINE ATTIVI"));
        set_row (_i++,"@0g ");

        stampa_classe = false;
      }
      if ((_sez_da_stamp == '2')&&(_let_da_stamp == 'Z'))
      {
        set_row(_i++,"@0g "); 
        set_row (_i++,FR("@0gCONTI D'ORDINE PASSIVI"));
        set_row(_i++,"@0g "); 

        stampa_classe = false;
      }
      if (stampa_classe)
      {
        if ((_sez_da_stamp=='1')||(_sez_da_stamp=='2')||(_sez_da_stamp=='9'))
        {                 
          set_row(_i,"@0g%c)", bil->let);  
          TParagraph_string s(descrizione_ivd(sezione,lettera, 0 ,""), 40);
          setta_righe_descr(s, "@3g%s");

          if (!_intera_struttura || (_intera_struttura && bil->gruppo[0] != 'Z'))
          {
            _cont_numr = 1;
            _cont_num  = 1;
            _cont_gcs  = 0;
          }
        
          if (numrom.not_empty())
          {
            set_row(_i,"@3g%8s@12g-", (const char*) numrom);
            TParagraph_string s(descrizione_ivd(sezione,lettera,numeror, ""), 40);
            setta_righe_descr(s, "@14g%s");
          }
          if (numero.not_empty())
          {
            if (devo_stampare_risultato_prima_delle_imposte())
              stampa_risultato_prima_delle_imposte();          
            set_row(_i,"@13g%s)", num2str(numero));
            TParagraph_string s(descrizione_ivd(sezione,lettera,numeror, numero), 32);

            setta_righe_descr(s, "@27g%s");
          }
        }
      }
    }
    else
      if ((_numr_da_stamp!=_numr_stamp)&&(_sez_da_stamp==_sez_stamp)&&(_let_da_stamp==_let_stamp))
      {
        if ((_sez_da_stamp=='1')||(_sez_da_stamp=='2')||(_sez_da_stamp=='9'))
        {
          set_row(_i,"@3g%8s@12g-", (const char*) numrom);
          TParagraph_string s(descrizione_ivd(sezione,lettera,numeror, ""), 40);
          setta_righe_descr(s,"@14g%s");
          if (!_intera_struttura || (_intera_struttura && bil->gruppo[0] != 'Z'))
          {
            _cont_num  = 1;
            _cont_gcs  = 0;
          }
        
          if (numero.not_empty())
          {
            if (devo_stampare_risultato_prima_delle_imposte())
              stampa_risultato_prima_delle_imposte();          
            set_row(_i,"@13g%s)", num2str(numero));
            TParagraph_string s(descrizione_ivd(sezione,lettera,numeror, numero), 32);
						setta_righe_descr(s,"@27g%s");
          }
        }
      }
      else
        if ((_num_da_stamp!=_num_stamp)&&(_sez_da_stamp==_sez_stamp)&&(_let_da_stamp==_let_stamp)&&(_numr_da_stamp==_numr_stamp))
        {
          if ((_sez_da_stamp=='1')||(_sez_da_stamp=='2')||(_sez_da_stamp=='9'))
          {
            if (devo_stampare_risultato_prima_delle_imposte())
              stampa_risultato_prima_delle_imposte();          
            set_row(_i,"@13g%s)", num2str(numero));
            TParagraph_string s(descrizione_ivd(sezione,lettera,numeror, numero), 32);

						setta_righe_descr(s, "@27g%s");
            if (!_intera_struttura || (_intera_struttura && bil->gruppo[0] != 'Z'))
            {
              _cont_gcs = 0;
              _cont_numr= 1;
            }
          }
        }
  if (bil->gruppo[0] != 'A')
  {
    if (!_stampacod)
    {               
      if (!_intera_struttura || (_intera_struttura && bil->gruppo[0] != 'Z'))
      {
				const TConto tc(gruppo, conto, sottoc, bil->tipocf);

        _cont_gcs += 1;
        set_row (_i,"@18g%3d@22g%3d", gruppo, conto);
        if (sottoc != 0)
          set_row (_i,"@26g%6ld", sottoc);
        set_row (_i,"@33g%s",  (const char*) tc.descrizione());
        set_row (_i,"@81g%r", &_sale);
        if (_annoeserafr != 0 || _databilrafr != botime)
          set_row (_i,"@111g%r", &_salerafr);
        _i++;
      }  
    }
    else
    {                                                  
      if (!_intera_struttura || (_intera_struttura && bil->gruppo[0] != 'Z'))
      {
				const TConto tc (gruppo, conto, sottoc, bil->tipocf);

        _cont_gcs += 1;
        set_row (_i,"@20g%s", (const char*) tc.descrizione());
        set_row (_i,"@81g%r", &_sale);
        if (_annoeserafr != 0 || _databilrafr != botime)
          set_row (_i,"@111g%r", &_salerafr);
        _i++;
      }
    } 
  }
}

void TStampa_IVdirettiva::setta_righe_verifica()
{
  struct bil_ivd* bil = (struct bil_ivd*) _buff;
  int numeror, gruppo, conto;
  char sezione,lettera,tmcf;
  long sottoc;
  TString numrom,numr, numero;
  
  _descr->set_width(35);
 
  sezione = bil->sez;
  lettera = bil->let;
  numr = bil->numr;
  numeror = atoi(bil->numr);
  numrom  = itor(numeror);
  numero  = bil->num;
	numero.trim();
  gruppo  = atoi(bil->gruppo);
  conto   = atoi(bil->conto);
  sottoc  = atol(bil->sottoc);
  tmcf    = bil->tipocf;
  
  //Se la classe prelevata dal record corrente del sort e' diversa dalla classe
  //prelevata dal record precedente, allora stampo la nuova classe con i relativi
  //sottoconti. In caso contrario continuo a stampare solo i sottoconti.

  if (_sez_da_stamp != _sez_stamp)
  {
    char app = ' ';
    set_row (_i,"@0g%c", app);
    set_row (_i++,"@46g!@80g!@114g!");       
    if ((_sez_da_stamp=='1')||(_sez_da_stamp=='2')||(_sez_da_stamp== '9'))
    {
      if (_let_da_stamp != 'Z')
      {      
        if (!_intera_struttura || (_intera_struttura && bil->gruppo[0] != 'Z'))
        {
          _cont_let  = 1;
          _cont_numr = 1;
          _cont_num  = 1;
          _cont_gcs  = 0;
        }
        if (lettera > ' ')
        {
          set_row(_i,"@0g%c)", lettera);
          TParagraph_string s(descrizione_ivd(sezione,lettera, 0, ""), 40);   
          setta_righe_descr_verifica(s, "@3g%s");
        }
        if (numrom.not_empty())
        {
          set_row(_i,"@0g%8s)", (const char*) numrom);
          TParagraph_string s(descrizione_ivd(sezione,lettera,numeror, ""), 40);
          setta_righe_descr_verifica(s, "@10g%s");
        }
        if (numero.not_empty())
        {
          set_row(_i,"@0g%s)", num2str(numero));
          TParagraph_string s(descrizione_ivd(sezione,lettera,numeror,numero), 32);
          setta_righe_descr_verifica(s, "@13g%s");
        }
      }
    }
  }
  else
    if ((_let_da_stamp!=_let_stamp)&&(_sez_da_stamp==_sez_stamp))
    {
      char app = ' ';
      set_row (_i,"@0g%c", app);
      set_row (_i++,"@46g!@80g!@114g!");   
      if ((_sez_da_stamp=='1')||(_sez_da_stamp=='2')||(_sez_da_stamp=='9'))
      {
        if (_let_da_stamp != 'Z')
        {
          set_row(_i,"@0g%c)", bil->let);
          TParagraph_string s(descrizione_ivd(sezione,lettera, 0, ""), 40);   
          setta_righe_descr_verifica(s, "@3g%s");
          if (!_intera_struttura || (_intera_struttura && bil->gruppo[0] != 'Z'))
          { 
            _cont_numr = 1;
            _cont_num  = 1;
            _cont_gcs  = 0;
          }
       
          if (numrom.not_empty())
          {
            set_row(_i,"@0g%8s)", (const char*) numrom);
            TParagraph_string s(descrizione_ivd(sezione,lettera,numeror, ""), 40);
            setta_righe_descr_verifica(s, "@10g%s");
          }
          if (numero.not_empty())
          {
            set_row(_i,"@0g%s)", num2str(numero));
            TParagraph_string s(descrizione_ivd(sezione,lettera,numeror,numero), 32);
            setta_righe_descr_verifica(s, "@13g%s");
          }
        }
      }
    }
    else
      if ((_numr_da_stamp!=_numr_stamp)&&(_sez_da_stamp==_sez_stamp)&&(_let_da_stamp==_let_stamp))
      {
        char app = ' ';
        set_row (_i,"@0g%c", app);   
        set_row (_i++,"@46g!@80g!@114g!");
        if ((_sez_da_stamp=='1')||(_sez_da_stamp=='2')||(_sez_da_stamp=='9'))
        {
          if (_let_da_stamp != 'Z')
          {
            set_row(_i,"@0g%8s)", (const char*) numrom);
            TParagraph_string s(descrizione_ivd(sezione,lettera,numeror, ""), 40);
            setta_righe_descr_verifica(s, "@10g%s");
            if (!_intera_struttura || (_intera_struttura && bil->gruppo[0] != 'Z'))
            {
              _cont_num  = 1;
              _cont_gcs  = 0;
            }
       
            if (numero.not_empty())
            {
              set_row(_i,"@0g%s)", num2str(numero));
              TParagraph_string s(descrizione_ivd(sezione,lettera,numeror,numero), 32);
              setta_righe_descr_verifica(s, "@13g%s");
            }
          }
        }
      }
      else
        if ((_num_da_stamp!=_num_stamp)&&(_sez_da_stamp==_sez_stamp)&&(_let_da_stamp==_let_stamp)&&(_numr_da_stamp==_numr_stamp))
        {
          char app = ' ';
          set_row (_i,"@0g%c", app);  
          set_row (_i++,"@46g!@80g!@114g!"); 
          if ((_sez_da_stamp=='1')||(_sez_da_stamp=='2')||(_sez_da_stamp=='9'))
          {
            if (_let_da_stamp != 'Z')
            {
              set_row(_i,"@0g%s)", num2str(numero));
              TParagraph_string s(descrizione_ivd(sezione,lettera,numeror,numero), 32);
              setta_righe_descr_verifica(s, "@13g%s");
              _cont_num += 1;
              _cont_gcs = 0;
            }
          }
        }
  if (bil->gruppo[0] != 'A')
  {
    if (!_stampacod)
    {  
      if (!_intera_struttura || (_intera_struttura && bil->gruppo[0] != 'Z'))
      { 
        _cont_gcs += 1; 
        set_row (_i,"@0g%3d", gruppo);
        set_row (_i,"@4g%3d", conto);
        if (sottoc != 0)
          set_row (_i,"@8g%6ld", sottoc);
			  TConto tc (gruppo,conto,sottoc,tmcf);
			  *_d = tc.descrizione();
        setta_righe_descr_verifica(*_d, "@15g%s");
        _i--;
        if (_datainizio == _data_inizio_es)
        {
          //modifica del 27/11/1995
          if (_tipo_stampa == 2) //all'ultima immissione
          {
						real saldoini = _sld_prg_dare - _sld_prg_avere;

						if (saldoini > ZERO)
							set_row(_i,"@47g%r", &saldoini);
						else
							if (saldoini < ZERO) // Non stampare il saldo iniziale se == 0.0
							{                                 
							saldoini = -saldoini;
							set_row(_i,"@64g%r", &saldoini);
							} 
          }
          else
						if (_tipo_stampa == 1) //per date limiti
						{ 
						 if (_sld_prg_dare != ZERO)   
							set_row(_i,"@47g%r", &_sld_prg_dare);
						 if (_sld_prg_avere != ZERO)   
							set_row(_i,"@64g%r", &_sld_prg_avere);
						}
        } 
        else
        {
         if (_sld_prg_dare != ZERO)   
          set_row (_i,"@47g%r", &_sld_prg_dare);
         if (_sld_prg_avere != ZERO)   
          set_row (_i,"@64g%r", &_sld_prg_avere);
        } 
        
				if (_mov_dare != ZERO)
					set_row (_i,"@81g%r", &_mov_dare);
				if (_mov_avere != ZERO)
					set_row (_i,"@98g%r", &_mov_avere);
				set_row(_i, "@46g!@80g!@114g!");
				if (_stampa_modulo)
        {
					if (_sale != ZERO)
					{
						if (_sez_saldo == 'D')
							set_row(_i, "%r", &_sale);
						else
							set_row(_i, "@132g%r", &_sale);
					}
        }
        else
          if (_sale != ZERO)
            set_row (_i,"%r@131g%c", &_sale, _sez_saldo);
      }
    }
    else
    {  
      if (!_intera_struttura || (_intera_struttura && bil->gruppo[0] != 'Z'))
      { 
        _cont_gcs += 1;
			  TConto tc (gruppo,conto,sottoc,tmcf);
			  *_d = tc.descrizione();
        set_row (_i,"@2g#a", _d);
      
        if (_datainizio == _data_inizio_es)
        {
          //modifica del 27/11/1995
          if (_tipo_stampa == 2)
          {
           	real saldoini = _sld_prg_dare - _sld_prg_avere;
           
						if (saldoini > ZERO)
	            set_row(_i,"@47g%r", &saldoini);
						else
							if (saldoini < ZERO) // non stampare il saldo iniziale se == 0.0
							{
							saldoini = -saldoini;
							set_row(_i,"@64g%r", &saldoini);
							}
          }
          else
						if (_tipo_stampa == 1)
						{
						 if (_sld_prg_dare != ZERO)   
							 set_row(_i,"@47g%r", &_sld_prg_dare);
						 if (_sld_prg_avere != ZERO)   
							 set_row(_i,"@64g%r", &_sld_prg_avere);
						} 
        }                            
        else
        {
          if (_sld_prg_dare != ZERO)   
           set_row (_i,"@47g%r", &_sld_prg_dare);
          if (_sld_prg_avere != ZERO)   
           set_row (_i,"@64g%r", &_sld_prg_avere);
        }
        
        set_row (_i,"@81g%r", &_mov_dare);
        set_row (_i,"@99g%r", &_mov_avere);
				set_row(_i, "@46g!@80g!@114g!");
				if (_stampa_modulo)
        {
					if (_sale != ZERO)
					{
						if (_sez_saldo == 'D')
							set_row(_i, "%r", &_sale);
						else
							set_row(_i, "@132g%r", &_sale);
					}
        }
        else
          if (_sale != ZERO)
            set_row (_i,"@115g%r@131g%c", &_sale, _sez_saldo);


      }
    }
  }
}    

void TStampa_IVdirettiva::setta_righe_descr(TParagraph_string & str, const char* formato)
{
  const char* r;
  while((r = str.get()) != NULL)
    set_row (_i++, formato, r); 
}

void TStampa_IVdirettiva::setta_righe_descr_verifica(TParagraph_string & str, const char* formato)
{
  const char* r;
  while ((r = str.get()) != NULL)
  { 
    set_row (_i, formato, r); 
    set_row (_i++, "@46g!@80g!@114g!");    
  } 
}

const TString & TStampa_IVdirettiva::descrizione_ivd(char sezione, char lettera, int numr, const char * numero)
{
  TString16 key; 
  if (numr != 0)
    key.format("%c%c%04d%-4s", sezione, lettera, numr, numero);
  else
    key.format("%c%c    %-4s", sezione, lettera, numero);
	key.trim();
  return cache().get(TAB_IVD, key, "S0");
}


// Crea l'intestazione per la stampa a 132 e a 198 caratteri

void TStampa_IVdirettiva::crea_intestazione()
{
  TString codice_ditta; codice_ditta.format("%ld", get_firm());
  TString16 key;
  const TRectype & nditte = cache().get(LF_NDITTE, codice_ditta);

  key = codice_ditta;
	key << "|1";
  
	const TRectype & unloc = cache().get(LF_UNLOC, key);

  key = "|";
	key << unloc.get(ULC_COMULC);
  
  const TRectype & comuni = cache().get(LF_COMUNI, key);

  reset_header();
  set_header (1, TR("DITTA@6g%-5s"), (const char*) codice_ditta);
  set_header (1, "@12g%-45s", (const char*) nditte.get(NDT_RAGSOC));
  set_header (1, "@59g%-25s", (const char*) unloc.get(ULC_INDULC));
  set_header (1, "@86g%-9s", (const char*) unloc.get(ULC_CIVULC));
  set_header (1, "@97g%-5s", (const char*) unloc.get(ULC_CAPULC));
  set_header (1, "@102g%-25s", (const char*) comuni.get(COM_DENCOM));
  set_header (1, "@129g%-3s", (const char*) comuni.get(COM_PROVCOM));
	//set_header(8, "CA@29g%-3s", (const char*)comuni.get(COM_PROVCOM));
	//setta_righe();

  if (_stampa_modulo)
    set_header(2,FR("@129gPag. @#"));
  else
    set_header(2,FR("@122gPag. @#"));
  
  key = nditte.get(NDT_TIPOA);
  key << "|" << nditte.get(NDT_CODANAGR);

	const TRectype & anag = cache().get(LF_ANAG, key);
  
  set_header (2,FR("@0gPartita iva@12g%-11s"), (const char*) anag.get(ANA_PAIV));
  set_header (2,FR("@30gCodice fiscale@45g%-16s"), (const char*) anag.get(ANA_COFI));

  if (_stampa_modulo)
    set_header (2,FR("@131gData@116g%s"),(const char*) _datastampa.string());
  else
    set_header (2,FR("@105gData@111g%s"),(const char*) _datastampa.string());
	if (_stampa_mov_prov > 0x1)
	{
		TString tipoprovv;
		TString riga;
		
		if ((_stampa_mov_prov & 0x1))
			tipoprovv << TR("Movimenti : Normali");
		if (_stampa_mov_prov > 0x1)
			tipoprovv << TR(" Provvisori :");
		if (_stampa_mov_prov & 0x2)
			tipoprovv << TR(" Manuali");
		if (_stampa_mov_prov & 0x4)
			tipoprovv << TR(" Competenza costi/ricavi");
		if (_stampa_mov_prov & 0x8)
			tipoprovv << TR(" Cespiti");
		riga.overwrite(tipoprovv, (132 - tipoprovv.len()) / 2);
		set_header(3, FR("%s"), (const char*) riga);
	}

  if (_tipo_bilancio == 1)
    intesta_scalare();
  else
		if (_tipo_bilancio == 2)
	    intesta_verifica();
}

void TStampa_IVdirettiva::intesta_verifica_fissa()
{
  TString sep(132),app(32),sep1(147);

  if (_tipo_stampa == 1)
  {
    if (_datainizio == _data_inizio_es)
      set_header(6,FR("@54gMOVIMENTI DI APERTURA@87gMOVIMENTI DEL PERIODO"));
    else
			if (_datainizio > _data_inizio_es)
				set_header(6,FR("@54gPROGRESSIVI PRECEDENTI@87gMOVIMENTI DEL PERIODO"));
  }
  else
		if (_tipo_stampa == 2)
			set_header(6,FR("@57gSALDO INIZIALE@87gMOVIMENTI DEL PERIODO"));
  if (_stampa_modulo)
    set_header(6,FR("@129gSALDO"));

  set_header(6,"@46g!@80g!@114g!");

  if (_stampa_modulo)
  {
    set_header(6,"@147g!");
    set_header(7,"@147g!");
  }
  
  set_header(7,"@46g!@80g!@114g!");
  app = "---------------------------------";
  if (_stampa_modulo)
  {
    set_header(7,"@47g%s@81g%s@115g%s", (const char*) app, (const char*) app,(const char*) app);
    set_header(8,FR("@1gdescrizione voce@46g!@53gDare@63g!@69gAvere@80g!@87gDare@97g!@103gAvere@114g!@122gDare@131g!@138gAvere@147g!"));
    sep1.fill('-');                            //Stampa 132 - (sep(132))       
    set_header (9, (const char *) sep1);
  }
  else
  {
    set_header(7,"@47g%s@81g%s@122gSALDO", (const char*) app, (const char*) app);
    set_header(8,FR("@1gdescrizione voce@46g!@53gDare@63g!@69gAvere@80g!@87gDare@97g!@103gAvere@114g!"));
    sep.fill('-');                            //Stampa 132 - (sep(132))       
    set_header (9, (const char *) sep);
  }
}

void TStampa_IVdirettiva::intesta_scalare()
{
  TString sep(132); 
	TString intestazione(TR("STAMPA BILANCIO CONFORME ALLA IV DIRETTIVA"));
 
	if (_tipo_data == Registrazione)
		intestazione << " " << TR("PER CASSA");
	else
		if (_tipo_data == CostiRicavi)
			intestazione << " " << TR("PER COMPETENZA COSTI/RICAVI");
	set_header(4, intestazione);
	set_header (4,FR("@80gEs. %s/%s"), (const char*)_data_inizio_es.string(), (const char*)_data_fine_es.string());     /**/
  if (_annoeserafr != 0 || _databilrafr != botime)
  {
    set_header (4,FR("@107gEs. %s/%s"), (const char*)_data_inizio_raf.string(), (const char*)_data_fine_raf.string()); /**/
    set_header (5,FR("@107galla data@122g%s"), (const char*)_databilrafr.string());
  }
  if (_tipo_stampa == 1)
    set_header (5,FR("@80galla data@95g%s"), (const char*)_datalimite.string());
  else
		if (_tipo_stampa == 2)
			set_header (5,FR("@110gall'ultima immissione"));

  sep.fill('-');                            //Stampa 132 - (sep(132))       
  set_header (6, (const char *) sep);
}

void TStampa_IVdirettiva::intesta_verifica()
{ 
	TString intestazione(TR("BILANCIO DI VERIFICA IV DIRETTIVA"));

	if (_tipo_data == Registrazione)
		intestazione << " " << TR("PER CASSA");
	else
		if (_tipo_data == CostiRicavi)
			intestazione << " " << TR("PER COMPETENZA COSTI/RICAVI");
	set_header(4, intestazione);
	if (_tipo_stampa == 1)
    set_header (4,FR("@90gdalla data@101g%s alla data %s"),
                (const char*)_datainizio.string(), (const char*)_datalimite.string());
  else
		if (_tipo_stampa == 2)
			set_header (4,FR("@111gall'ultima immissione"));

  TString sep;
  sep.fill('-', _stampa_modulo ? 147 : 132);
  set_header (5, sep);

  intesta_verifica_fissa();
}

void TStampa_IVdirettiva::init_sort()
{
  _bil = new bil_ivd;
  _sort = new TSort (sizeof(bil_ivd));
  
  _sort -> addsortkey ((char*)&(_bil->sez)    - (char*)&(_bil->sez),1);
  _sort -> addsortkey ((char*)&(_bil->let)    - (char*)&(_bil->sez),1);
  _sort -> addsortkey ((char*)&(_bil->numr)   - (char*)&(_bil->sez),4);
  _sort -> addsortkey ((char*)&(_bil->num)    - (char*)&(_bil->sez),6);
  _sort -> addsortkey ((char*)&(_bil->gruppo) - (char*)&(_bil->sez),3);
  _sort -> addsortkey ((char*)&(_bil->conto)  - (char*)&(_bil->sez),3);
  _sort -> addsortkey ((char*)&(_bil->sottoc) - (char*)&(_bil->sez),6);
  _sort->init();
}

bool TStampa_IVdirettiva::user_create()
{
  open_files(LF_TAB, LF_NDITTE, LF_SALDI, LF_COMUNI, LF_UNLOC, LF_ANAG,LF_PCON,LF_CLIFO, LF_CAUSALI,0);

  _descr   = new TParagraph_string("",40);
  _d       = new TParagraph_string("",33);
  
  _sld     = new TSaldo();
  
  _msk     = new TMask("cg1600a");
  
  _msk->set_handler(F_DATALIM,     data_limite);
  _msk->set_handler(F_TIPOSTAMPA,  tipo_stampa); 
  _msk->set_handler(F_TIPOBIL,     tipo_bilancio);    
  _msk->set_handler(F_ANNOESE,     anno_esercizio); 
  _msk->set_handler(F_DATAINI,     data_inizio);
  _msk->set_handler(F_DATABILRAF,  data_bil_raff);
  _msk->set_handler(F_ANNORAFFR,   anno_ese_raff);
	_msk->set(F_NORMALI, "X");

	_sez_utile = ini_get_string(CONFIG_DITTA, "CG", "SezIVDUtile", "9")[0];
	_lett_utile = ini_get_string(CONFIG_DITTA, "CG", "LettIVDUtile", "E")[0];
	_classe_utile = ini_get_string(CONFIG_DITTA, "CG", "ClasseIVDUtile", "");
	_num_utile = ini_get_string(CONFIG_DITTA, "CG", "NumIVDUtile", "22");
  
  return true;
}

bool TStampa_IVdirettiva::user_destroy()
{
  delete  _msk;
  delete _descr;
  delete _d;
  delete _sld;
  
  return true;
}

int cg1600 (int argc, char* argv[])
{
  TStampa_IVdirettiva a;

  a.run(argc, argv, TR("Stampa Bilancio IV direttiva CEE"));

  return 0;
}