// cg3400 - Stampa libro giornale

#include <isam.h>
#include <mask.h>
#include <utility.h>
#include <tabutil.h>
#include <urldefid.h>
#include <printapp.h>
#include <config.h>
#include <progind.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>

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

HIDDEN const char*  REAL_PICTURE = "###.###.###.###";
HIDDEN const char*  REAL_TOT_PIC = "#.###.###.###.###";
HIDDEN const char*  RIP_TOT_PIC  = "###.###.###.###";
HIDDEN const int    RIGHE_MODULO = 66;
HIDDEN const int    RIGHE_FOOTER = 10;

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     = 150;
HIDDEN const int    AVERE198    = 174;

HIDDEN TString256 tmp;

HIDDEN int date2esc(const TDate& d, int* prevesc = NULL);

HIDDEN enum descr { causale, conto, operazione };

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

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

const TString& TContoOccas::descrizione()
{
  
  if (_occfpi.empty())
    _descrizione = TBill::descrizione();
  else
  {
    TLocalisamfile occ(LF_OCCAS);
    
    occ.zero();
    occ.put(OCC_CFPI, _occfpi);
    if (occ.read() != NOERR) occ.zero();
    
    _descrizione = occ.get("RAGSOC");
    TString80 nome = _descrizione.mid(30);
    _descrizione.cut(30);
    _descrizione.trim();
    nome.trim();
    _descrizione << ' ' << nome;
  } 
  return _descrizione;
}

class CG3400_application : 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);
  
private:
  TRelation  * _rel;
  TCursor    * _cur;
  TRectype   * _RecPartoDa, *_RecArrivoA;    
  int          _ae;         // anno esercizio di ALLA_DATA
  int          _tipo;       // tipo del registro
  int          _annoEsMov;  // anno esercizio letto da mov
  bool         _stampa_definitiva;
  bool        _MovGiaStampato;
  long        _num_rig;
  //    TParagraph_string*      _descr_conto;                
  
public:
  TDate         _inizioEs, _fineEs;    // date inizio e fine esercizio
  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;
  //  bool         _gia_settata_riga_mov;   // per la stampa no iva

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

  TLocalisamfile * _com, *_clifo,*_pconti,*_nditte,*_anag, *_causali;
  TTable         *_tabreg, *_tabval, *_tabes, *_tabiva; 

public:

  virtual void preprocess_header();
  virtual void preprocess_footer();
  virtual bool preprocess_page(int, int);
  virtual print_action postprocess_page(int, int);
  virtual bool preprocess_print(int, int);
  virtual void postclose_print();
  virtual bool cancel_hook();
  virtual bool set_print(int);
  
  virtual bool user_create();
  virtual bool user_destroy();
  
  void      set_rows (int file, int counter);
  void      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         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();
  void aggiorna_tabreg(int, int);
  void aggiorna_mov();
  void set_totali_giorno(const TDate& giorno, const int righeivasettate);
  void get_dati_ditta ();

  const char*   SimboloValuta (const char* cod);
  const char*   get_descr_caus (const char * codcaus);    
  TRectype&     look_com (const char * cod);
  const char*   get_codiva_des(const char* codiva);
  
  CG3400_application() {};
  virtual ~CG3400_application() {};
};

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

//////////////////////////////////////////////////////////////////////////
// Funzioni legate ai parametri ditta
//////////////////////////////////////////////////////////////////////////
HIDDEN bool libro_giornale_iva_unico()
{
  TConfig conf(CONFIG_DITTA);
  return conf.get_bool("StLgiU");
}

HIDDEN bool libro_cronologico()
{
  TConfig conf(CONFIG_DITTA);
  return conf.get_bool("GsLbCn");
}

TRectype& CG3400_application::look_com (const char * cod)
{
  _com->zero();
  _com->put(COM_COM, cod);
  if (_com->read() != NOERR)
    _com->zero();

  return _com->curr();
}

const char* CG3400_application::SimboloValuta (const char* cod)
{
  TString16 codtab; 

  codtab.format ("%-3s", cod); 

  _tabval->zero();
  _tabval->put("CODTAB", codtab);
  _tabval->read();

  if (_tabval->good())
    tmp = _tabval->get("S7");
  else 
    tmp = "";

  return tmp;
}

const char * CG3400_application::get_descr_caus (const char * codcaus)
{
  TLocalisamfile& caus = *_causali;
  
  caus.zero();
  caus.put (CAU_CODCAUS, codcaus);
  if (caus.read() != NOERR) caus.zero();

  tmp = caus.get(CAU_DESCR);
  return tmp;
} 

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

  _nditte->zero();
  _nditte->put(NDT_CODDITTA, get_firm());   
  _nditte->read();

  if (_nditte->bad()) _nditte->zero();

  _ragsoc  = _nditte->get(NDT_RAGSOC);
  codanagr = _nditte->curr().get(NDT_CODANAGR);
  tipoa    = _nditte->curr().get_char(NDT_TIPOA);

  if (tipoa == 'F')
  {           
    TString80 cognome = _ragsoc;
    const char* nome  = cognome.mid(31);
    cognome.cut(30);
    _ragsoc = cognome; 
    _ragsoc << " " << nome;
  }

  _anag->setkey(1);
  _anag->zero();
  _anag->put (ANA_TIPOA, tipoa);
  _anag->put (ANA_CODANAGR, codanagr);
  _anag->read();
  if (_anag->bad()) _anag->zero();
  
  _cofi      = _anag->get(ANA_COFI);
  _paiva     = _anag->get(ANA_PAIV);
  //  _ragsoc    = _anag->get(ANA_RAGSOC);
  _comunefis = _anag->get(ANA_COMRF);

  if (_comunefis.empty()) 
    _comunefis   = _anag->get(ANF_COMRES);

  TRectype dep = look_com (_comunefis);

  _comunefis   = dep.get(COM_DENCOM);
  _provfis     = dep.get(COM_PROVCOM);
  _cap         = dep.get(COM_CAPCOM);
  
  if (_comunefis.empty()) 
  {
    _viafis      = _anag->get(ANA_INDRF);
    _viafis.rtrim();
    _viafis << " " << _anag->curr().get (ANA_CIVRF); 
  }
  else
  {
    _viafis      = _anag->get(ANA_INDRES);
    _viafis.rtrim();
    _viafis << " " << _anag->get (ANA_CIVRES); 
  }
}

bool CG3400_application::user_create()
{
  _ae = 0;
  _tabreg = new TTable ("REG");
  _tabval = new TTable ("%VAL");
  _tabes  = new TTable ("ESC");
  _tabiva = new TTable ("%IVA");
  
  _nditte  = new TLocalisamfile(LF_NDITTE); 
  _anag    = new TLocalisamfile (LF_ANAG); 
  _com     = new TLocalisamfile(LF_COMUNI);
  _clifo   = new TLocalisamfile(LF_CLIFO);
  _pconti  = new TLocalisamfile(LF_PCON);
  _causali = new TLocalisamfile(LF_CAUSALI);

  //  _descr_conto      = new TParagraph_string ("", 50);

  //  disable_print_menu();

  _rel = new TRelation (LF_MOV);
  _rel->add (LF_RMOV,    "NUMREG=NUMREG");
  _rel->add (LF_RMOVIVA, "NUMREG=NUMREG");

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

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

  add_cursor (_cur);

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

bool CG3400_application::user_destroy()
{
  delete _rel;
  delete _cur;
  delete _RecPartoDa;
  delete _RecArrivoA;

  delete _com; delete _clifo; delete _causali; delete _pconti;
  delete _nditte; delete _anag; 
  delete _tabreg; delete _tabes; delete _tabval; delete _tabiva;

  //  delete _descr_conto;
  delete _nditte;
  delete _anag;
  return TRUE;
}

void CG3400_application::aggiorna_mov()
{
  TLocalisamfile& mov = _cur->file(LF_MOV);
  long nprog = _nprog_da + 1;
  
  const TRectype da(*_RecPartoDa);  
  const TRectype  a(*_RecArrivoA);
  _cur->setregion(da, a);
  (*_cur) = 0L;
  
#ifndef DBG2
  TProgind prnd (_cur->items(), "Aggiornamento movimenti ...", FALSE, TRUE);  
#endif
  //  for (mov.read(_isgteq, _lock); mov.curr() < *_RecArrivoA && !mov.eof(); mov.next(_lock))

  for (  ; _cur->pos() < _cur->items(); ++(*_cur))
  {
#ifdef DBG2
    long numreg = _cur->file(LF_MOV).get_long("NUMREG");
    TString datareg(_cur->file(LF_MOV).get("DATAREG"));
    
    message_box("Numreg: %ld Datareg: %s", numreg, (const char*)datareg);
#endif        
    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++;
    }
    //    else mov.reread(_unlock);
#ifndef DBG2  
    prnd.addstatus(1);
#endif    
  }
  //  mov.reread(_unlock);
}


// NB
// Se si usa un codice @g dopo un
// @b (bold) il primo pezzo perde qualche carattere in visualizzazione
// (in stampa su carta non ho provato)
//
void CG3400_application::set_totali_giorno(const TDate& data, const int righeiva)
{
  int       r = 1 + righeiva;
  char      dep[255];
  const int STACC = 51;
  
  if (_tot_avere_gg != ZERO || _tot_dare_gg != ZERO)
  {
    TString td(_tot_dare_gg.string(REAL_PICTURE));
    TString ta(_tot_avere_gg.string(REAL_PICTURE));

    sprintf(dep, "@b@%dgTotale operazioni del %s @%dg%s @%dg%s", 
            _stampa_width == 132 ? DARE132-STACC : DARE198-STACC,
            data.string(),
            _stampa_width == 132 ? DARE132 : DARE198,
            (const char*)td, 
            _stampa_width == 132 ? AVERE132 : AVERE198,                
            (const char*)ta
            );
    
    set_row (r++, "%s", dep);
    _tot_dare_gg  = _tot_avere_gg = ZERO;
  }

  if ( _tot_avere_gg_ap != ZERO || _tot_dare_gg_ap != ZERO )
  {                
    TString tdp(_tot_dare_gg_ap.string(REAL_PICTURE));
    TString tap(_tot_avere_gg_ap.string(REAL_PICTURE));

    sprintf (dep, "@b@%dgTotale operazioni del %s Anno precedente @%dg%s @%dg%s", 
             _stampa_width == 132 ? DARE132-STACC : DARE198-STACC,
             data.string(),
             _stampa_width == 132 ? DARE132 : DARE198,
             (const char*)tdp, 
             _stampa_width == 132 ? AVERE132 : AVERE198,                
             (const char*)tap
             );

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

    _tot_avere_gg_ap = _tot_dare_gg_ap = ZERO;
  } 

  set_row (r, "");      // Lascio una riga vuota dopo il totale
}


void CG3400_application::postclose_print()
{
  if (_stampa_definitiva)
  {
    const int ultima_fatta = printer().getcurrentpage() - 1;
    //    const int stampate = ultima_fatta - _pagina_da + 1;  
    
    if (yesno_box("La stampa e' corretta ? "))
    {
      _pagina_da = -1;
      aggiorna_mov ();
      aggiorna_tabreg (_pagina_da, ultima_fatta);
    }
  }
}

void CG3400_application::preprocess_footer()
{
  TString           progr_dare_ap(22), progr_avere_ap(22);
  TString           progr_dare, progr_avere, dts, ats;
  TString256        riga;
  bool              ap = FALSE;
  int               r=2;
  const int STUMB  = 42;
  real              dt, at;
  
  reset_footer();
  
  if (_tot_avere_progr_ap != ZERO || _tot_dare_progr_ap != ZERO)
  {
    progr_dare_ap  = _tot_dare_progr_ap.string(REAL_PICTURE);
    progr_avere_ap = _tot_avere_progr_ap.string(REAL_PICTURE);
    ap = TRUE;
  }
  
  if (_cur->pos() >= _cur->items()-1)    // se sono sull'ultimo
  {
    progr_dare  = _tot_dare_progr.string(REAL_PICTURE);
    progr_avere = _tot_avere_progr.string(REAL_PICTURE);  
    riga = "";        
    riga.format("@b@%dgTotale progressivi                 @%dg%c %s @%dg%c %s", 
                _stampa_width == 132 ? DARE132-STUMB : DARE198-STUMB,
                _stampa_width == 132 ? DARE132-1  : DARE198,
                _stampa_width == 132 ? 'D' : ' ',
                (const char *) progr_dare, 
                _stampa_width == 132 ? AVERE132 : AVERE198,
                _stampa_width == 132 ? 'A' : ' ',
                (const char *) progr_avere
                );    

    set_footer (r++, (const char*) riga);    
    
    if (ap)
    {
      riga.format("@b@%dgTotale progressivi anno precedente    @%dg%c %s @%dg%c %s", 
                  _stampa_width == 132 ? DARE132-STUMB : DARE198-STUMB,
                  _stampa_width == 132 ? DARE132-1  : DARE198,
                  _stampa_width == 132 ? 'D' : ' ',
                  (const char *) progr_dare_ap, 
                  _stampa_width == 132 ? AVERE132 : AVERE198,
                  _stampa_width == 132 ? 'A' : ' ',
                  (const char *) progr_avere_ap
                  );    
      set_footer (r++, (const char*) riga);
    }
    
    _tot_dare_generale  = _tot_dare_progr  + _tot_dare_progr_ap;
    _tot_avere_generale = _tot_avere_progr + _tot_avere_progr_ap;
    dts = _tot_dare_generale.string(REAL_PICTURE);
    ats = _tot_avere_generale.string(REAL_PICTURE);
    
    riga.format("@b@%dgTotale progressivi generali           @%dg%c %s @%dg%c %s", 
                _stampa_width == 132 ? DARE132-STUMB : DARE198-STUMB,
                _stampa_width == 132 ? DARE132-1  : DARE198,
                _stampa_width == 132 ? 'D' : ' ',
                (const char *) dts, 
                _stampa_width == 132 ? AVERE132 : AVERE198,
                _stampa_width == 132 ? 'D' : ' ',
                (const char *) ats
                );    

    set_footer (r++, (const char*) riga);          
  }
else      // Non ancora totale generale
{
  dt = _tot_dare_progr  + _tot_dare_progr_ap;
  at = _tot_avere_progr + _tot_avere_progr_ap;
  dts = dt.string(REAL_PICTURE);
  ats = at.string(REAL_PICTURE);

  riga.format ("@b@%dgA riportare                    @%dg%c %s @%dg%c %s", 
               _stampa_width == 132 ? DARE132-STUMB : DARE198-STUMB,    
               _stampa_width == 132 ? DARE132-2  : DARE198,
               _stampa_width == 132 ? 'D' : ' ',                   
               (const char *) dts,
               _stampa_width == 132 ? AVERE132 : AVERE198,
               _stampa_width == 132 ? 'A' : ' ',                   
               (const char *) ats);
  set_footer (r++, (const char*) riga);          
}
}

int CG3400_application::stampa_intestazione_ditta()
{
  int           r=1;
  TString256    intes;
#if XVT_OS == XVT_OS_SCOUNIX                     
  TString riga(_stampa_width);
#endif

  get_dati_ditta();

#if XVT_OS == XVT_OS_SCOUNIX                     
  riga.fill('_'); 
  set_header(r, riga);
#endif

  set_header (++r, "Ditta: %s %s %s %s %s", (const char *)_ragsoc, 
              (const char *)_viafis, (const char *)_cap, 
              (const char *)_comunefis, (const char *)_provfis); 
  
  intes.format ("Partita iva %s @24gCodice fiscale %s @%dg%s @%dgData @>", 
                (const char*)_paiva, (const char*)_cofi, 
                _stampa_width == 132 ? 102 : 168,
                _stampa_definitiva ? "" : "LIBRO DI PROVA",
                _stampa_width == 132 ? 117 : 183
                );
  
  set_header (++r, "%s", (const char*)intes);
  r++;
  return r;
}

int CG3400_application::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();

  if (_stampa_definitiva)                                         
    set_header(r++, "Codice libro: %s %s ",(const char *) _reg_cod, (const char *) _reg_descr);
  else
    set_header(r++, "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
               );

#if XVT_OS != XVT_OS_SCOUNIX                     
  TString   backg(30);
  const int width = _stampa_width + 1;

  if (_stampa_intesta || !_stampa_definitiva)  
    backg.format("W4l{1 1 %d 1}W4l{1 5 %d 5}W1l{1 8 %d 8}", width,width,width);
  else
    backg.format("W4l{1 2 %d 2}W1l{1 5 %d 5}", width,width);

  set_background(backg);
  r++;
#else
  riga.fill('_'); 
  set_header(r, riga);
#endif

  /*if (_libro_giornale_iva_unico)
    {*/
  /*if (!_stampa_definitiva)
    set_header(r, "Ri"); */
  
  if (_libro_cronologico)
    set_header(r, "@59gCodice         Conto"); 

  if (!_stampa_definitiva) {
    if (_stampa_width == 132) {
      set_header(r++, "@131gS");    
      set_header(r, "@1gN.riga"); 
    }
    else {
      set_header(r++, "@197gS");    
      set_header(r, "@1gN.riga");       
    }
  }
  else
    r++;
  
  //    set_header(r, "@6gCod.Causale@34gDescrizione operazione");
  set_header(r, "@8gDescrizione operazione");
  if (_libro_cronologico)
    set_header(r, "@59gGeneralita' cliente/fornitore"); 
  else
    set_header(r, "@59gCodice         Conto"); 
  
  if (_stampa_width == 132)
    set_header(r, "@120gImporto");
  else
    set_header(r, "@161gDare @184gAvere");
  
  if (!_stampa_definitiva)          
    set_header(r, _stampa_width == 132 ? "@131gB" : "@197gB");
  
  r++;
  /*}
    else    // NO LIBRO GIORNALE IVA UNICO
    {
    set_header(r, "Numero@12gDocumento@28gCodice@115gImporti@127g  A"); 
    if (_libro_cronologico)
    set_header(r, "@41gDescrizione conto"); 
    if (!_stampa_definitiva)
    set_header(r, "@131gS"); 
    r++;

    if (_stampa_definitiva)
    set_header(r, "Riga"); 
    else
    set_header(r, "Regist."); 

    set_header(r, "@10gData e numero@28gConto@68gDescrizione operazione@106gDare@122gAvere@127g  C");
    if (_libro_cronologico)
    set_header(r, "@41gGeneralita' cliente/fornitore");
    else  
    set_header(r, "@41gDescrizione conto"); 

    if (!_stampa_definitiva)
    set_header(r, "@131gB"); 
    r++;
    } */

#if XVT_OS == XVT_OS_SCOUNIX                     
  riga.fill('-'); 
  set_header(r, riga);
#endif
  
  return r;
}

void CG3400_application::preprocess_header()
{
  int r      = _last_header + 1;
  int pag    = printer().getcurrentpage();
  TString256   riporto;
  real         riporto_dare, riporto_avere;
  
  if (pag > 0)   // Stampa riporti
  {
    riporto_dare  = _tot_dare_progr  + _tot_dare_progr_ap;
    riporto_avere = _tot_avere_progr + _tot_avere_progr_ap;

    TString dare (riporto_dare.string(RIP_TOT_PIC));
    TString avere(riporto_avere.string(RIP_TOT_PIC));
    // RIP_TOT_PIC adesso e' lunga 15

    riporto.format("@b@%dgRiporto: @%dg%15s @%dg%15s", 
                   _stampa_width == 132 ? 84 : DARE198-11,
                   _stampa_width == 132 ? DARE132 : DARE198,
                   (const char *) dare,
                   _stampa_width == 132 ? AVERE132 : AVERE198,
                   (const char *) avere 
                   );    

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

    set_header (r, "");
  }
}

//
// 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 CG3400_application::preprocess_print(int file, int counter)
{
  switch (file)
  {
  case LF_MOV:
    
    //   _gia_settata_riga_mov = FALSE;  // Stampa o no la riga di mov (solo se 
    // NO stampa giornale_iva_unico                                        
    _num_rig            = 0;
    _iva_array.destroy();
    
    _nprog_mov   = _nprog_da;

    *_RecPartoDa = _cur->file(LF_MOV).curr();

    break;
  default:
    break;
  }
  return TRUE;
}

bool CG3400_application::cancel_hook()
{
  int ultima_fatta = printer().getcurrentpage() - 1;
  //  int stampate = ultima_fatta - _pagina_da + 1;

  if (yesno_box ("Interrompo la stampa ?"))
  {
    if (_stampa_definitiva) 
      aggiorna_tabreg (ultima_fatta, ultima_fatta);
    return TRUE;
  }
  else
    return FALSE;
}

print_action CG3400_application::postprocess_page(int file, int counter)
{
  int righe_iva_settate=0;
  static bool nuovo_mese = FALSE;
  
  if (counter) 
  {
    if (nuovo_mese) {
      printer().formfeed();
      nuovo_mese = FALSE;
    }
    return NEXT_PAGE;
  }

  switch (file)
  {
  case LF_MOV:

    reset_print();

    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();

    //    if (_data_corr != _data_succ || _cur->lastrec()) 
    if (_data_corr != _data_succ || _cur->pos() == _cur->items())
    {
      nuovo_mese = (_mese_succ != _mese_corr);
      set_totali_giorno(_data_corr, righe_iva_settate);
      //      _gia_settata_riga_mov = FALSE;
      return REPEAT_PAGE;
    }
    //    else _gia_settata_riga_mov = TRUE;

    if (righe_iva_settate > 0)
      return REPEAT_PAGE;
    
    break;

  case LF_RMOVIVA:
  default:
    break;
  }
  return NEXT_PAGE;
}

void CG3400_application::set_rows (int file, int counter)
{
  TString16     datadoc, datareg, reg, numdoc, frm, caus;
  TString80     mov_descr, rmv_descr;
  TParagraph_string descr_conto("", 50);
  TContoOccas   tc;  
  long          numreg, protiva;
  int           r = 1, rdes=1;
  int           g, c;          
  long          s;
  char          sezione;
  real          importo;
  static char   cf;
  
  switch (file)  
  {
  case LF_MOV:
    /*
       if (_libro_giornale_iva_unico)
       {
       */
    reset_row(1);
    reset_row(2);
    datareg   = _cur->file(LF_MOV).get("DATAREG");        
    datadoc   = _cur->file(LF_MOV).get("DATADOC");        
    numdoc    = _cur->file(LF_MOV).get("NUMDOC");        
    numreg    = _cur->file(LF_MOV).get_long("NUMREG");        
    mov_descr = _cur->file(LF_MOV).get("DESCR");                    
    reg       = _cur->file(LF_MOV).get(MOV_REG);  
    protiva   = _cur->file(LF_MOV).get_long(MOV_PROTIVA);   
    caus      = _cur->file(LF_MOV).get(MOV_CODCAUS);  
    _occfpi   = _cur->file(LF_MOV).get(MOV_OCFPI);  
    _annoEsMov = _cur->file(LF_MOV).get_int(MOV_ANNOES);

    if (_stampa_definitiva)                     
    {
      set_row(r,"Operazione n. %-7ld", _nprog_mov);
      set_row(r," del %s", (const char*)datareg);
      set_row(r," documento n. %-7s",(const char*)numdoc);
      set_row(r," del %s %s",(const char*)datadoc,(const char*)mov_descr);
    }
    else
    { 
      set_row(r,"Operazione n. %7ld", numreg);
      set_row(r," del %s", (const char*) datareg);
      set_row(r," documento n. %-7s", (const char*) numdoc);
      set_row(r," del %s %s", (const char*)datadoc,(const char*)mov_descr);
    }

    if (_annoEsMov != _ae)
      set_row(r," Comp. %04d", _annoEsMov);          
    if (reg.not_empty())
      set_row(r, " (R.IVA %3s Prot. %ld) ", (const char*)reg,protiva);

    if (_MovGiaStampato && !_stampa_definitiva)
      set_row(r,format("@%dg*",_stampa_width == 132 ? 131 : 197));

    if (caus.not_empty())
    {
      TString80 desc_caus(get_descr_caus(caus));
      set_row(r+1, "@37gCausale %s %s", (const char*) caus, (const char*) desc_caus);
    } 

    /**************
      }
      else
      if (!_gia_settata_riga_mov)
      {
      set_row (r, "Operazioni del %s", datareg);
      _gia_settata_riga_mov = TRUE;
      }
      ****/
    
    break;
    
  case LF_RMOV:

    _num_rig++; 
    //    if (!_libro_giornale_iva_unico) _nprog_mov++;     
    
    reset_row(1);
    
    if (cf > ' ') {  // Per pulire le righe di indirizzo eventualmente settate prima.
      reset_row(2); reset_row(3);reset_row(4);
    }       
    
    g         = _cur->file(LF_RMOV).get_int("GRUPPO");      
    c         = _cur->file(LF_RMOV).get_int("CONTO");      
    s         = _cur->file(LF_RMOV).get_long("SOTTOCONTO");          
    cf        = _cur->file(LF_RMOV).get_char(RMV_TIPOC);    
    numreg    = _cur->file(LF_RMOV).get_long("NUMREG");    
    datareg   = _cur->file(LF_RMOV).get("DATAREG");                  
    sezione   = _cur->file(LF_RMOV).get_char (RMV_SEZIONE);
    importo   = _cur->file(LF_RMOV).get_real (RMV_IMPORTO);    
    rmv_descr = _cur->file(LF_RMOV).get(RMV_DESCR);

    /*
       if (_libro_giornale_iva_unico)
       {
       */                
    r=1;

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

    /*************
      }
      else   // no libro_giornale_iva_unico
      {
      if (_stampa_definitiva) 
      set_row (r, "%-3ld", _nprog_mov);
      else
      set_row (r, "%3ld",  numreg);
      set_row (r, "@4g@d",   (const char*)datareg);
      set_row (r, "@13g%02d.", g);
      set_row (r, "%02d.",     c);
      set_row (r, "%06d",      s);
      }
      *******************************************************/

    tc.set(g,c,s,cf,NULL,-1,_occfpi);

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

    tmp = tc.descrizione();
    descr_conto = tmp;
    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*) tmp);
    }
    
    if (cf > ' ')
      if (_libro_cronologico)
        setta_righe_indirizzo(cf, s, rdes);    
    
    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;
      }
    }
    
    if (_stampa_width == 132)
    {
      set_row (r, "@112g%r", &importo);
      set_row (r, "@128g%c", sezione);  
    }
    else  //  stampa_width == 198
      set_row (r, sezione == 'D' ? "@150g%r" : "@174g%r", &importo);      
    
    if (_MovGiaStampato && !_stampa_definitiva)
      set_row(r,format("@%dg*",_stampa_width == 132 ? 131 : 197));

    break;

  default:
    break;
  }
}

//
// PREPROCESS_PAGE
//
// Non stampo niente se:
//
// 1. STAMPATO = TRUE     
//       OPPURE
// 2. non ci sono righe di RMOV
//
bool CG3400_application::preprocess_page(int file, int counter)
{
  if (counter) return TRUE;

  switch (file)  {
    
  case LF_MOV:
    
    _annoEsMov      = 0;    
    _iva_array.destroy();
    
    if (!_cur->is_first_match(LF_RMOV)) return FALSE;

    _MovGiaStampato = _cur->file(LF_MOV).get_bool(MOV_STAMPATO);

    if (_MovGiaStampato && _stampa_definitiva)
      return FALSE;
    
    *_RecArrivoA = _cur->file(LF_MOV).curr();

    //    if (_libro_giornale_iva_unico) _nprog_mov++; 
    _nprog_mov++;

    _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();    
    
    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 CG3400_application::calcola_iva()
{
  TString  codiva;
  int      tipocr, tipodet, tipoatt;
  real     impo, impos;
  bool     intra;
  TRectype iva (_cur->file(LF_RMOVIVA).curr());

  if (!iva.empty())
  {
    impo    = iva.get_real (RMI_IMPONIBILE);
    impos   = iva.get_real (RMI_IMPOSTA);
    tipocr  = iva.get_int (RMI_TIPOCR);
    tipodet = iva.get_int (RMI_TIPODET);
    tipoatt = iva.get_int ("TIPOATT");
    codiva  = iva.get (RMI_CODIVA);
    intra   = iva.get_bool (RMI_INTRA);
    _iva_array.add_riga(impo,impos,ZERO,ZERO,codiva,tipodet,0,intra,tipoatt);
  }
}

int CG3400_application::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 char* CG3400_application::get_codiva_des(const char* codiva)
{
  _tabiva->zero();
  _tabiva->put("CODTAB", codiva);
  if (_tabiva->read() == NOERR)
    return _tabiva->get("S0");
  else
    return NULL;  
}

// 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 CG3400_application::setta_righe_iva()
{
  int r=0, j;

  for (j = 0; j < _iva_array.items(); j++)
  {
    TRigaiva& riga = (TRigaiva&)_iva_array[j];
    r = j+1;
    set_row(r, "Imponibile@12g%r",    &riga._imponibile);
    set_row(r, "@31gImposta@39g%r",   &riga._imposta);
    set_row(r, "@58gCod.Iva@68g%3s", (const char*)riga._codiva);
    const TString80 codiva_des(get_codiva_des(riga._codiva));    
    const int       tipoatt = riga._tipoatt;
    set_row(r, "@73g%20s", (const char*)codiva_des);    
    switch (riga._tipodet)
    {
    case 0 : set_row(r, "@94gDetraibile");
             break;
           case 1 : set_row(r, "@94gIndetraibile su op.es.");
             break;
           case 3 : set_row(r, "@94gPassaggi interni");
             break;
           case 9 : set_row(r, "@94gIndetraibile art.19");
             break;
           default: break;   
           } 
    set_row(r, " Tipo attivita' %d", tipoatt);
  } 
  _iva_array.destroy();
  set_row (j+1, "");  // lascio una riga vuota dopo tutto cio'
  return r; 
}

int CG3400_application::setta_righe_valuta(int riga)
{      
  const char*   simbolo;
  TString16     codvali;
  real          corrval;
  int           r = riga+1;

  corrval   = current_cursor()->file(LF_MOV).get_real(MOV_CORRVALUTA);
  
  if (corrval != ZERO)
  {  
    codvali   = current_cursor()->file(LF_MOV).get(MOV_CODVALI);
    simbolo   = SimboloValuta(codvali);  
    TString valut(corrval.string(REAL_PICTURE));

    if (simbolo && *simbolo)
      set_row(r,"@58gValuta %5s", simbolo);
    else
      set_row(r,"@58gValuta %3s", (const char*)codvali);

    set_row(r++,"@84gCorr.in valuta @112g%s", (const char*)valut);
  }
  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
void CG3400_application::setta_righe_indirizzo(char tipocf, long codcf,int rdes)
{
  TString16 prov, comcf, capcf, civcf, statocf;
  TString80 viacf, comune;
  bool      really_occas = FALSE;     
  char      tipoa;
  long      codanagr;    
  char      riga[256];
  int       r = rdes;
  
  _clifo->zero();
  _clifo->put(CLI_CODCF, codcf);
  _clifo->put(CLI_TIPOCF, tipocf);

  const bool clifo_ok = (_clifo->read() == NOERR);

  if (clifo_ok) really_occas = _clifo->get_bool(CLI_OCCAS);

  if (_occfpi.not_empty() && really_occas)   // => e' un occasionale...
  {
    TLocalisamfile occ(LF_OCCAS);
    
    occ.zero();
    occ.put(OCC_CFPI, _occfpi);
    if (occ.read() != NOERR) occ.zero();
    
    viacf = occ.get (OCC_INDIR);
    civcf = occ.get (OCC_CIV);
    capcf = occ.get (OCC_CAP);
    comcf = occ.get (OCC_COM);
  } 
else 
{
  // E' possibile cio' ?
  if (!clifo_ok) return;

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

TRectype rec = look_com (comcf);
comune       = rec.get(COM_DENCOM);
prov         = rec.get(COM_PROVCOM);

sprintf (riga, "@%dg%s %s",
         POSCONTO,
         (const char*) viacf,
         (const char*) civcf
         );

         set_row (r++, riga);

         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;
  //    TString80 viana;
  TString16 datana, codcomna, provna, capna, statona;
  
  TLocalisamfile anafis (LF_ANAGFIS);  
  
  anafis.zero();
  anafis.put("CODANAGR", codanagr);
  if (anafis.read() != NOERR) anafis.zero();
  
  datana = anafis.get("DATANASC");
  
  if (datana.not_empty())
  {
    codcomna  = anafis.get("COMNASC");
    TRectype dep = look_com (codcomna);

    comna     = dep.get(COM_DENCOM);
    provna    = dep.get(COM_PROVCOM);
    capna     = dep.get(COM_CAPCOM);
    
    statona   = anafis.get("STATO");        

    sprintf (riga, "@%dg%s %s %s %s", POSCONTO,
             (const char*)datana,
             (const char*)comna,
             (const char*)provna, (const char*) capna);
    
    set_row(r++, riga);
  }
}
}

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

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

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

  if (_tabreg->good())
  {
    _tabreg->put ("I7", (long)partito_da); // partito_da = -1 se stampa OK
    if (partito_da == -1)
    {
      _tabreg->put ("I1", (long)_pagine_stampate + 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 CG3400_application::controlla_mov_aep()
{                  
  const int aep = _ae - 1;  
  
  _cur->setfilter(format("ANNOES=%04d && STAMPATO!=\"X\"", aep));
  (*_cur) = 0L;

  _cur->setfilter("");  

  if (_cur->items() > 0)
  {
    warning_box("Impossibile proseguire nella stampa.\nEsistono movimenti nell'esercizio precedente non ancora stampati su bollato");
    return FALSE;
  }
  
  return TRUE;
}

bool CG3400_application::leggi_tabreg(const char * reg_cod, int reg_anno)
{
  TString16 codtab;

  _ae = reg_anno;

  codtab.format ("%04d%-3s", reg_anno, reg_cod);

  _tabreg->zero();
  _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_ok       = _tabreg->get_int("I7");
  _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;
}

// Calcola l'anno di esercizio di una data                                
// Certified 99%
HIDDEN int date2esc(const TDate& d, int* prevesc)
{                   
  if (prevesc) *prevesc = 0;
  TTable esc("ESC");
  for (int err = esc.first(); err == NOERR; err = esc.next())
  {
    const TDate ia(esc.get("D0"));   // Data inizio esercizio
    const TDate fa(esc.get("D1"));   // Data fine esercizio
    app()._inizioEs = ia;
    app()._fineEs   = fa;
    const anno = esc.get_int("CODTAB");  
    if (d >= ia && d <= fa)
      return anno;
    if (prevesc) *prevesc = anno; 
  } 
  return 0;
}

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

// NB
// Qui viene compilato app()._ae
// L'anno di esercizio e' determinato da DATA_A
//
bool CG3400_application::data_a_hndl (TMask_field& f, KEY k)
{
  TMask&          m = f.mask();          

  if (f.to_check(k))
  {
    const TDate     data_a(f.get());                  
    const int       ae = date2esc(data_a); // Anno esercizio
    TString16       dep(data_a.string());
    
    if (dep.empty()) return TRUE;                   
    
    app()._ae = ae;
    
    if (ae == 0) 
      return f.error_box("La data specificata non appartiene a nessun esercizio");
  }
  
  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());   
    const int       ae = app()._ae; 
    const TMask_field& fld_dtda = m.field(DATA_DA);

    if (definitiva)  
    {     
      if (dtda.not_empty())  // senno' ci metto inizioEs
      {
        if (data_da < app()._inizioEs || data_a > app()._fineEs);
        return f.warning_box("Le date specificate non appartengono allo stesso esercizio");
        if (data_da > data_a)
          return f.warning_box("La data di partenza non puo' essere maggiore della data finale");
      }
    }
  }  // if K_ENTER

  return TRUE;
}

bool CG3400_application::data_da_hndl(TMask_field& f, KEY k)
{
  TMask&              m = f.mask();          
  if (f.to_check(k))
  {
    const TDate         data_da (f.get());
    const TString16     data_a(m.get(DATA_A));    
    const int           ae_data_da = date2esc(data_da);
    const TString16     dep(data_da.string());
    
    if (dep.empty() || data_a.empty())
      return TRUE;
    
    if (app()._ae != 0)
      if (app()._ae != ae_data_da)
        return f.error_box("Le due date non appartengono allo stesso esercizio");
  }

  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());                  
    TString16       dtda(data_da.string());   

    // Controlli sulle date    

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

//
// MASK_A_COD_REG
// 
// Aggiorna il campo PAGINA_DA della maschera
//
// Legge la tabella dei registri e controlla se la stampa precedente
// era andata a buon fine.  
// Se no, riempie il campo PAGINA_DA con il valore precedente.
// Se si', mette semplicemente l'ultimo numero di pagina precedente + 1
//
bool CG3400_application::mask_a_cod_reg (TMask_field& f, KEY k)
{
  if (k == K_TAB || k == K_ENTER)
  {
    TMask&              m = f.mask();
    CG3400_application& a = app();    
    const bool definitiva = m.get_bool(STAMPA_DEF);
    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;

    const TString16 reg_cod(f.get()); 

    if (reg_cod.empty())
    {
      if (k == K_TAB)   // Magari ci ripassa e lo inserisce
        return TRUE;
      else              // Se e' K_ENTER mi serve davvero
        return f.warning_box("Manca il codice registro");
    }
    
    bool reg_ok = a.leggi_tabreg(reg_cod, a._ae);

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

    // CHECKTYPE NORMAL abolito! (nella maschera non ho l'anno...
    if (!reg_ok) 
      return f.warning_box("Registro inesistente");
    
    if (app()._tipo != 5)
      return f.warning_box("Il registro %s per l'anno %d non e' di tipo libro giornale",
                           (const char *) reg_cod, a._ae);

    /*if (definitiva)
      {
      if (a._stampa_ok == -1)     // stampa precedente andata bene
      m.set(PAGINA_DA, a._pagine_stampate+1);
      else
      m.set(PAGINA_DA, a._stampa_ok);
      }*/
  }
  return TRUE;
}

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

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

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

  if (k == K_ENTER || k == K_ESC)
    gia_detto = FALSE;
  
  return TRUE;
}

void CG3400_application::init_print()
{
  if (_stampa_len != 0) 
    printer().formlen(_stampa_len);
  else
    printer().formlen(RIGHE_MODULO); 

  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;

  //  force_setpage(TRUE);      
  
  printer().set_from_page (_pagina_da);

  // la stampa precedente era andata male  
  //  if (_stampa_ok != -1) set_page_number (_stampa_ok); 
  
  _last_header = set_headers();
}

void CG3400_application::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;
  _tot_dare_progr     = _tot_dare;
  _tot_avere_progr    = _tot_avere;
}

bool CG3400_application::init_cursor()
{
  TRectype da (_cur->file(LF_MOV).curr());
  TRectype a  (_cur->file(LF_MOV).curr());

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

  _cur->setregion(da, a);

  if (_cur->items() == 0)
    return warning_box ("Non ci sono movimenti.\nLa stampa e' annullata");

  return TRUE;
}

bool CG3400_application::set_print(int)
{
  TMask ma ("cg3400a");
  KEY   tasto;

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

  while ((tasto = ma.run()) != K_QUIT)
  {
    _libro_giornale_iva_unico = libro_giornale_iva_unico();
    _libro_cronologico        = libro_cronologico();

    _reg_cod           = ma.get(CODREG);
    _stampa_definitiva = ma.get_bool(STAMPA_DEF);
    _data_da           = ma.get(DATA_DA);
    _data_a            = ma.get(DATA_A);
    _pagina_da         = ma.get_int(PAGINA_DA);
    _stampa_width      = ma.get_int(STAMPA_WIDTH);
    _stampa_len        = ma.get_int(STAMPA_LEN);

    // Se stampa definitiva DALLA_DATA e' la data di inizio esercizio
    // e si scartano i movimenti gia' stampati su bollato
    if (_stampa_definitiva) 
    {
      _data_da = _inizioEs;

      // Controlla che non siano rimasti movimenti ancora da stampare dell'es.prec.
      if (_stampa_stesso_registro) 
        if (!controlla_mov_aep()) 
          continue;
    }
    
    init_print();
    
    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());
      tasto = mb.run();           
      if (tasto == K_ENTER) 
      {
        real dare2;
        _nprog_da   = mb.get_long(N_RIGA_STAMPATO);
        _last_data  = mb.get(ULTIMA_DATA);
        dare2       = mb.get_long(PROGR_DARE);
        // "Se l'utente cambia il progressivo dare, esso viene uguagliato all'avere"        
        if (dare2 != _tot_dare)
        {
          _tot_dare     = dare2;
          _tot_avere    = dare2;
        }
      }
      else
        continue;
    }

    if (!init_cursor()) return FALSE;
    init_totals();

    return TRUE;
  }
  return FALSE;
}

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