campo-sirio/cg/cg3400.cpp

// cg3400 - Stampa libro giornale

#include "cglib01.h"
#include "cglib03.h"
#include "cg2103.h"
#include "cg3400a.h"
#include "cg3400b.h"

#include <config.h>
#include <currency.h>
#include <mask.h>
#include <tabutil.h>
#include <printapp.h>
#include <progind.h>
#include <recarray.h>

#include <mov.h>
#include <rmov.h>
#include <rmoviva.h>
#include <nditte.h>
#include <anagr.h>
#include <anafis.h>
#include <anagiu.h>
#include <causali.h>
#include <comuni.h>
#include <pconti.h>
#include <clifo.h>
#include <occas.h>

HIDDEN const char*  REAL_PICTURE  = "###.###.###.###.###";

HIDDEN const int    RIGHE_FOOTER = 3;

HIDDEN const int    WCAUS132    = 20;
HIDDEN const int    WOPER132    = 28;
HIDDEN const int    WCONTO132   = 35;
HIDDEN const int    POSCONTO    = 74;

HIDDEN const int    DARE132     = 95;
HIDDEN const int    AVERE132    = 112;
HIDDEN const int    DARE198     = 152;
HIDDEN const int    AVERE198    = 174;

HIDDEN const int    SCRITTA     = 26;  
HIDDEN const int    TOTDARE132  = 84; 
HIDDEN const int    SEZA132     = 108;  
HIDDEN const int    TOTAVERE132 = 110; 

enum descr { causale, conto, operazione };
enum tipo_sospensione { nessuna, normale, vol_affari, liquidazione };


class TContoOccas : public TBill
{
  TString16   _occfpi;
  TAssoc_array _desc;
  
public:
  const TContoOccas& set(int g = 0, int c = 0, long s = 0L, char t = ' ', 
                         const char* occfpi = NULL);
  
  const TString& descrizione();
  
  TContoOccas();
  virtual ~TContoOccas() {}
};

TContoOccas::TContoOccas() 
{ }

const TContoOccas& TContoOccas::set(int g, int c, long s, char t, const char* occfpi)
{
  TBill::set(g,c,s,t); 
  _occfpi = t > ' ' ? occfpi : "";   
  return *this;
}

const TString& TContoOccas::descrizione()
{                 
  if (tipo() > ' ' && _occfpi.not_empty())
  {
    TString16 code; code << tipo() << '|' << sottoconto();
    const bool really_occas = cache().get(LF_CLIFO, code, CLI_OCCAS).not_empty();      
    if (really_occas)
      return cache().get(LF_OCCAS, _occfpi, "RAGSOC");
  }
  
  TString16 code; code.format("%c%03d%03d%06ld", 
                              tipo(), gruppo(), conto(), sottoconto());
  TString* d = (TString*)_desc.objptr(code);
  if (d == NULL)
  {
    d = new TString(TBill::descrizione());
    _desc.add(code, d);
  }
  return *d;
}

class TStampa_giornale : public TPrintapp
{
  static bool mask_a_cod_reg   (TMask_field& f, KEY k);
  static bool data_a_hndl      (TMask_field& f, KEY k);
  static bool data_da_hndl     (TMask_field& f, KEY k);
  static bool mask_b_ripristina(TMask_field& f, KEY k);
  static bool mask_b_warning   (TMask_field& f, KEY k);

  static bool filter_func(const TRelation * r);  
  static bool filtra_reg (const TRelation * r);  
  int righe_rimaste() const;
  
private:
  TRelation*    _rel;
  TCursor*      _cur;
  TRectype*     _RecPartoDa, *_RecArrivoA;    
  int           _ae;         // anno esercizio di ALLA_DATA  
  int           _ae_solare;  // anno esercizio solare usato per la tabella registri
  int           _tipo;       // tipo del registro
  int           _annoEsMov;  // anno esercizio letto da mov
  TString16     _reg;
  int           _anno_iva;
  bool          _stampa_definitiva;
  bool          _MovGiaStampato;
  bool          _totals_updated;
  
  bool          _gia_settato_ariportare;
  bool          _forza_ariportare;
  int           _devo_riportare;  // Guy: Togliere 'sto casino se non funziona
  
  bool          _nuovo_mese;    // Finito il mese ?
  long          _num_rig;
  real          _importo;
  char          _sezione;
  int     _pagine_contate;  // cnt pag. stampate. 
  
  TContoOccas _tc;  
  
public:
  TRigaiva_array  _iva_array;

  TString16    _reg_cod;
  TString80    _reg_descr;
  TDate        _data_da, _data_a, _last_data;
  real         _tot_dare, _tot_avere;              // valori di partenza
  real         _tot_dare_progr, _tot_avere_progr;  // progressivi anno in corso
  real         _tot_dare_progr_ap, _tot_avere_progr_ap;  // progr. anno prec.
  real         _tot_dare_gg , _tot_avere_gg ;      // giornalieri
  real         _tot_dare_gg_ap , _tot_avere_gg_ap ;      // giornalieri anno precedente
  real         _tot_dare_generale, _tot_avere_generale; // tot. generali
  long         _nprog_da, _nprog_mov;
  int          _stampa_width, _stampa_len;

  int          _pagine_stampate, _pagine_numerate, _stampa_ok, _pagina_da;
  TDate        _data_corr, _data_succ, _ultima_data_mov;
  int          _mese_corr, _mese_succ;
  int          _last_header;    // prima riga di intestazione "libera"

  bool         _stampa_stesso_registro;
  bool         _libro_giornale_iva_unico, _libro_cronologico, _stampa_intesta, _stampa_num_pag;
  //  bool         _gia_settata_riga_mov;   // per la stampa no iva

  TString80    _ragsoc, _paiva, _comunefis, _viafis;
  TString16    _provfis, _cap, _occfpi;
  TString80    _cofi;


  TTable         *_tabreg; 


public:
  virtual void preprocess_header();
  virtual void preprocess_footer();
  virtual bool preprocess_page(int, int);
  virtual print_action postprocess_page(int, int);
  virtual print_action postprocess_print(int, int);
  virtual bool preprocess_print(int, int);
  virtual void postclose_print();
  //  virtual bool cancel_hook();
  virtual bool set_print(int);

  virtual void on_firm_change();
  
  virtual bool user_create();
  virtual bool user_destroy();
  
  void set_rows (int file, int counter);
  int  setta_righe_indirizzo(char tipocf, long codcf, int rdesc);
  int  setta_righe_iva();
  int  setta_righe_valuta(int start_riga);
  int  setta_righe_descr(TParagraph_string&, enum descr);
  
  void fill_page(int start_riga, int righe_iva);  
  void calcola_iva();
  void init_print();
  bool init_cursor();

  void init_totals();
  int  stampa_intestazione_ditta();
  int  set_headers();

  bool leggi_tabreg(const char * codreg, int annoes);
  bool controlla_mov_aep();

  bool competenza_ep() const { return _ae != _annoEsMov; }
  bool competenza_ec() const { return !competenza_ep(); } // tertium non datur ?

  void aggiorna_tabreg(int, int);     
  void aggiorna_mov();
  int  set_totali_giorno(const TDate& giorno, const int righeivasettate);
  int  set_totali_pagina(int r);
  void get_dati_ditta ();

  const TString& get_descr_caus (const char * codcaus);    
  const TRectype& look_com (const char* cod, const char* stato = "");
  const TString& get_codiva_des(const char* codiva);
  void        update_totals (char sezione, real& importo);
  void        set_reg_filter(TMask& m);
  
  TStampa_giornale() : _pagine_contate(0) {};
  virtual ~TStampa_giornale() {};
};

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

bool TStampa_giornale::filtra_reg(const TRelation * r)
{           
  bool ok = TRUE;
  if (app()._ae_solare)  
  {
    const TRectype& rec = r->lfile().curr();
    const int anno = atoi(rec.get("CODTAB").left(4));
    ok = anno == app()._ae_solare;
  }
  return ok;
}

bool TStampa_giornale::filter_func(const TRelation * r)
{           
  const TRectype& recmov = r->curr();

  // Scarto SEMPRE i provvisori
  const TString& provvis = recmov.get(MOV_PROVVIS);
  if (!provvis.blank())
    return FALSE;

  // Scarto i movimenti che hanno il registro  ai soli fini della liquidazione
  const TRectype& reg = r->lfile("REG").curr();
  const tipo_sospensione ts = reg.get_bool("B1") ? (tipo_sospensione) reg.get_int("I9") : nessuna;
  if (ts == liquidazione)
    return FALSE;
  
  // In caso di NO libro con iva scarta quelli che non hanno righe contabili
  if (!app()._libro_giornale_iva_unico)
  {
    const long numreg = recmov.get_long("NUMREG");
    TRectype& recrmov = r->curr(LF_RMOV);
    recrmov.zero();
    recrmov.put("NUMREG", numreg);   
    recrmov.put("NUMRIG", 1);                              
    
    if (r->lfile(LF_RMOV).read() != NOERR)          
    {
      const long numreg2 = recrmov.get_long("NUMREG");
      return numreg2 == numreg;
    }  
  }
  return TRUE;
}


//////////////////////////////////////////////////////////////////////////
// Funzioni legate ai parametri ditta
//////////////////////////////////////////////////////////////////////////

const TRectype& TStampa_giornale::look_com (const char* cod, const char* stato)
{
  TString16 codice;
  codice << stato << '|' << cod;
  return cache().get(LF_COMUNI, codice);
}

const TString & TStampa_giornale::get_descr_caus (const char * codcaus)
{
  return cache().get(LF_CAUSALI, codcaus).get("DESCR");
} 

void TStampa_giornale::get_dati_ditta ()
{
  TString16 codanagr;
  char      tipoa;

  const TRectype & nditte = cache().get(LF_NDITTE, get_firm());   

  _ragsoc  = nditte.get(NDT_RAGSOC);
  codanagr = nditte.get(NDT_CODANAGR);
  tipoa    = nditte.get_char(NDT_TIPOA);

  TToken_string key ;

  key.add(tipoa);
  key.add(codanagr);
  const TRectype & anag =  cache().get(LF_ANAG, key);
  
  _cofi      = anag.get(ANA_COFI);
  _paiva     = anag.get(ANA_PAIV);
  _comunefis = anag.get(ANA_COMRF);
  _cap       = anag.get(ANA_CAPRF);

  if (_comunefis.empty()) 
    _comunefis   = anag.get(ANF_COMRES);

  const TRectype& dep = look_com(_comunefis);
  _comunefis = dep.get(COM_DENCOM);
  _provfis = dep.get(COM_PROVCOM);
  if (_cap.empty())
    _cap = dep.get(COM_CAPCOM);
  
  if (_comunefis.empty()) 
  {
    _viafis = anag.get(ANA_INDRF);
    _viafis.rtrim();
    _viafis << " " << anag.get (ANA_CIVRF); 
  }
  else
  {
    _viafis = anag.get(ANA_INDRES);
    _viafis.rtrim();
    _viafis << " " << anag.get (ANA_CIVRES); 
  }
}

void TStampa_giornale::on_firm_change()
{
  TConfig conf(CONFIG_DITTA);
  _libro_giornale_iva_unico = conf.get_bool("StLgiU");
  _libro_cronologico        = conf.get_bool("GsLbCn");
}

bool TStampa_giornale::user_create()
{
  _ae = 0;
  _ae_solare = 0;
  open_files(LF_TABCOM, LF_TAB, LF_NDITTE, LF_ANAG, LF_COMUNI, LF_CLIFO, LF_PCON, LF_OCCAS, 0);
  _tabreg = new TTable ("REG");


  
  _rel = new TRelation (LF_MOV);
  _rel->add (LF_RMOV,    "NUMREG==NUMREG");
  _rel->add (LF_RMOVIVA, "NUMREG==NUMREG");
  _rel->add ("REG", "CODTAB[1,4]==ANNOIVA|CODTAB[5,7]==REG"); // CM500302 senza == si incasina con registri vuoti!

  _cur = new TCursor (_rel, "", 2);   // usa la chiave 2: DATAREG+NUMREG

  _RecPartoDa = new TRectype(_cur->curr());
  _RecArrivoA = new TRectype(_cur->curr());

  add_cursor (_cur);

  add_file (LF_MOV);
  add_file (LF_RMOV);
  add_file (LF_RMOVIVA);
  return TRUE;
}

bool TStampa_giornale::user_destroy()
{
  delete _rel;
  delete _RecPartoDa;
  delete _RecArrivoA;

  delete _tabreg;
  return TRUE;
}

void TStampa_giornale::aggiorna_mov()
{
  TLocalisamfile& mov = _cur->file(LF_MOV);
  long nprog = _nprog_da + 1;
  
  _cur->setregion(*_RecPartoDa, *_RecArrivoA);
  
  const long items = _cur->items();
  TProgind prnd (items, TR("Aggiornamento movimenti ..."), FALSE, TRUE);  

  for ((*_cur) = 0L; _cur->pos() < items; ++(*_cur))
  {
    const bool gia_stampato = _cur->file(LF_MOV).get_bool(MOV_STAMPATO);
    if (!gia_stampato)
    {
      _cur->file(LF_MOV).put (MOV_STAMPATO, TRUE);
      _cur->file(LF_MOV).put (MOV_NUMGIO, nprog);
      mov.rewrite();
      nprog++;
    }
    prnd.addstatus(1);
  }
}

int TStampa_giornale::set_totali_giorno(const TDate& data, const int righeiva)
{
  int       r = righeiva + 1;
  char      dep[200];
  const int SHIFT = 15;
  const int STACC = 51 + SHIFT;

// Se e' l'unico totale lo stampo anche se e' zero
  if (competenza_ec() || (_tot_avere_gg != ZERO || _tot_dare_gg != ZERO))
  {
    TString80 td; real2currency(td, _tot_dare_gg);
    TString80 ta; real2currency(ta, _tot_avere_gg);

    sprintf(dep, FR("@b@%dgTotale operazioni del %s @%dg%c %s @%dg%c @%dg%s"), 
            _stampa_width == 132 ? SCRITTA : DARE198-STACC,
            data.string(),
            _stampa_width == 132 ? TOTDARE132 : DARE198-2,
            'D',            
            (const char*)td, 
            _stampa_width == 132 ? SEZA132 : AVERE198-2,
            'A',                        
            _stampa_width == 132 ? TOTAVERE132 : AVERE198,                
            (const char*)ta
            );
    
    set_row (r++, "%s", dep);
    _tot_dare_gg  = _tot_avere_gg = ZERO;
  }
  
  if (competenza_ep() || (_tot_avere_gg_ap != ZERO || _tot_dare_gg_ap != ZERO))
  {                
    TString80 tdp; real2currency(tdp, _tot_dare_gg_ap);
    TString80 tap; real2currency(tap, _tot_avere_gg_ap);

    sprintf (dep, FR("@b@%dgTotale operazioni del %s Anno precedente @%dg%c %s @%dg%c @%dg%s"), 
             _stampa_width == 132 ? SCRITTA : DARE198-STACC,
             data.string(),
             _stampa_width == 132 ? TOTDARE132 : DARE198-2,
             'D',            
             (const char*)tdp,                             
             _stampa_width == 132 ? SEZA132 : AVERE198-2,             
             'A',            
             _stampa_width == 132 ? TOTAVERE132 : AVERE198,                
             (const char*)tap
             );

    set_row (r++, "%s", dep);

    _tot_avere_gg_ap = _tot_dare_gg_ap = ZERO;
  } 
  return r;  
}


void TStampa_giornale::postclose_print()
{
  if (_stampa_definitiva && yesno_box(TR("La stampa e' corretta?")))
  {
    const int ultima_fatta = _pagine_contate;    
    aggiorna_mov();
    aggiorna_tabreg (_pagina_da, ultima_fatta);
  }
}      


void TStampa_giornale::preprocess_footer()
{
  TString           progr_dare_ap(22), progr_avere_ap(22);
  TString           progr_dare(25), progr_avere(25), dts(25), ats(25);
  TString256        riga;
  bool              ap = FALSE;
  int               r=1;  // was 2
  const int STUMB  = 42;
  real              dt, at;
  
  reset_footer();
  
  if (_tot_avere_progr_ap != ZERO || _tot_dare_progr_ap != ZERO)
  {
    real2currency(progr_dare_ap, _tot_dare_progr_ap);
    real2currency(progr_avere_ap, _tot_avere_progr_ap);
    ap = TRUE;
  }
  
  //
  // Non stampo "A riportare" 
  // SE :
  // 1. E' gia' stato stampato
  // OPPURE
  // 2. Sono sull'ultima riga
  // 

  const int riporta = _devo_riportare;
  
  if (riporta)  
  {
    dt = _tot_dare_progr  + _tot_dare_progr_ap;
    at = _tot_avere_progr + _tot_avere_progr_ap;
    real2currency(dts, dt);
    real2currency(ats, at);

    riga.format ("@b@%dg%s@%dg%c %s @%dg%c @%dg%s", 
                 _stampa_width == 132 ? SCRITTA : DARE198-STUMB,                          
                 TR("A riportare                    "),
                 _stampa_width == 132 ? TOTDARE132  : DARE198-2,
                 'D',                   
                 (const char *) dts,    
                 _stampa_width == 132 ? SEZA132 : AVERE198-2,
                 'A',                   
                 _stampa_width == 132 ? TOTAVERE132 : AVERE198,
                 (const char *) ats);
    set_footer (r++, (const char*) riga);          
    
    _forza_ariportare = FALSE;
    
    if (_devo_riportare > 1)
      _devo_riportare = FALSE;
  }
} 


int TStampa_giornale::set_totali_pagina(int righe)
{
  TString           progr_dare_ap(22), progr_avere_ap(22);
  TString           progr_dare(22), progr_avere(22), dts(22), ats(22);
  TString256        riga;
  bool              ap = FALSE; 
  const int SHIFT  = 15;
  const int STUMB  = 51 + SHIFT;
  real              dt, at;
  int               r = righe == 0 ? 1 : righe;  
  
  if (_tot_avere_progr_ap != ZERO || _tot_dare_progr_ap != ZERO)
  {
    real2currency(progr_dare_ap, _tot_dare_progr_ap);
    real2currency(progr_avere_ap, _tot_avere_progr_ap);
    ap = TRUE;
  }
  
  if (_cur->pos() == _cur->items()-1)    // se sono sull'ultimo
  {
    // I totali distinti tra anno precedente e corrente SOLO SE STAMPA DI PROVA
    if (!_stampa_definitiva)
    {  
      real2currency(progr_dare, _tot_dare_progr);
      real2currency(progr_avere, _tot_avere_progr);  
      riga = "";        
      riga.format(FR("@b@%dgTotale progressivi @%dg%c %s @%dg%c @%dg%s"), 
                  _stampa_width == 132 ? SCRITTA : DARE198-STUMB,
                  _stampa_width == 132 ? TOTDARE132 : DARE198-2,
                  'D',
                  (const char *) progr_dare, 
                  _stampa_width == 132 ? SEZA132 : AVERE198-2,                  
                  'A',
                  _stampa_width == 132 ? TOTAVERE132 : AVERE198,
                  (const char *) progr_avere
                  );    

      set_row (r++, (const char*) riga);    

      if (ap)
      {
        riga.format(FR("@b@%dgTotale progressivi anno precedente @%dg%c %s @%dg%c @%dg%s"), 
                    _stampa_width == 132 ? SCRITTA : DARE198-STUMB,
                    _stampa_width == 132 ? TOTDARE132  : DARE198-2,
                    'D',
                    (const char *) progr_dare_ap, 
                    _stampa_width == 132 ? SEZA132 : AVERE198-2,                    
                    'A',
                    _stampa_width == 132 ? TOTAVERE132 : AVERE198,
                    (const char *) progr_avere_ap
                    );    
        set_row (r++, (const char*) riga);
      }
    }      // stampa_definitiva

    _tot_dare_generale  = _tot_dare_progr  + _tot_dare_progr_ap;
    _tot_avere_generale = _tot_avere_progr + _tot_avere_progr_ap;
    real2currency(dts, _tot_dare_generale);
    real2currency(ats, _tot_avere_generale);
    
    riga.format(FR("@b@%dgTotale progressivi generali @%dg%c %s @%dg%c @%dg%s"), 
                _stampa_width == 132 ? SCRITTA : DARE198-STUMB,
                _stampa_width == 132 ? TOTDARE132 : DARE198-2,
                'D',
                (const char *) dts, 
                _stampa_width == 132 ? SEZA132 : AVERE198-2,                
                'A',
                _stampa_width == 132 ? TOTAVERE132 : AVERE198,
                (const char *) ats
                );    

    set_row (r++, (const char*) riga);          
  }
  else      // Non ancora totale generale
  { 
// Determina se le righe settate finora stanno in questa pagina oppure no
    _gia_settato_ariportare  = righe_rimaste() > righe;

// La fill_page mette forza_ariportare a TRUE
// nel caso di pagine con solo i totali (v. fax VLADIMIRO) bisogna impedire
// che venga stampato di nuovo "Totale ..." nella preprocess_footer
    _forza_ariportare        = FALSE;                          
    
    dt = _tot_dare_progr  + _tot_dare_progr_ap;
    at = _tot_avere_progr + _tot_avere_progr_ap;
    real2currency(dts, dt);
    real2currency(ats, at);

// "Se il mese e' finito devo scrivere Totale progressivi generali
// invece che A riportare"

    riga.format (FR("@b@%dgTotale progressivi generali @%dg%c %s @%dg%c @%dg%s"), 
                   _stampa_width == 132 ? SCRITTA : DARE198-STUMB,    
                   _stampa_width == 132 ? TOTDARE132  : DARE198-2,
                   'D',                   
                   (const char *) dts,  
                   _stampa_width == 132 ? SEZA132 : AVERE198-2,                   
                   'A',                   
                   _stampa_width == 132 ? TOTAVERE132 : AVERE198,
                   (const char *) ats);
    set_row (r++, (const char*) riga);          
  }      
  return r;
}

int TStampa_giornale::stampa_intestazione_ditta()
{
  int           r=1;
  TString256    intes;
  TString       riga(_stampa_width);

  get_dati_ditta();

  riga.fill('-'); 
  set_header(r, riga);

  set_header (++r, FR("Ditta: %5ld %-.50s %.35s %.5s %.20s %.2s"), 
              get_firm(),
              (const char *)_ragsoc, 
              (const char *)_viafis, (const char *)_cap, 
              (const char *)_comunefis, (const char *)_provfis); 

  if (_stampa_definitiva)  
    intes.format (FR("Partita iva %s @24gCodice fiscale %s"), 
                  (const char*)_paiva, (const char*)_cofi, 
                  _stampa_width == 132 ? 102 : 168
                  );
  else  
    intes.format (FR("Partita iva %s @24gCodice fiscale %s @%dg%s @%dgData @>"), 
                  (const char*)_paiva, (const char*)_cofi, 
                  _stampa_width == 132 ? 102 : 168,
                  FR("LIBRO DI PROVA"),
                  _stampa_width == 132 ? 117 : 183
                  );

  set_header (++r, "%s", (const char*)intes);
  r++;
  return r;
}

int TStampa_giornale::set_headers()
{
  int r=1;
  TString riga(_stampa_width);
  TString16 data_da = _data_da.string();
  TString16 data_a  = _data_a.string();

  if (_stampa_intesta || !_stampa_definitiva) 
    r = stampa_intestazione_ditta();
  else    
    r += 2;    

  if (_stampa_definitiva)                                         
    set_header(r++, FR("Codice libro: %s %s "),(const char *) _reg_cod, (const char *) _reg_descr);
  else
    set_header(r++, FR("Codice libro: %s %s @%dgdalla data: %s alla data: %s @%dgEsercizio: %04d"),
               (const char *) _reg_cod, (const char *) _reg_descr,
               _stampa_width == 132 ? 69 : 135,
               (const char *) data_da,  (const char *) data_a, 
               _stampa_width == 132 ? 117 : 183,
               _ae
               );

  riga.fill('-'); 
  set_header(r++, riga);

  if (_libro_cronologico)
    set_header(r, FR("@59gCodice         Conto")); 

  if (!_stampa_definitiva) {
    if (_stampa_width == 132) {
      set_header(r++, "@131gS");    
      set_header(r, FR("@1gN.riga")); 
    }
    else {
      set_header(r++, "@197gS");    
      set_header(r, FR("@1gN.riga"));       
    }
  }
  else
    if (_libro_cronologico) r++;    // NON LASCIARE RIGHE IN BIANCO!!
  
  set_header(r, FR("@8gDescrizione operazione@36gCausale"));
  if (_libro_cronologico)
    //  POSCONTO    = 74;
    set_header(r, FR("@74gGeneralita' cliente/fornitore")); 
  else
    set_header(r, FR("@59gCodice         Conto")); 
  
  if (_stampa_width == 132)
    set_header(r, FR("@120gImporto"));
  else
    set_header(r, FR("@161gDare @184gAvere"));
  
  if (!_stampa_definitiva)          
    set_header(r, _stampa_width == 132 ? "@131gB" : "@197gB");
  
  r++;

  riga.fill('-'); 
  set_header(r, riga);

  return r;
}

void TStampa_giornale::preprocess_header()
{
  int r      = _last_header + 1;
  int pag    = printer().getcurrentpage();
  real         riporto_dare, riporto_avere;
  
  if (_stampa_num_pag) // Stampa numero di pagina in alto a destra
  {
	  TEsercizi_contabili esc;
	  const int esercizio = esc.date2esc(_data_a);  //codice esercizio correntemente selezionato
	  const int anno = esc[esercizio].inizio().year();  //anno finale dell'esercizio
	  TString16 numpag, riga;
	  numpag.format("%d/%d", anno, _pagina_da+pag);
    const int tab = _stampa_width - numpag.len();
    riga.format("@%dg%s", tab, (const char*)numpag);
    set_header(2, riga); // Sempre quasi sulla prima riga!
  }

//  _gia_settato_ariportare  = FALSE;
      
  if (pag > 0)   // Stampa riporti
  {
    riporto_dare  = _tot_dare_progr  + _tot_dare_progr_ap;
    riporto_avere = _tot_avere_progr + _tot_avere_progr_ap;

    // Non stampa nulla se ZERO SOLO SE DI PROVA <<<<<---------------------
    // Lascio una riga senno' vado a finire sull'intestazione
    if (!_stampa_definitiva)
      if (riporto_dare == ZERO && riporto_avere == ZERO)
      {
        set_header (r, "");
        return;
      }

    TString80 dare; real2currency(dare, riporto_dare);
    TString80 avere; real2currency(avere, riporto_avere);

    TString256   riporto;
    riporto.format(FR("@b@%dgRiporto: @%dg%c %17s  @%dg%c@%dg%17s"),  // prima erano %15s
                   _stampa_width == 132 ? SCRITTA : DARE198-11,
                   _stampa_width == 132 ? TOTDARE132 : DARE198-2,
                   _stampa_width == 132 ? 'D' : ' ',
                   (const char *) dare,       
                   _stampa_width == 132 ? SEZA132 : SEZA132,
                   _stampa_width == 132 ? 'A' : ' ',                   
                   _stampa_width == 132 ? TOTAVERE132 : AVERE198,
                   (const char *) avere 
                   );    

    set_header (r++, "%s", (const char *) riporto);
  }
}

//
// PREPROCESS_PRINT
//
// Se non ci sono items nel cursore (= se non ci sono movimenti) 
// la stampa e' abortita.
//
// stampa_ok = -1  ->  la stampa precedente era OK
// stampa_ok = x   ->  la stampa precedente non e' andata a buon fine
//                     ed era partita dalla pagina x.
//
// Se la stampa precedente e' andata male, setto la pagina corrente a
// quella salvata in stampa_ok, e la pagina da cui parte la stampa vera e 
// propria a quella che mi dice l'utente:
//
//           set_page_number (stampa_ok)
//           setfrompage     (pagina_da)
//
bool TStampa_giornale::preprocess_print(int file, int counter)
{
  switch (file)
  {
  case LF_MOV:
    _nuovo_mese   = FALSE;    
    _iva_array.destroy();
    _nprog_mov   = _nprog_da;
    *_RecPartoDa = _cur->curr();
    break;
  default:
    break;
  }
  return TRUE;
}

int TStampa_giornale::righe_rimaste() const 
{
  const TPrinter& p = printer();
  int rows_left = p.rows_left();
  if (rows_left <= 0)
    rows_left = p.formlen() - (p.headersize()+1) - p.footersize();
  return rows_left;
}

void TStampa_giornale::fill_page(int righe_da_stampare, int righe_iva_settate)
{
  const TPrinter& p = printer();

  TString256   rigas;
  int r = righe_da_stampare + 1;
  int r_l = p.rows_left() - righe_da_stampare;
   
  if (r_l < 0)
    r_l += p.formlen() - (p.headersize()/*+1*/) - p.footersize();
  
// Se sono rimaste righe da riempire
  if (r_l > 0)
  {
    rigas.fill('=', _stampa_width);
    set_row(r++, "%s", (const char*) rigas);
    int j=0;
    // Calcola una specie di coefficiente angolare      
    int alfa = (_stampa_width - 6) / r_l;
    r_l--;
    
    for ( ; r_l > 0; r_l--)           // Non stampare sulla riga orizzontale!
    {
      rigas.format("@%dg======", j);
      set_row(r++, rigas);
      j += alfa;
    }
  }
}

print_action TStampa_giornale::postprocess_print(int file, int counter)
{
  if (file == LF_MOV)
    _pagine_contate = printer().getcurrentpage() - 1;
  return NEXT_PAGE;
}

print_action TStampa_giornale::postprocess_page(int file, int counter)
{
  int righe_iva_settate=0;
//  bool        FINITO = FALSE;
  
  if (counter) 
  {
    if (_nuovo_mese) 
    {
      printer().formfeed();
      _nuovo_mese = FALSE;
    }
    return NEXT_PAGE;
  }

  switch (file)
  {
  case LF_MOV:
    {
      reset_print();
      righe_iva_settate = 0;
      if (_libro_giornale_iva_unico)
      {
        righe_iva_settate = setta_righe_iva();
        righe_iva_settate = setta_righe_valuta(righe_iva_settate);
      }
      
      _cur->save_status();                
      ++(*_cur);
      _data_succ = _cur->file(LF_MOV).get_date(MOV_DATAREG);
      _mese_succ = _data_succ.month();
      --(*_cur);
      _cur->restore_status();            
      
      _devo_riportare = TRUE;
      
      const bool last_row = _cur->pos() == _cur->items()-1;
      if (_data_corr != _data_succ || last_row)
      {
        _nuovo_mese = (_mese_succ != _mese_corr);
        int righe  = set_totali_giorno(_data_corr, righe_iva_settate);
        if (_nuovo_mese || last_row)
        {
          righe = set_totali_pagina(righe);
          
          if (righe - 1 > (int)printer().rows_left())
            _devo_riportare = 3;        // Very TRUE!
          else
            _devo_riportare = FALSE;
  
          // Nella stampa su bollato metto un segno su tutte le righe 
          if (_stampa_definitiva)
            fill_page(righe - 1, righe_iva_settate);
        }
        return REPEAT_PAGE;
      }
  
      if (righe_iva_settate > 0)
        return REPEAT_PAGE;
    }
    break;

  case LF_RMOV:
    // Sposto qui per evitare di aggiornare i progressivi con una riga della
    // pagina dopo  
    if (!_totals_updated)
      update_totals(_sezione, _importo);
    _gia_settato_ariportare = FALSE;
    break;
  default:
    break;
  }
  return NEXT_PAGE;
}

void TStampa_giornale::update_totals (char sezione, real& importo)
{
#ifdef DBG
  TString dgap(_tot_dare_gg_ap.string());
  TString dgpp(_tot_dare_progr_ap.string());  
  TString dgac(_tot_dare_gg.string());
  TString dgpc(_tot_dare_progr.string());
  TString agap(_tot_avere_gg_ap.string());
  TString agpp(_tot_avere_progr_ap.string());  
  TString agac(_tot_avere_gg.string());
  TString agpc(_tot_avere_progr.string());
#endif  

  if (sezione == 'D')
  {
    if (_annoEsMov != _ae)  {
      _tot_dare_gg_ap     += importo;    // prog. anno precedente
      _tot_dare_progr_ap  += importo;   
    }
    else  {
      _tot_dare_gg    += importo;    // prog. giornalieri
      _tot_dare_progr += importo;      // prog. generali
    }
  }
  else
  {                                   
    if (_annoEsMov != _ae)  {
      _tot_avere_gg_ap    += importo;
      _tot_avere_progr_ap += importo;
    }        
    else  {
      _tot_avere_gg    += importo;
      _tot_avere_progr += importo;
    }
  }
#ifdef DBG
  dgap = _tot_dare_gg_ap.string();
  dgpp = _tot_dare_progr_ap.string();  
  dgac = _tot_dare_gg.string();
  dgpc = _tot_dare_progr.string();
  agap = _tot_avere_gg_ap.string();
  agpp = _tot_avere_progr_ap.string();  
  agac = _tot_avere_gg.string();
  agpc = _tot_avere_progr.string();
#endif  
}    



void TStampa_giornale::set_rows (int file, int counter)
{
  TString16     datadoc_str, datareg_str, numdoc, frm, caus;
  TDate         datadoc, datareg;
  TString80     mov_descr, rmv_descr;
  long          numreg, protiva;
  int           r = 1;
  int           g, c;          
  long          s;
  static char   cf = ' ';
  static int    rdes = 1;
  
  switch (file)  
  {
  case LF_MOV:
    {
      const TRectype& mov = _cur->curr(LF_MOV);
      reset_row(1);
      reset_row(2);     
    
      datareg   = mov.get_date("DATAREG");        
      datadoc   = mov.get_date("DATADOC");        
      datareg_str = datareg.string();
      // "Fai vedere lo stesso ..-..-.... anche se non c'e' la data..."    
      if (datareg_str.empty())
        datareg_str = "  -  -    ";
      datadoc_str = datadoc.string();
      if (datadoc_str.empty())
        datadoc_str = "  -  -    ";    
      numdoc    = mov.get("NUMDOC");        
      numreg    = mov.get_long("NUMREG");        
      mov_descr = mov.get("DESCR");                    

      // Usati in setta_righe_iva per determinare tipo attivita'
      _reg       = mov.get(MOV_REG);  
      _anno_iva  = mov.get_int(MOV_ANNOIVA);

      protiva         = mov.get_long(MOV_PROTIVA);   
      caus            = mov.get(MOV_CODCAUS);  
      _occfpi         = mov.get(MOV_OCFPI);  
      _annoEsMov      = mov.get_int(MOV_ANNOES);
      _MovGiaStampato = mov.get_bool(MOV_STAMPATO);    
    
      if (_stampa_definitiva)                     
      {
        set_row(r,FR("Operazione n. @b%-7ld@r"), _nprog_mov);
        set_row(r,FR(" del @b%s@r"), (const char*)datareg_str); // XX/XX/XXXX
        set_row(r,FR(" doc. n. @b%-7s@r"),(const char*)numdoc);
        set_row(r,FR(" del @b%s@r %-50s"),(const char*)datadoc_str,
                (const char*)mov_descr);
      }
      else
      { 
        set_row(r,FR("Operazione n. @b%-7ld@r"), numreg);
        set_row(r,FR(" del @b%s@r"), (const char*) datareg_str);
        set_row(r,FR(" doc. n. @b%-7s@r"), (const char*) numdoc);
        set_row(r,FR(" del @b%s@r %-50s"), (const char*)datadoc_str,(const char*)mov_descr);
      }

      if (_annoEsMov != _ae)
        set_row(r,FR(" Comp. %04d"), _annoEsMov);          
    
      if (_MovGiaStampato && !_stampa_definitiva)
      {
        TString16 fmt; 
        fmt.format("@%dg*", _stampa_width == 132 ? 131 : 197);
        set_row(r,fmt);
      }

      if (caus.not_empty())
      {
        const char* desc_caus = get_descr_caus(caus);
        set_row(r+1, FR("@36gCausale %3s %-50s"), (const char*) caus, desc_caus);
        if (_reg.not_empty())
          set_row(r+1, FR(" (R.IVA @b%3s@r Prot. @b%ld@r) "), (const char*)_reg,protiva);
      } 
    }
    break;
    
  case LF_RMOV:
    {
      const TRectype& rmov = _cur->curr(LF_RMOV);
      _num_rig++; 
      reset_print();
    
      g         = rmov.get_int("GRUPPO");      
      c         = rmov.get_int("CONTO");      
      s         = rmov.get_long("SOTTOCONTO");          
      cf        = rmov.get_char(RMV_TIPOC);    

      if (cf != 'C' && cf != 'F') 
        cf = ' ';
    
      numreg    = rmov.get_long("NUMREG");    
      datareg   = rmov.get("DATAREG");                  

      _sezione   = rmov.get_char (RMV_SEZIONE);
      _importo   = rmov.get_real (RMV_IMPORTO);    

      rmv_descr = rmov.get(RMV_DESCR);

      r=1;

      // Num. progressivo di operazione. Azzerato in preprocess_page
      if (!_stampa_definitiva) set_row (r, "%7ld", _num_rig);

      set_row (r, "@8g%-50s", (const char*) rmv_descr);

      set_row (r, "@59g%03d.", g);
      if (c != 0)
        set_row (r, "%03d.",     c);
      if (s != 0L)
        set_row (r, "%06ld",     s);

      if (cf > ' ' && _occfpi.not_empty() && s == _cur->curr(LF_MOV).get_long(MOV_CODCF))
        _tc.set(g,c,s,cf,_occfpi);
      else
        _tc.set(g,c,s,cf,"");

      TParagraph_string descr_conto("", 198);
      if (_stampa_width == 132) 
        descr_conto.set_width (WCONTO132);      
      else                          // se a 198 non spezzo le descrizioni
        descr_conto.set_width(198);

      descr_conto = _tc.descrizione();

      if (_stampa_width == 132)
        rdes = setta_righe_descr (descr_conto, conto);        
      else
      {
        rdes = 2;
        frm.format("@%dg%%-%ds", POSCONTO,50);
        set_row (r, frm, (const char*) descr_conto);
      }
    
      if (cf > ' ')
        if (_libro_cronologico)
          rdes = setta_righe_indirizzo(cf, s, rdes);    

      // NB Totali aggiornati in postprocess_page (update_totals())

      if (_stampa_width == 132)
      {
        set_row (r, "@110g%r %c", &_importo, _sezione); 
      }
      else  //  stampa_width == 198
        set_row (r, _sezione == 'D' ? "@152g%r" : "@174g%r", &_importo);
    
      if (_MovGiaStampato && !_stampa_definitiva)
      {
        TString16 fmt; 
        fmt.format("@%dg*", _stampa_width == 132 ? 131 : 197);
        set_row(r,fmt);
      }

      {
        const int rows = rdes - 1;
        const int left = printer().rows_left();
        if (left > 0 && left < rows)
        {
          _totals_updated = TRUE;
          update_totals(_sezione, _importo);
        }
        else
         _totals_updated = FALSE;
      }
    }    
    break;

  default:
    break;
  }
}

//
// PREPROCESS_PAGE
//
// Non scarto nulla qui, non si deve mai vedere una stampa vuota
//
bool TStampa_giornale::preprocess_page(int file, int counter)
{
  if (counter) return TRUE;

  switch (file)  
  {
    
  case LF_MOV:
    {
      _annoEsMov = _anno_iva = 0;    
      _iva_array.destroy();
      *_RecArrivoA = _cur->file(LF_MOV).curr();
      _nprog_mov++;           
      // Il numero di operazione deve ripartire da 0 per ogni movimento    
      _num_rig = 0;
      _data_corr = _cur->file(LF_MOV).get_date(MOV_DATAREG);
      // _ultima_data_mov finisce sul registro come ultima data di stampa
      if (_data_corr > _ultima_data_mov) 
        _ultima_data_mov = _data_corr;
      _mese_corr = _data_corr.month();    
      _devo_riportare = TRUE;
    }
    break;

  case LF_RMOV: 
    break;

  case LF_RMOVIVA: 
    if (_libro_giornale_iva_unico)  calcola_iva ();
    break;

  default: 
    break;
  }
  set_rows (file, counter);
  return TRUE;
}

void TStampa_giornale::calcola_iva()
{
  const TRectype& iva = _cur->curr(LF_RMOVIVA);
  if (!iva.empty())
    _iva_array.add_riga(iva);
}

int TStampa_giornale::setta_righe_descr(TParagraph_string& str, enum descr des)
{
  int           i = 1;
  TString16     frm;
  const char*   r;         
  //  char          descr[51];
  TString80     descr;
  
  switch (des)
  {
  case causale:    // lunga 20
    if (_libro_giornale_iva_unico)
      frm.format("@10g\0x25%ds", _stampa_width == 132 ? WCAUS132 : 40);
    else
      frm.format("@48g%%d", WCAUS132);
    break;
  case conto:     // lunga 21
    //    if (_libro_giornale_iva_unico)
    frm.format("@%dg%%-%ds", POSCONTO,WCONTO132);
    /*
       else
       frm.format("@26g%%d", POSCONTO,WCONTO132); */
    break;
  case operazione:  // lunga 28
    if (_libro_giornale_iva_unico)
      frm.format("@31g%%d", WOPER132);
    else
      frm.format("@69g%%d", WOPER132);
    break;
  default:
    break;
  }
  while ((r = str.get()) != NULL)  
  {
    descr = r;
    descr.ltrim();
    set_row (i++, (const char*)frm, (const char*)descr);
  }

  return i;
}

const TString& TStampa_giornale::get_codiva_des(const char* codiva)
{
  return cache().get("%IVA", codiva).get("S0");
}

// NB
// Questa funzione ritorna il numero di righe che ha settato.
// Se questo e' diverso da 0 viene fatta una REPEAT_PAGE
// Attenzione quindi se si modifica la variabile r
int TStampa_giornale::setta_righe_iva()
{
  int r=0, j;
  TString80 rig, impon_str, impos_str;

  for (j = 0; j < _iva_array.items(); j++)
  {
    const TRigaiva& riga = _iva_array.riga(j);
    r = j+1;
    real2currency(impon_str, riga._imponibile);
    real2currency(impos_str, riga._imposta);
    set_row(r, FR("   Imponibile@15g%15s"), (const char*)impon_str);
    set_row(r, FR("@35gImposta@43g%15s"),   (const char*)impos_str);
    set_row(r, FR("@64gCod.Iva %3s"), (const char*)riga._codiva);
    const TString& codiva_des = get_codiva_des(riga._codiva);    
    const int tipoatt = riga._tipoatt;
    if (_stampa_width == 132)
      set_row(r, "@76g%-.17s", (const char*)codiva_des);    
    else
      set_row(r, "@76g%-.50s", (const char*)codiva_des);    
    const int S132 = 97;      
    const int S198 = 127;      
    rig.format("@%dg", _stampa_width == 132 ? S132 : S198);    
    rig << riga.descr_det();
    set_row(r, (const char*)rig);

    const int meseliq = _cur->file(LF_MOV).get_int(MOV_MESELIQ);
    if (meseliq > 0)
      set_row(r, FR(" Mese liq. %2d"), meseliq);
      
    if (tipoatt != 0)
    {
      TRegistro reg(_reg, _anno_iva);
      const bool att_mista_ev = reg.attivita_mista();
      if (att_mista_ev)
        set_row(r, FR(" Tipo attivita' %d"), tipoatt);
    }
  } 
  _iva_array.destroy();
  return r; 
}

int TStampa_giornale::setta_righe_valuta(int r)
{      
  const real corrval = current_cursor()->file(LF_MOV).get_real(MOV_CORRVALUTA);
  
  if (corrval != ZERO)
  {  
    const TString16 codvali = current_cursor()->file(LF_MOV).get(MOV_CODVALI);
    const TCurrency cur(corrval, codvali);
    set_row(++r,FR("@56gValuta %3s"), (const char*)codvali);
    if (_stampa_width == 132)
      set_row(r,FR("@89gCorr.in valuta @109g%20v"), &cur);
    else
      set_row(r,FR("@119gCorr.in valuta @171g%20v"), &cur);
  }
  return r;  
}

// Cerca l'indirizzo del C/F.
// Legge CLIFO o OCCAS a seconda di _occas      
// Setta le righe 2 e 3 che vengono poi resettate al record successivo
int TStampa_giornale::setta_righe_indirizzo(char tipocf, long codcf,int rdes)
{
  TString16 prov, comcf, capcf, civcf, statocf;
  TString80 viacf, comune;
  char      tipoa;
  long      codanagr;    
  char      riga[256];
  int       r = rdes;
  
  TToken_string key;
  key.add(tipocf);
  key.add( codcf);

  const TRectype & clifo = cache().get(LF_CLIFO, key);

  if (_occfpi.not_empty() && clifo.get_bool(CLI_OCCAS))   // => e' un occasionale...
  {
    const TRectype & occ = cache().get(LF_OCCAS, _occfpi);
    
    viacf = occ.get(OCC_INDIR);
    civcf = occ.get(OCC_CIV);
    capcf = occ.get(OCC_CAP);
    comcf = occ.get(OCC_COM);
  } 
  else 
  {
    viacf   = clifo.get(CLI_INDCF);
    civcf   = clifo.get(CLI_CIVCF);
    comcf   = clifo.get(CLI_COMCF);
    capcf   = clifo.get(CLI_CAPCF);
    statocf = clifo.get(CLI_STATOCF);
    tipoa   = clifo.get_char(CLI_TIPOAPER);
    codanagr = clifo.get_long(CLI_CODANAGPER);
  }

  const TRectype& rec = look_com (comcf, statocf);
  comune       = rec.get(COM_DENCOM);
  prov         = rec.get(COM_PROVCOM);
  if (comcf.empty())
		comune = clifo.get(CLI_LOCCF);
  
  if (viacf.not_empty())
  {
    sprintf (riga, "@%dg%s %s",
             POSCONTO,
             (const char*) viacf,
             (const char*) civcf
             );
  
    set_row (r++, riga);
  }
  
  if (comune.not_empty() || prov.not_empty() || capcf.not_empty())
  {
    sprintf (riga, "@%dg%s %s %s",
             POSCONTO,
             (const char*) capcf, (const char*) comune,
             (const char*) prov
             );
    set_row (r++, riga);  
  }
  
  // Se fisica prendo anche data nascita e luogo  
  if (tipoa == 'F')
  {
    TString80 comna;
    TString16 datana, codcomna, provna, capna, statona;
    
    datana = clifo.get("DATANASC");
    
    if (datana.not_empty())
    {
      codcomna  = clifo.get("COMNASC");
      statona   = clifo.get("STATONASC");
      const TRectype& dep = look_com (codcomna, statona);
  
      comna     = dep.get(COM_DENCOM);
      provna    = dep.get(COM_PROVCOM);
      capna     = dep.get(COM_CAPCOM);
      
      sprintf (riga, "@%dg%s %s %s %s", POSCONTO,
               (const char*)datana,
               (const char*)comna,
               (const char*)provna, (const char*) capna);
      
      set_row(r++, riga);
    }
  }
  return r;
}

//
// Lettura/aggiornamento tabella registri
//
void TStampa_giornale::aggiorna_tabreg(int partito_da, int stampate)
{
  TString16 codtab;

  codtab.format ("%04d%-3s", _ae_solare, (const char*) _reg_cod);

  _tabreg->zero();                                   
  _tabreg->put("CODTAB", codtab);
  _tabreg->read(_isequal, _lock);

  if (_tabreg->good())
  {
    _tabreg->put ("I1", (long)_pagina_da + stampate); // pagine stampate
    _tabreg->put ("I6", _nprog_mov);    // ultimo numero di riga
    _tabreg->put ("R1", _tot_dare_generale);
    _tabreg->put ("R2", _tot_avere_generale);
    _tabreg->put ("D3", _ultima_data_mov);  // Data piu' alta trovata
    _tabreg->rewrite();
  }
}

bool TStampa_giornale::controlla_mov_aep()
{                  
  TWait_cursor hourglass;
  
  TEsercizi_contabili esc;
  const int aep = esc.pred(_ae);  
  TDate inizio_ep, fine_ep;
  if (aep > 0)
  {   
    inizio_ep = esc[aep].inizio();
    fine_ep = esc[aep].fine();
  }
  else
    return TRUE; // = e' il primo esercizio
  
  TRectype da(LF_MOV), a(LF_MOV);
  da.put(MOV_DATAREG, inizio_ep);
  a.put (MOV_DATAREG, fine_ep);
  _cur->setregion(da, a);
  _cur->setfilter("");
  _cur->set_filterfunction(filter_func, TRUE);
  
  const TRecnotype items = _cur->items();
  _cur->freeze();
  TProgind pi(items, TR("Controllo movimenti esercizio precedente"), FALSE, TRUE);
  
  bool gia_stampati = TRUE;
  for (*_cur = 0L ; _cur->pos() < items; ++(*_cur))
  {                                    
    pi.addstatus(1);
    gia_stampati = _cur->file().get_bool("STAMPATO");  
    if (!gia_stampati) break;   // basta trovarne uno ancora da stampare
  }
  _cur->freeze(FALSE);
  if (!gia_stampati)
    error_box(TR("Impossibile proseguire con la stampa:\n"
              "Esistono movimenti nell'esercizio precedente\n" 
              "che non sono ancora stati stampati su bollato."));
  return gia_stampati;
}

bool TStampa_giornale::leggi_tabreg(const char * reg_cod, int reg_anno)
{
  TString16 codtab;
  codtab.format ("%04d%-3s", reg_anno, reg_cod);
  _tabreg->put("CODTAB", codtab);
  const bool ok = _tabreg->read() == NOERR;
  if (!ok) 
    _tabreg->zero();
  
  _pagine_stampate = _tabreg->get_int("I1");
  _pagine_numerate = _tabreg->get_int("I2");
  _stampa_num_pag  = _tabreg->get_bool("S11");
  _nprog_da        = _tabreg->get_long ("I6");
  _tot_dare        = _tabreg->get_real ("R1");
  _tot_avere       = _tabreg->get_real ("R2");
  _last_data       = _tabreg->get_date ("D3");
  _stampa_intesta  = _tabreg->get_bool ("B9");
  _stampa_stesso_registro = _tabreg->get_bool ("B8");
  _reg_descr       = _tabreg->get ("S0");
  _tipo            = _tabreg->get_int("I0");
  
  return ok;
}

void TStampa_giornale::set_reg_filter(TMask& m)
{
  TEdit_field& reg = m.efield(CODREG);
  reg.browse()->cursor()->set_filterfunction(filtra_reg);  
}

//-----------------------------------------------------------------------
//
// MASCHERE
//
//-----------------------------------------------------------------------

// NB
// Qui viene compilato app()._ae
// L'anno di esercizio e' quello iniziale (in caso di esercizio a cavallo di 2 anni!)
//
bool TStampa_giornale::data_a_hndl (TMask_field& f, KEY k)
{
  TMask& m = f.mask();          

  if (f.to_check(k))
  {
    const TDate data_a(f.get());                  

    if (!data_a.ok()) 
      return TRUE;                   
    
    TEsercizi_contabili esc;
    const int esercizio = esc.date2esc(data_a);
    if (esercizio <= 0)
      return f.error_box(TR("La data non appartiene a nessun esercizio"));
    
    app()._ae_solare = esc[esercizio].inizio().year();   //in caso di esercizio a cavallo di 2 anni va preso il primo anno
    app()._ae = esercizio;

    m.set(ANNO_ESER, app()._ae_solare);
    m.send_key(K_TAB, CODREG);
  }
  
  if (k == K_ENTER)
  {
    const bool      definitiva = m.get_bool(STAMPA_DEF);
    const TDate     data_da(m.get(DATA_DA));    
    const TDate     data_a(f.get());                  
    TString16       dtda(data_da.string());   

    if (definitiva)  
    {     
      if (dtda.not_empty()) 
      {
        if (data_da.year() !=  data_a.year())
          return f.warning_box(TR("Le date specificate non appartengono allo stesso anno"));
        if (data_da > data_a)
          return f.warning_box(TR("La data di partenza non puo' essere maggiore della data finale"));
      }
    }
  }  // if K_ENTER

  return TRUE;
}

bool TStampa_giornale::data_da_hndl(TMask_field& f, KEY k)
{
  TMask&              m = f.mask();          
  //  if (f.to_check(k))
  if (k == K_TAB)
  {
    const TDate data_da (f.get());
    const TDate data_a(m.get(DATA_A));    
 
    if (!data_da.ok() || !data_a.ok())
      return TRUE;
    
    if (data_da.year() != data_a.year())
      return f.error_box(TR("Le due date non appartengono allo stesso anno"));
  }

  if (k == K_ENTER)
  {
    const bool      definitiva = m.get_bool(STAMPA_DEF);
    const TDate     data_a(m.get(DATA_A));                      
    const TDate     data_da(f.get());                  

    // Controlli sulle date    

    // se la stampa e' di prova DALLA_DATA e' obbligatoria
    if (!definitiva && !data_da.ok()) 
        return f.warning_box(TR("Manca la data di partenza"));
    
    if (data_da.ok() && data_da > data_a)
        return f.warning_box(TR("La data di partenza non puo' essere maggiore della data finale"));
  }
  return TRUE;
}

//
// MASK_A_COD_REG
//
// ----------->>>>  SCRIVO ANCHE QUI _ae <<<<----------------
//
bool TStampa_giornale::mask_a_cod_reg (TMask_field& f, KEY k)
{
  if (f.to_check(k))
  {
    TMask&              m = f.mask();
    TStampa_giornale& a = app();    
//    const bool definitiva = m.get_bool(STAMPA_DEF); //qui verificare
    const TString16 data_astr(m.get(DATA_A));
    const TDate     data_a(m.get(DATA_A));

    // 25/11 controlli sul registro solo DOPO aver messo la DATA_A
    if (data_astr.empty()) 
      return TRUE;
    else     
    {
      TEsercizi_contabili esc;
      const int esercizio = esc.date2esc(data_a);
      if (esercizio > 0)
      {
        a._ae_solare = esc[esercizio].inizio().year();  // Anno solare usato per la tabella dei registriin caso di esercizio a cavallo di 2 anni va preso il primo anno
        a._ae = esercizio;  // Anno esercizio
      }
    }

    const TString16 reg_cod(f.get());
    a.leggi_tabreg(reg_cod, a._ae_solare);

    // Output da qui della descrizione del registro e dell'anno
    m.set(REG_DESC,  a._reg_descr);
    m.set(ANNO_ESER, a._ae_solare); 
  }
  return TRUE;
}

//
// mask_b_ripristina
//
// Se premo il bottone <Ripristina> rimetto i valori precedenti
// dentro ai campi (per ripetere la stampa)
//
bool TStampa_giornale::mask_b_ripristina (TMask_field& f, KEY k)
{
  if (k == K_SPACE) 
  {                                                             
    TMask& m = f.mask();
    TStampa_giornale& a = (TStampa_giornale&)main_app();    
    m.set(PROGR_DARE,      a._tot_dare.string());
    m.set(ULTIMA_DATA,     a._last_data.string());
    m.set(N_RIGA_STAMPATO, a._nprog_da);
    m.set(PAGINA_DA,       a._pagine_stampate);
  }
  return TRUE; 
}

bool TStampa_giornale::mask_b_warning (TMask_field& f, KEY k)
{
  static bool gia_detto = FALSE;

  if (k == K_TAB && !f.mask().is_running())
    gia_detto = FALSE;

  if (!gia_detto)
  {
    if (k == K_SPACE)
    {
      f.warning_box(TR("Le modifiche a questi progressivi saranno scritte nel registro"));
      gia_detto = TRUE;
      return TRUE;
    }
  }
  
  return TRUE;
}

void TStampa_giornale::init_print()
{
  // 17.5.95 Leggo parametri di stampa del registro  
  TString16   config;
  config.format("REG%05ld%03s", get_firm(), (const char*)_reg_cod);
  printer().read_configuration(config);
  
  if (_stampa_len != 0) 
    printer().formlen(_stampa_len);

  printer().footerlen(RIGHE_FOOTER);
  
  reset_print();
  reset_header();
  reset_footer();
  set_background();

  for (int i=1; i<RIGHE_FOOTER; i++) set_footer(i, "%s", " ");

  set_real_picture (REAL_PICTURE);
  set_print_zero(TRUE);

  if (_stampa_width == 1) 
    _stampa_width = 132;
  else 
    _stampa_width = 198;

/* Guy: sarebbe interessante ma non funziona mai!
  // Solo se _pagina_da diversa da 0
  if (_pagina_da)  
    printer().set_from_page(_pagina_da - _pagine_stampate);
*/
  
  // la stampa precedente era andata male  
  //  if (_stampa_ok != -1) set_page_number (_stampa_ok); 
  
  _last_header = set_headers();
}

void TStampa_giornale::init_totals()
{
  _tot_dare_gg_ap     = ZERO;
  _tot_avere_gg_ap    = ZERO;
  _tot_dare_progr_ap  = ZERO;
  _tot_avere_progr_ap = ZERO;
  _tot_dare_gg        = ZERO;
  _tot_avere_gg       = ZERO;
  _tot_dare_generale  = ZERO;
  _tot_avere_generale = ZERO;
  if (_stampa_definitiva)
  {
    _tot_dare_progr     = _tot_dare;
    _tot_avere_progr    = _tot_avere;
  }
  else
  {
    _tot_dare_progr     = ZERO;
    _tot_avere_progr    = ZERO;
  }
}

bool TStampa_giornale::init_cursor()
{   
//  bool gia_stampati = FALSE;
  
  TRectype da (LF_MOV);
  TRectype a  (LF_MOV);

  da.put(MOV_DATAREG, _data_da);
  a.put (MOV_DATAREG, _data_a);

  _cur->setregion(da, a);
  _cur->set_filterfunction(filter_func, TRUE);
  _cur->setfilter(_stampa_definitiva ? "STAMPATO!=\"X\"" : "");
  
  (*_cur) = 0L;

  if (_cur->items() == 0L)
  {
    _cur->setfilter("");  
    return warning_box(TR("Non ci sono movimenti da stampare nel periodo selezionato.\nLa stampa e' annullata"));
  }

  return TRUE;
}

bool TStampa_giornale::set_print(int)
{
  TMask ma ("cg3400a");

  ma.set_handler (CODREG, mask_a_cod_reg);
  ma.set_handler (DATA_A, data_a_hndl);
  ma.set_handler (DATA_DA,data_da_hndl);
  //  set_reg_filter(ma);

  _pagina_da    = 0;  // Parto dall'inizio
  _forza_ariportare = FALSE;

  KEY   tasto;
  while ((tasto = ma.run()) != K_QUIT)
  {
    _reg_cod           = ma.get(CODREG);
    _stampa_definitiva = ma.get_bool(STAMPA_DEF);
    _data_da           = ma.get(DATA_DA);
    _data_a            = ma.get(DATA_A);

    _stampa_width      = ma.get_int(STAMPA_WIDTH);
    _stampa_len        = ma.get_int(STAMPA_LEN);

    set_magic_currency(TRUE);
//    set_curr_codval(ma.get(F_CODVAL));

    // Se stampa definitiva DALLA_DATA e' la data di inizio esercizio
    // e si scartano i movimenti gia' stampati su bollato
    if (_stampa_definitiva) 
    {
      TEsercizi_contabili esc;
      _ae = esc.date2esc(_data_a);
      _data_da = esc[_ae].inizio();
      _ae_solare = _data_da.year(); // qui modificato

      // Controlla che non siano rimasti movimenti ancora da stampare dell'es.prec.
      if (_stampa_stesso_registro) 
        if (!controlla_mov_aep()) 
          continue;
    }
    
    if (!init_cursor()) continue;
    
    if (_stampa_definitiva)
    {
      TMask mb("cg3400b");
      mb.set_handler (DLG_RIPRISTINA, mask_b_ripristina);
      mb.set_handler (PROGR_DARE,     mask_b_warning);
      mb.set_handler (N_RIGA_STAMPATO,mask_b_warning);      
      mb.set_handler (ULTIMA_DATA,    mask_b_warning);
      mb.set (PROGR_DARE,      _tot_dare.string());
      mb.set (N_RIGA_STAMPATO, _nprog_da);
      mb.set (ULTIMA_DATA,     _last_data.string());
      mb.set (PAGINA_DA,       _pagine_stampate);

      tasto = mb.run();           
      if (tasto == K_ENTER) 
      {
        _nprog_da  = mb.get_long(N_RIGA_STAMPATO);
        _last_data = mb.get(ULTIMA_DATA);
        real dare2(mb.get(PROGR_DARE));
        _pagina_da = mb.get_int(PAGINA_DA);
        // "Se l'utente cambia il progressivo dare, esso viene uguagliato all'avere"        
        if (dare2 != _tot_dare)
        {
          _tot_dare     = dare2;
          _tot_avere    = dare2;
        }
      }
      else
        continue;
    }

    init_print();
    init_totals();

    return TRUE;
  }
  return FALSE;
}

int  cg3400  (int argc, char * argv[])
{
  TStampa_giornale app;
  app.run(argc, argv, TR("Stampa libro giornale"));
  return TRUE;
}