campo-sirio/cg/cg3200.cpp

#include <currency.h>
#include <modaut.h>
#include <msksheet.h>
#include <printapp.h>
#include <utility.h>

#include "cg3.h"
#include "cg3200.h"
#include "cglib02.h"
#include "cglib03.h"

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

class TMastrini_record : public TRectype
{
  TBill _bill;
  
protected:
  virtual const TString& get_str(const char* fieldname) const;
  virtual int length(const char* fieldname) const;  
  virtual TFieldtypes type(const char* fieldname) const;
  
public:
  TMastrini_record() : TRectype(LF_SALDI) { }
  virtual ~TMastrini_record() { }
};

const TString& TMastrini_record::get_str(const char* fieldname) const
{                                   
  if (strcmp(fieldname, RMV_DESCR) == 0)
  {          
    const int g = atoi(TRectype::get_str(RMV_GRUPPO));
    const int c = atoi(TRectype::get_str(RMV_CONTO));
    const long s = atol(TRectype::get_str(RMV_SOTTOCONTO));
    ((TBill&)_bill).set(g, c, s);
    const TString& descr = _bill.descrizione();
    return descr;
  }
  return TRectype::get_str(fieldname);
}

int TMastrini_record::length(const char* fieldname) const
{
  if (strcmp(fieldname, RMV_DESCR) == 0)
    return 50;
  return TRectype::length(fieldname);
}

TFieldtypes TMastrini_record::type(const char* fieldname) const
{
  if (strcmp(fieldname, RMV_DESCR) == 0)
    return _alfafld;
  return TRectype::type(fieldname);
}

class TMastrini_application : public TPrintapp
{
  static bool anno_hnd(TMask_field& f, KEY k);
  static bool data_inizio (TMask_field& f, KEY k);
  static bool data_fine   (TMask_field& f, KEY k);
  static bool gruppo_hnd  (TMask_field& f, KEY k);
  static bool tipocf_hnd  (TMask_field& f, KEY k);
  static bool contoi_hnd  (TMask_field& f, KEY k);
  static bool contof_hnd  (TMask_field& f, KEY k);
  static bool sottoc_handler_ini  (TMask_field& f, KEY k); 
  static bool sottoc_handler_fine (TMask_field& f, KEY k);
  static bool cdc_handler (TMask_field& f, KEY k);
  
  static bool memorizza_handler(TMask_field& f, KEY k);
  static bool scelte_notify(TSheet_field& s, int r, KEY k);

  TDociva_array      _b;
  TRelation*         _rel;
  TMask*             _msk;
  TTable*            _tabivd, * _tabtpd, * _tabreg;
  TSaldo*            _sld;
  TParagraph_string* _d18,* _d22,* _d30;
  TArray             _riga, _lista;
  
  TDate _data_ini,_data_fine,_data_finese,_data_finesesucc,_ultima_data_reg;
  TDate _datareg,_datadoc,_data_inizioese,_datareg_stampa,_inizioes;
  int _cur1,_cur2,_gruppo,_conto,_numcarat,_stampanum,_numivd,_annoiva;
  int _numrig,_natdoc,_tipo,_selez_mastrini,_g_prec,_c_prec,_numrivd_int;
  real _progredare,_progreavere,_totprogre_dare_al,_totprogre_avere_al;
  real _totprogre_dare,_totprogre_avere,_importo;
  real _riporto_dare,_riporto_avere,_riporto_parziale_dare,_riporto_parziale_avere;
  real _totale_periodo_dare,_totale_periodo_avere,_totale_prima_dare,_totale_prima_avere;
  real _saldo_periodo,_saldo_progre,_saldo_progre_al,_saldo_progre_prec;
  real _saldo_movimenti,_saldo_progressivi,_totale_saldo,_riporto_footer_dare,_riporto_footer_avere;
  TString _ragsoc,_indulc,_civulc,_capulc,_com,_prov,_comulc;
  long _codice_ditta,_s_prec;
  TString _tipodoc,_codcaus,_descrcaus,_descrdociva,_regiva,_g_contr,_c_contr,_s_contr,_descrcontr;
  char    _sezivd,_lettivd; 
  TString _descrizione,_sezione,_numdoc,_descrizionemov,_numrivd,_descr;
  TString _dataregs, _datadocs;
  int     _gruppocontr,_contocontr,_nummast,_pagina;
  long    _sottocontocontr;

  bool _stampaprogre,_stampatotiva,_stampatot,_stampa_mov_prov;
  bool _stampato,_devi_stampare_footer;
  int _stampa_saldo_des;
 
  int  _annomsk,_annoesmsk,_annoes,_annomsksucc,_tipo_mask,_anno_ghost;
  int  _anno_corrente,_anno_precedente,_indbil,_numero_pag;
  long _sottoc,_numreg,_numgio,_protiva;
  bool _stampa_progressivi_si,_competenza,/*_inizio_stampa,*/_puoi_stampare,_stampa_footer_si;
  bool _cambia_mastrino,_gia_stampata_intestazione;
  char _tmcf,_tipo_contr; 
  
  bool _flag_del_cazzo;

  TDate _dataregrmov;
  int  _gruppof,_contof;
  long _sottocf;
  TString _dataregrmovstring,_importo_str,_saldo_movimenti_str,_saldo_progressivi_str;

  int  _rw, _conta_mastrini, _indice_array, _item, _item_lista, _indice_lista;
  int  _ddociva_len;

  bool _noseparator, _print_cdc;
  TString _real_picture;

  TString _cdc, _fsc, _riga_commessa;


  real _totale_commessa_dare, _totale_commessa_avere, _saldo_commessa;

  
protected:
  virtual bool user_create() ;
  virtual bool user_destroy();
  virtual bool set_print(int m);
 
  virtual bool preprocess_print(int file, int counter);
  virtual bool preprocess_page (int,int);
  virtual print_action postprocess_page (int,int);
  virtual print_action postprocess_print(int,int);
  virtual void preprocess_header();   
  virtual void preprocess_footer();
  virtual void set_page(int,int);
  virtual void process_link(int id, const char* txt);
      
  void set_handlers(TMask* msk) const;
  bool mask2sheet();
  bool sheet2mask();

  const char* real2str(const real& r) const;
  bool show_cdc();
  
public:
  
  int  date2esc(const TDate& d);   
  void ricerca_clifo();
  void ricerca_gruppo();
  int  ricerca_clifo(int riga);
  int  ricerca_gruppo(int riga);

  void calcola_progressivi(bool finali = FALSE);
  void calcola_progressivi_al(const TDate& data); 
  int  stampa_progressivi(int start_riga);
  int  stampa_progre_riporto(int start_riga);
  void documenti_iva();
  void ricerca_regiva();
  void descrizione_causale();
  int  crea_intestazione(int riga);
  void crea_intestazione();
  void fai_stampa132();
  void fai_stampa198();
  void stampa_totali132();
  void stampa_totali198();      
  void stampa_totali132_II();
  void stampa_totali198_II();  
  void carica_array_totali132();
  void carica_array_totali198();  
  void stampa_totaliiva();  
  void stampa_totali_commessa();
  void ricerca_classe_IV(bool scelta);
  void data_fine_esercizio(int);
  const char* descrizione_gruppo();
  const char* descrizione_conto();    
  const char* descrizione_sottoconto();
  const char* descrizione_classe(char,char,int,int);
  bool almeno_un_record();
  void ricerca_dati_ditta();
  void conto(int,int,bool);                       
  bool check_ordine(TMask_field& f, KEY k);
  
  void setta_riga (int r, const TString& riga);              
  int  righe_rimaste_da_stampare();
  
  TMastrini_application() {}
  virtual ~TMastrini_application() {}
};

inline TMastrini_application& app() { return (TMastrini_application&)main_app(); }

int TMastrini_application::righe_rimaste_da_stampare()
{  
  int righe_rimaste = 0;
                  
  if (_nummast == 2)
  { 
    if (printer().rows_left() != 0)
    {
      if ( (_conta_mastrini % 2) != 0)
      { 
        if ( (printer().formlen() % 2) != 0)
          righe_rimaste = printer().rows_left() - (printer().formlen() / 2) + 1; //- 33;
        else
          righe_rimaste = printer().rows_left() - (printer().formlen() / 2); 
      }
      else
        righe_rimaste = printer().rows_left();
    }
    else
    {
      if ( (_conta_mastrini % 2) != 0)
        righe_rimaste = printer().formlen() / 2; //32;
      else 
      {
        if ( (printer().formlen() % 2) != 0)
          righe_rimaste = (printer().formlen() / 2) + 1; //33;
        else
          righe_rimaste = printer().formlen / 2;
      }
    }
  }
 
  return righe_rimaste;
} 

void TMastrini_application::process_link(int id, const char* txt)
{                                         
  TRectype mov(LF_MOV);
  mov.put(MOV_NUMREG, txt);
  mov.edit();

  /* Vecchio modo barbaro ed obsoleto
  const char* const app = "cg2 -0";  
  TToken_string ss(10);
  ss.add("1");
  ss.add(txt);

  TMessage fs(cmd2name(app), MSG_LN, ss);
  fs.send();             

  TExternal_app pn(app);
  pn.run();
  */
} 

// Visualizzo le commesse se necessario
bool TMastrini_application::show_cdc()
{
  const bool okp = has_module(CMAUT);   // Mostra campo "Stampa commesse"
  bool okg = okp;                       // Mostra campi del gruppo delle commesse
  if (okg)
  {   
    okg = _msk->get_int(F_ANNO) != 0;   // Controllo anno
    if (okg)
    {                                   // Controllo se conto normale
      const char ti = _msk->get(F_TIPOCF_INI)[0];
      const char tf = _msk->get(F_TIPOCF_FINE)[0];
      okg =  ti <= ' ' && tf <= ' ';
    }
  } 
  _msk->show(-7, okg);
  _msk->show(F_PRINTCDC, okp);
  return okg;
}

bool TMastrini_application::cdc_handler(TMask_field& f, KEY k)
{
  if (k == K_TAB)
  {
    TMask& m = f.mask();
    const bool on = !(m.field(F_DACDC).empty() && m.field(F_ACDC).empty());
    if (!on)
    {
      m.reset(F_DAFSC);
      m.reset(F_AFSC);
    }
    m.enable(F_DAFSC, on); 
    m.enable(F_AFSC, on);
  }
  return TRUE;
}

bool TMastrini_application::sottoc_handler_ini(TMask_field& f, KEY key)
{
  const TMask& m = f.mask();
  const short id  = f.dlg();  
                                  
  const int gruppo = m.get_int(F_GRUPPOINI);
  const int conto = m.get_int(F_CONTOINI_CONTO);

  const long sottoconto = m.get_long(id);
  
  if ( key == K_ENTER )
  {
    if (sottoconto != 0 && conto == 0) 
      return f.warning_box(TR("Manca il CONTO"));

    if (conto != 0 && gruppo == 0)
      return f.warning_box(TR("Manca il GRUPPO"));
  }

  if (key == K_TAB && m.is_running())
  {
    if (id == F_SOTTOCINI_CONTO && (gruppo != 0 || conto != 0 || sottoconto != 0L))
    {
      TString16 key;
			
			key.format("%d|%d|%ld", gruppo, conto, sottoconto);
			const TRectype & pconti = cache().get(LF_PCON, key);

      if (pconti.empty())
        return f.warning_box(TR("Sottoconto inesistente"));
			
			const TString & ds = pconti.get(PCN_DESCR);
      
      f.mask().set(F_DESCRINI_CONTO,   ds);
      f.mask().set(F_DESCRINI_CLIENTE, ds);
      f.mask().set(F_DESCRINI_FORN,    ds);              
      
    }
    else
      if (id == F_SOTTOCINI_CLIENTE || id == F_SOTTOCINI_FORN) 
      {
        char tipo = id == F_SOTTOCINI_CLIENTE ? 'C' : 'F';
        if (sottoconto != 0)
        {
		      TString16 key;
					key.format("%c|%ld", tipo, sottoconto);
					const TRectype & clifo = cache().get(LF_CLIFO, key);
					if (clifo.empty())
            return f.warning_box(TR("Anagrafica inesistente"));
          const TString & rs = clifo.get(CLI_RAGSOC);
        
          f.mask().set(F_DESCRINI_CLIENTE, rs);
          f.mask().set(F_DESCRINI_FORN, rs);
        
        }
      }
  }

  return TRUE;
}

bool TMastrini_application::sottoc_handler_fine(TMask_field& f, KEY key)
{
  const TMask& m = f.mask();
  const short id  = f.dlg();                    
  TString    ds;
  TString80  rs;                                      
  
  const int gruppo = m.get_int(F_GRUPPOFINE);
  const int conto = m.get_int(F_CONTOFINE_CONTO);

  const long sottoconto = m.get_long(id);          

  if ( key == K_ENTER )
  {
    if (sottoconto != 0 && conto == 0) 
      return f.warning_box(TR("Manca il CONTO"));

    if (conto != 0 && gruppo == 0)
      return f.warning_box(TR("Manca il GRUPPO"));
      
    if (!app().check_ordine(f,key))
      return FALSE;  
  }    

  if ( key == K_TAB && m.is_running())
  {
    if (id == F_SOTTOCFINE_CONTO && (gruppo != 0 || conto != 0 || sottoconto != 0L))
    {
      TString16 key;

			key.format("%d|%d|%ld", gruppo, conto, sottoconto);
			
			const TRectype & pconti = cache().get(LF_PCON, key);

      if (pconti.empty())
        return f.warning_box(TR("Sottoconto inesistente"));
      const TString & ds = pconti.get(PCN_DESCR);
        
      f.mask().set(F_DESCRFINE_CONTO,   ds);
      f.mask().set(F_DESCRFINE_CLIENTE, ds);
      f.mask().set(F_DESCRFINE_FORN,    ds);
      
    }
    else
      if (id == F_SOTTOCFINE_CLIENTE || id == F_SOTTOCFINE_FORN) 
      {
        char tipo = id == F_SOTTOCFINE_CLIENTE ? 'C' : 'F';
        if (sottoconto != 0)
        {
		      TString16 key;

					key.format("%c|%ld", tipo, sottoconto);
					
					const TRectype & clifo = cache().get(LF_CLIFO, key);
					
					if (clifo.empty())
            return f.warning_box(TR("Anagrafica inesistente"));
          
					const TString & rs = clifo.get(CLI_RAGSOC);
          
					f.mask().set(F_DESCRFINE_CLIENTE, rs);
          f.mask().set(F_DESCRFINE_FORN,    rs);
        
        }
      }
  }
  return TRUE;
}

bool TMastrini_application::gruppo_hnd (TMask_field& f, KEY k)
{  
  if (k == K_ENTER)
  {
    int gruppof = f.mask().get_int(F_GRUPPOFINE);
    
    if (gruppof == 0)
      return TRUE;
      
    int gruppoi = f.mask().get_int(F_GRUPPOINI);
    
    if (gruppoi > gruppof)
      return f.error_box(TR("Il gruppo di partenza deve essere inferiore o uguale al gruppo di arrivo"));
  }   
  
  return TRUE;
}

bool TMastrini_application::tipocf_hnd (TMask_field& f, KEY k)
{             
  if (k == K_SPACE)
    app().show_cdc();
  return TRUE;
}

bool TMastrini_application::contoi_hnd (TMask_field& f, KEY k)
{ 
  if (k == K_TAB && f.focusdirty() && f.mask().is_running())
  { 
    TMask& m = f.mask();
    const short id        = f.dlg();  
    const int gruppo      = m.get_int(F_GRUPPOINI);
    const int conto       = m.get_int(id);

    
    if (gruppo != 0 && conto != 0)
    {    
      const char tipomsk = m.get(F_TIPOCF_INI)[0];

      TString key(20);
      
			key.format("%d|%d|", gruppo, conto);

      const TRectype & pconti = cache().get(LF_PCON, key);
      
			if (!pconti.empty())
      {                          
        char tipo = pconti.get_char(PCN_TMCF);
        if (tipomsk != tipo)
          return f.warning_box(TR("Conto inesistente"));
			}
          
      const TString & ds = pconti.get(PCN_DESCR);
      
			m.set(F_DESCRINI_CLIENTE, ds);
      m.set(F_DESCRINI_FORN, ds);
      m.set(F_DESCRINI_CONTO, ds);  
          
    }
    else
    {
      m.set(F_DESCRINI_CLIENTE, "");
      m.set(F_DESCRINI_FORN, "");
      m.set(F_DESCRINI_CONTO, "");  
    }  
  }  
  
  return TRUE;
}

bool TMastrini_application::contof_hnd (TMask_field& f, KEY k)
{
  const short id  = f.dlg();  
  TMask& m = f.mask();
   
  if (k == K_ENTER)
  {
    int gruppof = m.get_int(F_GRUPPOFINE);
    
    if (gruppof == 0)
      return TRUE;
      
    char tipo = m.get(F_TIPOCF_INI)[0];

    int gruppoi = m.get_int(F_GRUPPOINI);
    
    if (gruppoi < gruppof)
      return TRUE;
      
    int contof = m.get_int(id);
    int contoi = m.get_int(F_CONTOINI_CONTO); 
    
    if (contoi > contof)
      return f.error_box(TR("Il conto di partenza deve essere inferiore o uguale al conto di arrivo"));
  }

  if (k == K_TAB && f.focusdirty() && f.mask().is_running())
  {  
    TString ds;                       
    int gruppo = m.get_int(F_GRUPPOFINE);
    int conto  = m.get_int(id);
    
    if (gruppo != 0 && conto != 0 && m.field(F_DESCRFINE_CONTO).empty())
    {    
      char tipomsk = f.mask().get(F_TIPOCF_FINE)[0];        
      
      TString16 key;
			key.format("%d|%d|", gruppo, conto);

      const TRectype & pconti = cache().get(LF_PCON, key);

      if (pconti.empty())
        return f.warning_box(TR("Sottoconto inesistente"));
      char tipo = pconti.get_char(PCN_TMCF);
      if (tipomsk != tipo)
        return f.warning_box(TR("Conto inesistente"));

          
      const TString & ds = pconti.get(PCN_DESCR);
            
      m.set(F_DESCRFINE_CLIENTE, ds);
      m.set(F_DESCRFINE_FORN, ds);
      m.set(F_DESCRFINE_CONTO, ds);  
          
    }
    else
    {
      f.mask().set(F_DESCRFINE_CLIENTE, "");
      f.mask().set(F_DESCRFINE_FORN, "");
      f.mask().set(F_DESCRFINE_CONTO, "");  
    }  
  }  
  
  return TRUE;
}

bool TMastrini_application::check_ordine(TMask_field& f, KEY k)
{
  const int gruppof = f.mask().get_int(F_GRUPPOFINE);
    
  if (gruppof == 0)
    return TRUE;
      
  const int gruppoi = f.mask().get_int(F_GRUPPOINI);
    
  if (gruppoi < gruppof)
    return TRUE;
    
  int contof = f.mask().get_int(F_CONTOFINE_CONTO);
  int contoi = f.mask().get_int(F_CONTOINI_CONTO);
    
  if (contoi < contof)
    return TRUE;
    
  long sottocf = f.mask().get_long(F_SOTTOCFINE_CONTO);
  long sottoci = f.mask().get_long(F_SOTTOCINI_CONTO);
        
  if (sottoci > sottocf)
    return f.error_box(TR("Il sottoconto di partenza deve essere inferiore o uguale al sottoconto di arrivo"));
  
  return TRUE;
}
                                       
bool TMastrini_application::memorizza_handler(TMask_field& f, KEY k)
{
  if (k == K_SPACE)
  {
    if (app().mask2sheet())
    {
      TMask& m = f.mask();
      m.reset(-9);
      m.set_focus_field(F_TIPOCF_INI);
    }
  }
  return TRUE;
}

bool TMastrini_application::scelte_notify(TSheet_field& s, int r, KEY k)
{
  bool ok = TRUE;
  if (k == K_INS)
    ok = FALSE;
  return ok;
}

int TMastrini_application::date2esc(const TDate& d)
{                   
  TEsercizi_contabili esc;
  return esc.date2esc(d);
}

//Questa funzione restituisce vero se il record su piano dei conti ha almeno un
//record figlio (e che soddisfa la condizione riguardante la data di registr.).
//Viene successivamente utilizzata per stampare l'intestazione (e i totali)
//oppure no

bool TMastrini_application::almeno_un_record()
{
  bool  trovato=FALSE;
 
  if (current_cursor()->is_first_match(LF_RMOV))
  {
    TLocalisamfile& rmov_file = current_cursor()->file(LF_RMOV);
    const TRecnotype record = rmov_file.recno();
  
    TRelation rel(LF_RMOV);
    rel.add(LF_MOV, "NUMREG==NUMREG");
    TRectype& rmov = rel.curr();
    TRectype& mov = rel.curr(LF_MOV);
    
    TString filter;
    if (_cdc.not_empty())
    {
      filter << '(' << RMV_CODCMS << "=='" << _cdc << "')";
      if (_fsc.not_empty())
        filter << "&&(" << RMV_FASCMS << "=='" << _fsc << "')";
    }
    rmov.zero();
    rmov.put(RMV_GRUPPO,     _gruppo);
    rmov.put(RMV_CONTO,      _conto);
    rmov.put(RMV_SOTTOCONTO, _sottoc);
    TCursor cur(&rel, filter, 2, &rmov, &rmov);
    const long items = cur.items();
    cur.freeze();
    for (cur = 0L; cur.pos() < items; ++cur)
    {       
      const int  annoes = rmov.get_int (RMV_ANNOES);
      const long numreg = rmov.get_long(RMV_NUMREG);

      const TRectype & mov = cache().get(LF_MOV, numreg);

      const TDate datacomp = (mov.get(MOV_DATACOMP));
      const TString16 provvis (mov.get(MOV_PROVVIS));

        
      TDate datareg;
      if (_annomsk == 0)
        datareg = rmov.get_date(RMV_DATAREG);
      else
        datareg = datacomp;

      if ( ((annoes==_annomsk) || (_annomsk==0)) && ((datareg>=_data_ini) && (datareg<=_data_fine)) && (_stampa_mov_prov || provvis.blank()))
      {
        trovato = TRUE;
        break;
      }
    }
    rmov_file.readat(record);
  }
  return trovato;
}

bool TMastrini_application::anno_hnd(TMask_field& f, KEY k)
{
  if (f.to_check(k, TRUE))
    app().show_cdc();
  return TRUE;  
}

bool TMastrini_application::data_inizio(TMask_field& f, KEY k)
{
  const TDate data = f.mask().get    (F_DATAINI);
  const int anno = f.mask().get_int(F_ANNO);
  app()._annomsk = anno;
  
  if (k == K_ENTER)
  {
    if (anno != 0)
    {
      app().data_fine_esercizio(anno);

      if (data.ok())
      {
        if (data < app()._data_inizioese || data > app()._data_finese)
        {
          f.error_box(TR("La data non appartiene all'esercizio indicato"));
              return FALSE;
        }
        else
          app()._data_ini = data;
      }    
    }
    else
    {
      if (!data.ok())
        return f.error_box(TR("La data deve essere obbligatoriamente indicata"));

      if (app().date2esc(data) == 0)
        return f.error_box(TR("La data indicata non appartiene ad alcun esercizio"));
      else
        app()._data_ini = data;
    }  
  }  
  return TRUE;
}

bool TMastrini_application::data_fine(TMask_field& f, KEY k)
{
  int   annoes;
  TDate data, data_ini;

  annoes   = f.mask().get_int(F_ANNO);
  data     = f.mask().get    (F_DATAFINE);
  data_ini = f.mask().get    (F_DATAINI);
  app()._annomsk = annoes;
  
  if (k == K_ENTER)
  {
    if (annoes != 0)
    {                  
      app().data_fine_esercizio(annoes);
      
      if (data.ok())
      {
        if (data < app()._data_inizioese || data > app()._data_finese)
        {
          f.error_box(TR("La data non appartiene all'esercizio indicato"));
          return FALSE;
        }
        else
          app()._data_fine = data;
      }
    }
    else
      {
        if (data == botime)
          return f.error_box(TR("La data deve essere obbligatoriamente indicata"));

        app()._anno_ghost = app().date2esc(data_ini); 
        
        if (app()._anno_ghost == 0)
          return f.error_box(TR("La data indicata non appartiene ad alcun esercizio"));
        app()._data_fine = data;
      }

    if (data < data_ini)
    {
      f.error_box(TR("La data finale non puo' essere inferiore alla data di partenza"));
      return FALSE;
    }
  } 
  return TRUE;
}

void TMastrini_application::fai_stampa132()
{ 
  if (_nummast == 1 || _nummast == 3)
    _rw = 1;
  else
    if (_nummast == 2)
    {  
      int riga;
              
      if ( (_conta_mastrini % 2) != 0 )
        riga = (printer().formlen() / 2);    //-1
      else
        riga = printer().formlen();          //-1;
        
      int app1    = printer().formlen();
      int app2    = printer().rows_left();
      int cur_row = (app1 - app2);
          
      if (cur_row == riga) 
      {
        //_rw += 2;
        _rw = crea_intestazione(_rw);
        _rw = stampa_progre_riporto(_rw);
        
        if (_item != 0)  
        {
          for (int i = _indice_array; i < _item; i++)
          {
            TString& data = (TString&)_riga[i];
    
            int g1 = data.find("g",1);
            int c1 = data.find("@",g1);
            int g2 = data.find("g",c1);
              
            TString fmt1 = "";
            TString fmt2 = "";
            TString str1,str2;
              
            if (g1 != -1)
            {
              fmt1 = data.sub(0,g1+1);
              fmt1 << "%s";
              str1 = data.sub(g1+1,c1);
            }  
            if (c1 != -1)
            {
              fmt2 = data.sub(c1,g2+1);
              fmt2 << "%s";
              str2 = data.sub(g2+1);
            }
              
            if (fmt1 != "")
              set_row (_rw,fmt1,(const char*) str1);
            if (fmt2 != "")
              set_row (_rw,fmt2,(const char*) str2);
              
            _rw++;
          }  
        }  
      }
      else
        _rw = 1;
      
      if (_item != 0)  
        _riga.destroy();
    }
    
  set_row (_rw,"@0g#t",  &_dataregs);
  if (_stampanum == 1)
    set_row (_rw,"@11g$[b]#7ld$[n]", &_numreg);
  else
    if (_stampanum == 2)
      set_row (_rw,"@11g#7ld", &_numgio);
    
  set_row (_rw,"@19g#t", &_datadocs);
  set_row (_rw,"@30g#7t", &_numdoc);
  set_row (_rw,"@38g#3t", &_codcaus);

  set_row (_rw,"@117g#t #t #t", &_g_contr, &_c_contr, &_s_contr);
}

void TMastrini_application::fai_stampa198()
{            
  if (_nummast == 1 || _nummast == 3)
    _rw = 1;
  else
    if (_nummast == 2)
    {            
      int riga;
              
      if ( (_conta_mastrini % 2) != 0 )
        riga = (printer().formlen() / 2);    //-1
      else
        riga = printer().formlen();          //-1;

      int app1    = printer().formlen();
      int app2    = printer().rows_left();
      int cur_row = (app1 - app2);
          
      if (cur_row == riga) 
      {
        //_rw += 2;
        _rw = crea_intestazione(_rw);
        _rw = stampa_progre_riporto(_rw);
        
        if (_item != 0)
        {
          for (int i = _indice_array; i < _item; i++)
          {
            TString& data = (TString&)_riga[i];
    
            int g1 = data.find("g",1);
            int c1 = data.find("@",g1);
            int g2 = data.find("g",c1);
              
            TString fmt1 = "";
            TString fmt2 = "";
            TString str1,str2;
              
            if (g1 != -1)
            {
              fmt1 = data.sub(0,g1+1);
              fmt1 << "%s";
              str1 = data.sub(g1+1,c1);
            }  
            if (c1 != -1)
            {
              fmt2 = data.sub(c1,g2+1);
              fmt2 << "%s";
              str2 = data.sub(g2+1);
            }
              
            if (fmt1 != "")
              set_row (_rw,fmt1,(const char*) str1);
            if (fmt2 != "")
              set_row (_rw,fmt2,(const char*) str2);
              
            _rw++;
          }
        }
      }
      else
        _rw = 1;
         
      if (_item != 0)   
        _riga.destroy();  
    }

  set_row (_rw,"@0g#t", &_dataregs);
  if (_stampanum == 1)            
  {
    set_row (_rw,"@11g$[b]#7ld$[n]", &_numreg);
    set_row (_rw,"@18g/#3d", &_numrig);
  }
  else if (_stampanum == 2)
     set_row (_rw,"@11g#7ld", &_numgio);
     
  set_row (_rw,"@23g#t", &_datadocs);
  set_row (_rw,"@34g#7t", &_numdoc);
  set_row (_rw,"@42g#3t", &_codcaus);

// Stampa saldo movimenti / Descrizione contropartita
  const TRectype& rmov = current_cursor()->curr(LF_RMOV);
  _gruppocontr = rmov.get_int(RMV_GRUPPOC);     
  _contocontr = rmov.get_int(RMV_CONTOC);
  _sottocontocontr = rmov.get_long(RMV_SOTTOCONTOC);  
  _g_contr = rmov.get(RMV_GRUPPOC);
  _c_contr = rmov.get(RMV_CONTOC);
  _s_contr = rmov.get(RMV_SOTTOCONTOC);
  
  if (_stampa_saldo_des == 3)
  {      
    if (_sottocontocontr > 0)
    { 
      conto(_gruppocontr,_contocontr,FALSE);
      TBill tc (_gruppocontr,_contocontr,_sottocontocontr,_tipo_contr);
      _descrcontr.cut(0);
      _descrcontr << _g_contr << ' ' << _c_contr << ' ' << _s_contr << ' ' << tc.descrizione();
      _descrcontr.cut(47);
      set_row (_rw,"@135g%-48s", (const char*)_descrcontr);
    }
    else
    {
      _descrcontr.cut(0);
    }
  }
  else
  {
    set_row (_rw,"@151g#t", &_saldo_movimenti_str);
    set_row (_rw,"@168g#t #t #t", &_g_contr, &_c_contr, &_s_contr);
  }
}

void TMastrini_application::stampa_totali_commessa()
{
  if (_cdc.not_empty())
  {
    {
      _saldo_commessa = _totale_commessa_dare - _totale_commessa_avere;
      
      set_row (_rw,"@32g@b%s", TR("PROGRESSIVI COMMESSA"));
      
      if (_numcarat == 1)
      {
        set_row (_rw,"@66g%r", &_saldo_commessa);
        set_row (_rw,"@83g%r", &_totale_commessa_dare);   
        set_row (_rw,"@100g%r", &_totale_commessa_avere);
      }
      else
      {
        set_row (_rw,"@100g%r", &_totale_commessa_dare);
        set_row (_rw,"@117g%r", &_totale_commessa_avere); 
        if (_stampa_saldo_des < 3)
          set_row (_rw,"@135g%r", &_saldo_commessa);
      }
    }
  }
}

void TMastrini_application::stampa_totali132()
{
  if (_nummast == 1 || _nummast == 3)
    _rw = 2;
      
  const TString sep(132, '_');                   //Stampa 132 - (sep(132))      
  set_row(_rw++,"@0g%s", (const char*)sep);

  _totprogre_dare=_progredare+_totale_periodo_dare;
  _totprogre_avere=_progreavere+_totale_periodo_avere;
  _saldo_periodo = _totale_periodo_dare - _totale_periodo_avere;
  _saldo_progre = _totprogre_dare - _totprogre_avere;
  _saldo_progre_al = _totprogre_dare_al - _totprogre_avere_al;
  set_row (_rw,"@32g%s", TR("TOTALI PERIODO"));
  set_row (_rw,"@66g%r", &_saldo_periodo);
  set_row (_rw,"@83g%r", &_totale_periodo_dare);   
  set_row (_rw++,"@100g%r", &_totale_periodo_avere);
  
  set_row (_rw,"@32g%s", TR("TOTALI PROGRESSIVI"));
  set_row (_rw,"@66g%r", &_saldo_progre);
  set_row (_rw,"@83g%r", &_totprogre_dare);
  set_row (_rw++,"@100g%r", &_totprogre_avere);
  
  if (_stampaprogre)                         //Progressivi attuali
  {                                            
    set_row (_rw,"@32g%s %s", TR("TOTALI PROGRESSIVI AL"), _ultima_data_reg.string());
    set_row (_rw,"@66g%r", &_saldo_progre_al);
    set_row (_rw,"@83g%r", &_totprogre_dare_al);
    set_row (_rw,"@100g%r", &_totprogre_avere_al);
  }                        

  stampa_totali_commessa();
  
  _devi_stampare_footer = FALSE;
}

const char* TMastrini_application::real2str(const real& r) const
{
	TString & str = get_tmp_string(30);
  real2currency(str, r);
  return str;
}

void TMastrini_application::carica_array_totali132()
{
  TString sep(132);
  TToken_string r(255); 
  
  if (_nummast == 2)
    _rw = 1;

  _totprogre_dare=_progredare+_totale_periodo_dare;
  _totprogre_avere=_progreavere+_totale_periodo_avere;
  _saldo_periodo = _totale_periodo_dare - _totale_periodo_avere;
  _saldo_progre = _totprogre_dare - _totprogre_avere;
  _saldo_progre_al = _totprogre_dare_al - _totprogre_avere_al;

  sep.fill(' ');
  r.add("@0g%s");
  r.add(sep);  
  _lista.add(r);  
  r = "";
  
  sep.fill('_');                            //Stampa 132 - (sep(132))      
  r.add("@0g%s");
  r.add(sep);
  _lista.add(r);
  r = "";

  r.add("@32g%s@66g%s@83g%s@100g%s");
  r.add(TR("TOTALI PERIODO"));
  r.add(real2str(_saldo_periodo));     
  r.add(real2str(_totale_periodo_dare));
  r.add(real2str(_totale_periodo_avere));
  _lista.add(r);  
  r = "";

  r.add("@32g%s@66g%s@83g%s@100g%s");
  r.add(TR("TOTALI PROGRESSIVI"));
  r.add(real2str(_saldo_progre));       
  r.add(real2str(_totprogre_dare));
  r.add(real2str(_totprogre_avere));
  _lista.add(r);
  r = "";
  
  if (_stampaprogre)                         //Progressivi attuali
  {
    r.add("@32g%s@55g%s@66g%s@83g%s@100g%s");
    r.add(TR("TOTALI PROGRESSIVI AL"));
    r.add(_ultima_data_reg.string());
    r.add(real2str(_saldo_progre_al));
    r.add(real2str(_totprogre_dare_al));
    r.add(real2str(_totprogre_avere_al));
    _lista.add(r);
    r = "";
  } 
  
  if (_stampatotiva)
  {         
    real totale;
    
    sep.fill(' ');
    r.add("@0g%s");
    r.add(sep);  
    _lista.add(r);  
    r = "";

    TString fmt ("@0g%s");
    TString fmt1(format("@%dg", _ddociva_len));
    fmt << fmt1 << "%15s";

    for (int j = 0; j < _b.items(); j++)
    {
      TDociva& riga = (TDociva&)_b[j];
      r.add(fmt);
      r.add(riga._descrdoc);   
      totale = riga._totdociva;
      r.add(real2str(totale));
      _lista.add(r);
      r = "";
    }

    _b.destroy();
  }
  
  _indice_lista = 0;
}

void TMastrini_application::stampa_totali132_II()
{                              
  int riga,cur_row,diff;
  int lim = 0;
  
  _item_lista = _lista.items();
  
  if ( (_conta_mastrini % 2) != 0 )
  {
    riga    = (printer().formlen() / 2);    //- 1;
    cur_row = printer().formlen() - printer().rows_left();
    diff    = riga - cur_row;
  }
  else
  {
    riga    = printer().formlen();          //- 1;
    cur_row = printer().formlen() - printer().rows_left();
    diff    = riga - cur_row;
  }

  if (_indice_lista == 0 && diff != 0)
  {
    if (_item_lista > diff)
      lim = diff;
    else
      lim = _item_lista;
  }
  else  
  {
    lim = _item_lista;
    _rw = 1;
    _rw = crea_intestazione(_rw);
    _rw = stampa_progre_riporto(_rw);          
    if ( (_conta_mastrini % 2) != 0 )
    {
      riga    = (printer().formlen() / 2);    //- 1;
      cur_row = _rw;
      diff    = riga - cur_row;
    }
    else
    {
      riga    = printer().formlen();          //- 1;
      cur_row = _rw + (printer().formlen() / 2); //32;
      diff    = riga - cur_row;
    }
  }
            
  for (int i = _indice_lista; i < lim; i++)
  {
    TToken_string& data = (TToken_string&)_lista[i];
  
    TString fmt  (data.get(0));
    TString arg1 (data.get(1));
    TString arg2 (data.get(2));
    TString arg3 (data.get(3));
    TString arg4 (data.get(4));
    
    set_row(_rw++,fmt, (const char*) arg1, (const char*) arg2, (const char*) arg3, (const char*) arg4);         
    
    _indice_lista++;
  }                  
  
  if (_item_lista <= diff)
    _lista.destroy();
    
  _devi_stampare_footer = FALSE;  
}

void TMastrini_application::stampa_totali198()
{
  if (_nummast == 1 || _nummast == 3)
    _rw = 1;

  const TString sep(198, '-'); //Stampa 198 - (sep(198))      

  set_row(_rw,"@0g%s", (const char*)sep);

  _totprogre_dare=_progredare+_totale_periodo_dare;
  _totprogre_avere=_progreavere+_totale_periodo_avere;

  set_row (++_rw,"@32g%s@100g%r", TR("TOTALI PERIODO"), &_totale_periodo_dare);
  set_row (_rw,"@117g%r", &_totale_periodo_avere);
  
  set_row (++_rw,"@32g%s@100g%r", TR("TOTALI PROGRESSIVI"), &_totprogre_dare);
  set_row (_rw,"@117g%r", &_totprogre_avere);
  
  // il saldo totale movimenti non viene stampato se stampo le descrizioni delle contropartite
  if (_stampa_saldo_des < 3)
  {
    set_row (_rw,"@135g%r", &_saldo_progressivi);
    set_row (_rw,"@151g%r", &_saldo_movimenti);
  }
  
  if (_stampaprogre)                          //Progressivi attuali
  {
    _saldo_progre_al = _totprogre_dare_al - _totprogre_avere_al;
    set_row(++_rw,"@32g%s@55g%s", TR("TOTALI PROGRESSIVI AL"), _ultima_data_reg.string());
    set_row (_rw,"@100g%r", &_totprogre_dare_al);
    set_row (_rw,"@117g%r", &_totprogre_avere_al); 
    if (_stampa_saldo_des < 3)
      set_row (_rw,"@135g%r", &_saldo_progre_al);
  }                             

  stampa_totali_commessa();
  
  _devi_stampare_footer = FALSE;
}

void TMastrini_application::carica_array_totali198()
{
  TString sep(198);
  TToken_string r(255); 
  
  if (_nummast == 2)
    _rw = 1;
            
  sep.fill(' ');                            //Stampa 132 - (sep(132))      
  r.add("@0g%s");
  r.add(sep);
  _lista.add(r);
  r = "";

  sep.fill('_');                            //Stampa 132 - (sep(132))      
  r.add("@0g%s");
  r.add(sep);
  _lista.add(r);
  r = "";

  _totprogre_dare=_progredare+_totale_periodo_dare;
  _totprogre_avere=_progreavere+_totale_periodo_avere;

  if (_stampa_saldo_des == 3)
    r.add("@32g%s@100g%s@117g%s");
  else
    r.add("@32g%s@100g%s@117g%s@151g%s");
  r.add(TR("TOTALI PERIODO"));
  r.add(real2str(_totale_periodo_dare));
  r.add(real2str(_totale_periodo_avere));
  r.add(real2str(_saldo_movimenti));
  _lista.add(r);
  r = "";

  if (_stampa_saldo_des == 3)
    r.add("@32g%s@100g%s@117g%s");
  else    
    r.add("@32g%s@100g%s@117g%s@135g%s");
  r.add(TR("TOTALI PROGRESSIVI"));
  r.add(real2str(_totprogre_dare));
  r.add(real2str(_totprogre_avere));
  r.add(real2str(_saldo_progressivi));     
  _lista.add(r);
  r = "";
  
  if (_stampaprogre)                          //Progressivi attuali
  {
    _saldo_progre_al = _totprogre_dare_al - _totprogre_avere_al;
    r.add("@32g%s@55g%s@100g%s@117g%s@135g%s");
    r.add(TR("TOTALI PROGRESSIVI AL"));
    r.add(_ultima_data_reg.string());
    r.add(real2str(_totprogre_dare_al));
    r.add(real2str(_totprogre_avere_al));
    r.add(real2str(_saldo_progre_al));    
    _lista.add(r);
    r = "";
  }                 

  if (_stampatotiva)
  { 
    real totale;
    
    sep.fill(' ');
    r.add("@0g%s");
    r.add(sep);  
    _lista.add(r);  
    r = "";

    TString16 fmt;
    fmt << "@0g%s@" << _ddociva_len << "g%15s";
    
    for (int j = 0; j < _b.items(); j++)
    {
      TDociva& riga = (TDociva&)_b[j];
      r.add(fmt);
      r.add(riga._descrdoc);   
      totale = riga._totdociva;
      r.add(real2str(totale));
      _lista.add(r);
      r = "";
    }

    _b.destroy();
  }
  
  _indice_lista = 0;
}

void TMastrini_application::stampa_totali198_II()
{
  int riga,cur_row,diff;
  int lim = 0;
  
  _item_lista = _lista.items();
  
  if ( (_conta_mastrini % 2) != 0 )
  {
    riga    = (printer().formlen() / 2);    //- 1;
    cur_row = printer().formlen() - printer().rows_left();
    diff    = riga - cur_row;
  }
  else
  {
    riga    = printer().formlen();          //- 1;
    cur_row = printer().formlen() - printer().rows_left();
    diff    = riga - cur_row;
  }

  if (_indice_lista == 0 && diff != 0)
  {
    if (_item_lista > diff)
      lim = diff;
    else
      lim = _item_lista;
  }
  else  
  {
    lim = _item_lista;
    _rw = 1;
    _rw = crea_intestazione(_rw);
    _rw = stampa_progre_riporto(_rw);          
    if ( (_conta_mastrini % 2) != 0 )
    {
      riga    = (printer().formlen() / 2);    //- 1;
      cur_row = _rw;
      diff    = riga - cur_row;
    }
    else
    {
      riga    = printer().formlen();          //- 1;
      cur_row = _rw + (printer().formlen() / 2);  //32;
      diff    = riga - cur_row;
    }
  }
            
  for (int i = _indice_lista; i < lim; i++)
  {
    TToken_string& data = (TToken_string&)_lista[i];
  
    TString fmt  (data.get(0));
    TString arg1 (data.get(1));
    TString arg2 (data.get(2));
    TString arg3 (data.get(3));
    TString arg4 (data.get(4));
    TString arg5 (data.get(5));
    
    set_row(_rw++,fmt, (const char*)arg1, (const char*)arg2, (const char*)arg3, 
                       (const char*)arg4, (const char*)arg5);         
    
    _indice_lista++;
  }                  
  
  if (_item_lista <= diff)
    _lista.destroy();           

  _devi_stampare_footer = FALSE;
}

void TMastrini_application::setta_riga (int r, const TString& riga)
{                         
  TString* p = (TString*)_riga.objptr(r);
  if (p == NULL)
    _riga.add(riga);
  else  
    *p << riga;
}

bool TMastrini_application::preprocess_page(int file, int counter)
{ 
  if (counter)
    return TRUE;
  
  TLocalisamfile & rmov = current_cursor()->file(LF_RMOV);
  long    rec;
  TDate   datasucc;
  TString datasuccstring,dataregrmovstring;
  int     gruppof,contof;
  long    sottocf;
  TString provvis = "";
  int     annoes;

  switch (file)
  {
    case LF_SALDI:

// Usati in crea_intestazione()
      
      _devi_stampare_footer = TRUE;
       
      if (_nummast == 3 || _nummast == 2)
      {
        _rw = 0;
        _rw++;
      }
       
      _gruppo = atoi(current_cursor()->curr(LF_SALDI).get(SLD_GRUPPO));
      _conto  = atoi(current_cursor()->curr(LF_SALDI).get(SLD_CONTO));
      _sottoc = atol(current_cursor()->curr(LF_SALDI).get(SLD_SOTTOCONTO)); 
      
      _cambia_mastrino = TRUE;
      
      annoes  = atoi(current_cursor()->curr(LF_SALDI).get(SLD_ANNOES));  
      conto(_gruppo,_conto,TRUE);

      if (annoes != _anno_corrente && annoes != _anno_precedente)
        return FALSE;

      if (_g_prec == _gruppo && _c_prec == _conto && _s_prec == _sottoc)
        return FALSE;

      _g_prec = _gruppo;
      _c_prec = _conto;
      _s_prec = _sottoc;

      _saldo_periodo = ZERO;
      _totale_periodo_dare = ZERO;
      _totale_periodo_avere = ZERO;
      _saldo_progre = ZERO;
      _totprogre_dare = ZERO;
      _totprogre_avere = ZERO;
      _saldo_progre_al = ZERO;
      _totprogre_dare_al = ZERO;
      _totprogre_avere_al = ZERO;
      _progredare = ZERO;
      _progreavere = ZERO;
      _totale_prima_dare = ZERO;
      _totale_prima_avere = ZERO;
      _saldo_movimenti = ZERO;
      _saldo_progressivi = ZERO;
      _saldo_progre_prec = ZERO;
      if (_selez_mastrini == 2)
      {
        calcola_progressivi(TRUE);
        _totale_saldo = _saldo_progre_prec;
      }
                      
      if ((_selez_mastrini == 1) || (_selez_mastrini == 2))
      {  
        if ((_selez_mastrini == 1 && almeno_un_record()) ||
            (_selez_mastrini == 2 && _totale_saldo != ZERO))
        {                                
          _puoi_stampare = TRUE;  
          
          if (_nummast == 3 || _nummast == 2)  
          {                           
            int cur_row = printer().formlen() - printer().rows_left();
            int diff = printer().formlen() - cur_row;
            if (diff <= 13 && diff != 0)
              printer().formfeed();
              
            _rw = crea_intestazione(_rw);
            calcola_progressivi();
            _saldo_progressivi += _saldo_progre_prec;          
            _rw = stampa_progre_riporto(_rw);
          }
        }  
        else
        {
          _puoi_stampare = FALSE; 
          return FALSE;
        }                      
      }
      else
        if (_selez_mastrini == 3) 
        {  
          calcola_progressivi();
          if (_progredare == ZERO && _progreavere == ZERO && !almeno_un_record())  
          { 
            _puoi_stampare = FALSE;
            return FALSE;
          }
          else               
          {                                
            _puoi_stampare = TRUE; 
            
            if (_nummast == 3 || _nummast == 2)
            {                                                        
              int cur_row = printer().formlen() - printer().rows_left();            
              int diff = printer().formlen() - cur_row;
              if (diff <= 13 && diff != 0)
                printer().formfeed();
                
              _rw = crea_intestazione(_rw);
              _saldo_progressivi += _saldo_progre_prec;
              _rw = stampa_progre_riporto(_rw);
            }
          }
        }    
      break;

    case LF_RMOV:
    { 
      TLocalisamfile& rmov = current_cursor()->file(LF_RMOV);
      if (_cdc.not_empty() && rmov.get(RMV_CODCMS) != _cdc)
        return FALSE;
      if (_fsc.not_empty() && rmov.get(RMV_FASCMS) != _fsc)
        return FALSE;  
    
     //Il flag _gia_stampata_intestazione serve nella stampa in continuo, xche'
     //sono costretto a richiamare l'intestazione sia nella preprocess_page (per
     //i mastrini con intestazione a meta' pagina), sia nella preprocess_header
     //per i mastrini che si trovano a cavallo fra una pagina e quella successiva.
     //In quest'ultimo caso infatti quando vado a pagina nuova devo stampare l'intestazione
     //ma senza il flag rischio di stamparla due volte.
     if (_nummast == 3)
        _gia_stampata_intestazione = FALSE;  
      
      if (_nummast == 1 || _nummast == 3)
        _rw = 1;
        
      // Ricerca la contropartita di quel movimento
      
      _numreg = rmov.get_long(RMV_NUMREG);
      _numrig = rmov.get_int(RMV_NUMRIG);

      _gruppocontr = rmov.get_int(RMV_GRUPPOC);     
      _contocontr = rmov.get_int(RMV_CONTOC);
      _sottocontocontr = rmov.get_long(RMV_SOTTOCONTOC);  
      _g_contr = rmov.get(RMV_GRUPPOC);
      _c_contr = rmov.get(RMV_CONTOC);
      _s_contr = rmov.get(RMV_SOTTOCONTOC);
      
    // Stampa solo quelli che hanno anno esercizio uguale a quello specificato
    // nella maschera. Se non viene specificato li stampa tutti

      _importo = rmov.get_real(RMV_IMPORTO);
      _importo_str = real2str(_importo);
      const TRectype & mov = cache().get(LF_MOV, _numreg);

      _annoes  = mov.get_int(MOV_ANNOES);
      _regiva  = mov.get(MOV_REG);   
      _annoiva = mov.get_int(MOV_ANNOIVA);


      // Controlla se saldo e' diverso da 0

      if (((_annoes == _annomsk) || (_annomsk == 0)) && (_totale_saldo != 0.0))
      { 
        _sezione = rmov.get(RMV_SEZIONE);     

        if (_annomsk == 0)
        {
          _datareg = mov.get(MOV_DATAREG);

          _datareg_stampa = _datareg;
        }
        else
          if (_annomsk != 0)
          {
            _datareg = mov.get(MOV_DATACOMP);
            _datareg_stampa = mov.get(MOV_DATAREG);
          }


        provvis  =  mov.get(MOV_PROVVIS);

  
        _dataregs = _datareg_stampa.string();

        if ((_stampa_mov_prov)||((!_stampa_mov_prov)&&(provvis.trim().empty())))
        {
          if ((_datareg >= _data_ini) && (_datareg <= _data_fine))
          {   
            // Determino l' anno di competenza dell' operazione in esame          
            int anno = date2esc(_datareg_stampa);
            if (anno != _annoes)
              if (_numcarat == 1)
                set_row (_rw, "@132g*");
              else
                set_row (_rw, "@197g*");

            if (_stampa_mov_prov  && provvis.trim().not_empty()) 
              if (_numcarat == 1)
                set_row(_rw, "@130gP"); 
              else
                set_row(_rw, "@195gP");
                
            _codcaus = mov.get(MOV_CODCAUS);
            _tipodoc = mov.get(MOV_TIPODOC);

            if (_stampatotiva && (_tmcf == 'C' || _tmcf == 'F'))
            {  
              if (_tipodoc != "")
              {
                documenti_iva();
                _b.add_riga(_descrdociva,_importo, _natdoc);     
                if (_descrdociva.len() > _ddociva_len)
                  _ddociva_len = _descrdociva.len();
              }
            }
            _datadoc = (mov.get(MOV_DATADOC));

            _datadocs = _datadoc.string();
            _numdoc = mov.get(MOV_NUMDOC);

            descrizione_causale();
            _descrizionemov = mov.get(MOV_DESCR);
            _numgio = atol(mov.get(MOV_NUMGIO));


            _descrizione = rmov.get(RMV_DESCR);
            
            _d18->cut(0); _d22->cut(0); _d30->cut(0);
            
            if (_nummast == 1 || _nummast == 3)
            {
              if (_numcarat == 1)     // Stampa 132 caratteri
              {
                if (_descrizione != "")
                {
                  *_d22 = (const char*) _descrizione;
                  if (_descrizionemov != "")
                  {                                    
                    *_d18 = (const char*) _descrizionemov;
                    set_row(_rw, "@42g#a", _d18);
                    set_row(_rw, "@61g#a", _d22);
                  }
                  else if (_descrizionemov == "")
                  { 
                    *_d18 = (const char*) _descrcaus;
                    set_row(_rw, "@42g#a", _d18);
                    set_row(_rw, "@61g#a", _d22);
                  }
                }
                else if (_descrizione == "")
                       if (_descrizionemov != "")
                       {
                         *_d22 = (const char*) _descrizionemov;
                         *_d18 = (const char*) _descrcaus;
                         set_row (_rw,"@42g#a", _d18); 
                         set_row (_rw,"@61g#a", _d22);
                       }
                       else
                         if (_descrizionemov == "")
                         {
                           conto(_gruppocontr,_contocontr,FALSE);
                           TConto tc (_gruppocontr,_contocontr,_sottocontocontr,_tipo_contr);
                           _descrcontr = tc.descrizione();    
                           *_d18 = (const char*) _descrcaus;
                           set_row (_rw,"@42g#a", _d18); 
                           if (_descrcontr != "Sconosciuto")
                           {
                             *_d22 = (const char*) _descrcontr;
                             set_row (_rw,"@61g#a", _d22);
                           }
                         }  
              }
              else
                if (_numcarat == 2)     // Stampa 198 caratteri
                {
                  if (_descrizione != "")
                  {
                    *_d30 = (const char*) _descrizione;
                    if (_descrizionemov != "")
                    {                                    
                      *_d22 = (const char*) _descrizionemov;
                      set_row (_rw,"@46g#a", _d22);
                      set_row (_rw,"@70g#a", _d30);
                    }
                    else if (_descrizionemov == "")
                    { 
                      *_d22 = (const char*) _descrcaus;
                      set_row(_rw, "@46g#a", _d22);
                      set_row(_rw, "@70g#a", _d30);
                    }
                  }
                  else if (_descrizione == "") 
                         if (_descrizionemov.not_empty())
                         {
                           *_d30 = (const char*) _descrizionemov;
                           *_d22 = (const char*) _descrcaus;
                           set_row (_rw,"@46g#a", _d22); 
                           set_row (_rw,"@70g#a", _d30);
                         }
                         else
                         {
                           conto(_gruppocontr,_contocontr,FALSE);
                           TConto tc (_gruppocontr,_contocontr,_sottocontocontr,_tipo_contr);
                           _descrcontr = tc.descrizione();
                           *_d22 = (const char*) _descrcaus;
                           set_row (_rw,"@46g#a", _d22); 
                           if (_descrcontr != "Sconosciuto")
                           {
                             *_d30 = (const char*)_descrcontr;
                             set_row (_rw,"@70g#a", _d30);
                           }
                         }
                }
            }  //if (_nummast == 1 || _nummast == 3)
          
            if (_nummast == 2)
            {                       
              TString d18,d23,d30;
            
              if (_numcarat == 1)     // Stampa 132 caratteri
              {
                if (_descrizione != "")
                {
                  d23 = _descrizione;
                  if (_descrizionemov.not_empty())
                    d18 = _descrizionemov;
                  else
                    d18 = _descrcaus;
                }
                else if (_descrizione.empty())
                {
                  if (_descrizionemov.not_empty())
                  {
                    d23 = _descrizionemov;
                    d18 = _descrcaus;
                  }
                  else
                  {
                    conto(_gruppocontr,_contocontr,FALSE);
                    TConto tc (_gruppocontr,_contocontr,_sottocontocontr,_tipo_contr);
                    _descrcontr = tc.descrizione();    
                    d18 = _descrcaus;
                    if (_descrcontr != "Sconosciuto")
                      d23 = _descrcontr;
                  }  
                }        
                TParagraph_string d_18 (d18,18);
                int i = 0;  
                const char* str;
                while ( (str = d_18.get()) != NULL)
                { 
                  TString stringa;
                  stringa << "@42g" << str;
                  setta_riga(i,stringa);
                  i++;
                }
                
                TParagraph_string d_23 (d23,23);
                i = 0;
                while ( (str = d_23.get()) != NULL)
                {
                  TString stringa;
                  stringa << "@61g" << str;
                  setta_riga(i,stringa);
                  i++;
                }           
              }
              else
                if (_numcarat == 2)     // Stampa 198 caratteri
                {
                  if (_descrizione.not_empty())
                  {
                    d30 = _descrizione;
                    if (_descrizionemov != "")
                      d23 = _descrizionemov;
                    else if (_descrizionemov == "")
                      d23 = _descrcaus;
                  }
                  else
                  {
                     if (_descrizionemov.not_empty())
                     {
                       d30 = _descrizionemov;
                       d23 = _descrcaus;
                     }
                     else
                     {
                       conto(_gruppocontr,_contocontr,FALSE);
                       TConto tc (_gruppocontr,_contocontr,_sottocontocontr,_tipo_contr);
                       _descrcontr = tc.descrizione();
                       d23 = _descrcaus;
                       if (_descrcontr != "Sconosciuto")
                        d30 = _descrcontr;
                     }
                  }       
                  TParagraph_string d_23 (d23,23);
                  int i = 0;
                  const char* str;
                  while ( (str = d_23.get()) != NULL)
                  { 
                    TString stringa;
                    stringa << "@46g" << str;
                    setta_riga(i,stringa);
                    i++;
                  }
                
                  TParagraph_string d_30 (d30,30);
                  i = 0;
                  while ( (str = d_30.get()) != NULL)
                  {                     
                    TString stringa;
                    stringa << "@70g" << str;
                    setta_riga(i,stringa);
                    i++;
                  }
                }
             
              _item = _riga.items();
              int riga,cur_row,diff;
            
              if ( (_conta_mastrini % 2) != 0 )
              {   
                int app = 0;
                riga    = (printer().formlen() / 2);
                if (printer().rows_left() == 0)
                  app = printer().formlen() - _rw;
                else    
                  app = printer().rows_left();
                cur_row = printer().formlen() - app;  
                diff    = riga - cur_row;
              }
              else
              {
                riga    = printer().formlen();          
                cur_row = printer().formlen() - printer().rows_left();
                diff    = riga - cur_row;
              }
               
              bool stampa_riporti;
               
              int lim = 0;
              if (_item >= diff)  
              { 
                lim = diff - 1;
                stampa_riporti = TRUE;
              }
              else 
              {
                lim = _item;   
                stampa_riporti = FALSE;
              }
            
              _indice_array = 0;
            
              int k = _rw;
              
              for (int i = 0; i < lim; i++)
              {
                TString& data = (TString&)_riga[i];
              
                int g1 = data.find("g",1);
                int c1 = data.find("@",g1);
                int g2 = data.find("g",c1);
              
                TString fmt1 = "";
                TString fmt2 = "";
                TString str1,str2;
              
                if (g1 != -1)
                {
                  fmt1 = data.sub(0,g1+1);
                  fmt1 << "%s";
                  str1 = data.sub(g1+1,c1);
                }  
                if (c1 != -1)
                {
                  fmt2 = data.sub(c1,g2+1);
                  fmt2 << "%s";
                  str2 = data.sub(g2+1);
                }
              
                if (fmt1 != "")
                  set_row (k,fmt1,(const char*) str1);
                if (fmt2 != "")
                  set_row (k,fmt2,(const char*) str2);
              
                k++;
                _indice_array++;
              }
              if (stampa_riporti)
              { 
                _rw = k;        
                if (lim == 0)
                {
                  if (_numcarat == 1)
                  {  
                    TString app(132);
                    app.spaces(); 
                    set_row (_rw, "@0g%s", (const char*)app);
                  }
                  else
                  {  
                    TString app(198);
                    app.spaces(); 
                    set_row (_rw, "@0g%s", (const char*)app);
                  }
                }
                real dep_dare,dep_avere;
                if (_stampa_footer_si)
                {
                  _riporto_footer_dare  = _progredare  + _riporto_parziale_dare;
                  _riporto_footer_avere = _progreavere + _riporto_parziale_avere;
      
                  real imp_d,imp_a;
                  imp_d = _sezione == "D" ? _importo : ZERO;
                  imp_a = _sezione == "A" ? _importo : ZERO;   
                  if (lim != 0)                   
                  {
                    _riporto_footer_dare  += imp_d;
                    _riporto_footer_avere += imp_a;
                  }
                  dep_dare  = _riporto_footer_dare;
                  dep_avere = _riporto_footer_avere;
                  
                  _stampa_footer_si = FALSE;
                }                           
                else
                {
                  _riporto_footer_dare  += _riporto_parziale_dare;
                  _riporto_footer_avere += _riporto_parziale_avere;

                  real imp_d,imp_a;
                  imp_d = _sezione == "D" ? _importo : ZERO;
                  imp_a = _sezione == "A" ? _importo : ZERO;  
                  if (lim != 0)
                  {
                    _riporto_footer_dare  += imp_d;
                    _riporto_footer_avere += imp_a;
                  }
                  dep_dare  = _riporto_footer_dare;
                  dep_avere = _riporto_footer_avere;
                }
                
                if (_nummast != 3 || dep_dare != ZERO || dep_avere != ZERO)
                {  
                  TString dare  (real2str(dep_dare));
                  TString avere (real2str(dep_avere));
                  if (_numcarat == 1)                  
                  {
                    set_row (_rw,FR("@32gA RIPORTO@83g%s"), (const char*) dare);
                    set_row (_rw,"@100g%s", (const char*) avere);
                  }  
                  else
                    if (_numcarat == 2) 
                    {
                      set_row (_rw,FR("@32gA RIPORTO@100g%s"), (const char*) dare);
                      set_row (_rw,"@117g%s", (const char*) avere);
                    }        
                }                          
                if (lim == 0)
                {
                  rmov.prev();
                  _riga.destroy();   
                  _item = 0;        
                  return TRUE;  
                } 
                _rw--;
              }
              //_riga.destroy();
            } 
                            
            if (_print_cdc)
            {
              const TString& cms = rmov.get(RMV_CODCMS);
              if (cms.not_empty())
              {                                    
                TString riga_commessa;
                riga_commessa << "@0g@b" << cms;
                riga_commessa << "@21g" << cache().get("CMS", cms, "S0");
                const TString& fas = rmov.get(RMV_FASCMS);
                if (fas.not_empty())
                {
                  riga_commessa << "@72g" << fas;
                  riga_commessa << "@83g" << cache().get("FSC", fas, "S0");
                }    
                const int jump = max(_d18->items(), max(_d22->items(), _d30->items()));
                set_row (_rw+jump, riga_commessa);
              }
            }
  
            if (_sezione == "D")
            {
              _totale_periodo_dare += _importo;
              _riporto_parziale_dare += _importo;
              _totale_commessa_dare += _importo;
        

              if (_numcarat == 1)    // Stampa 132 caratteri
                set_row (_rw,"@83g%s", (const char*) _importo_str);
              else                   // Stampa 198 caratteri
              {
                _saldo_progressivi += _importo;
                _saldo_movimenti += _importo;
                set_row (_rw,"@100g%s", (const char*) _importo_str);
              }
            }
            else if (_sezione == "A")
                 {
                   _totale_periodo_avere += _importo;
                   _riporto_parziale_avere += _importo;
                   _totale_commessa_avere += _importo;
        

                   if (_numcarat == 1)    // Stampa 132 caratteri
                     set_row (_rw,"@100g%s", (const char*) _importo_str);
                   else                   // Stampa 198 caratteri 
                   {
                     _saldo_progressivi -= _importo;
                     _saldo_movimenti -= _importo;
                     set_row (_rw,"@117g%s", (const char*) _importo_str);
                   }
                 }
           
            const int righe_rimaste = printer().rows_left();
            _stampato = righe_rimaste >= 1;
            
            _saldo_progressivi_str=real2str(_saldo_progressivi);
            _saldo_movimenti_str=real2str(_saldo_movimenti);
            if (_numcarat == 2)
            {
               ricerca_regiva();
              _protiva = mov.get_long(MOV_PROTIVA);
              if (_protiva != 0)   
                set_row (_rw,"@191g%5d", _protiva);
          
              if (_tipo < 3)
                set_row (_rw,"@183g#t" , &_regiva);
              _dataregrmov = current_cursor()->curr(LF_RMOV).get_date(RMV_DATAREG);
              dataregrmovstring=_dataregrmov.string();

//Gestire la stampa di saldo_progressivi nella postprocess_page di RMOV

              if (_stampa_saldo_des < 3) // Stampa saldo (non descrizioni)
              {
                rec = rmov.recno();
                rmov.next();
                gruppof = rmov.get_int(RMV_GRUPPO);
                contof = rmov.get_int(RMV_CONTO);
                sottocf = rmov.get_int(RMV_SOTTOCONTO);
                datasucc = rmov.get_date(RMV_DATAREG);
                datasuccstring=datasucc.string();
                if (((gruppof!=_gruppo)||(contof!=_conto)||(sottocf!=_sottoc))||(rmov.eof()))
                  datasucc = ("");
                if (datasucc != _dataregrmov || _stampa_saldo_des == 2)
                {
                  if (_flag_del_cazzo)
                  {
                    calcola_progressivi();                             
                    _saldo_progressivi += _saldo_progre_prec;    
                    set_row (_rw,"@135g%r", &_saldo_progressivi);
                    _saldo_progressivi -= _saldo_progre_prec;          
                    _flag_del_cazzo = FALSE;
                  }  
                  else
                    set_row (_rw,"@135g%r", &_saldo_progressivi);
                }          
                rmov.readat(rec);
              }
            }
            else 
            {
               ricerca_regiva();
              _protiva = atol(mov.get(MOV_PROTIVA));
              if (_protiva != 0)   
                set_row (_rw,"@127g%5d", _protiva);
            }
            _rw = 1;
          
            return TRUE;
          }
          else
            return FALSE;         
        }
        else
          return FALSE;
      }
      else
        return FALSE;
    break; 
    }
    default:
      break;   
  }
  return TRUE;
}

void TMastrini_application::set_page(int file, int counter)
{
  switch (file)
  {
  case LF_SALDI:
    reset_print();
    break;

  case LF_RMOV:
    reset_print();
    if (_numcarat == 1)
      fai_stampa132();
    else
      fai_stampa198();
    break;
  default:
    break;
  }
}

print_action TMastrini_application::postprocess_page(int file, int counter)
{                   
  if (_nummast == 1 || _nummast == 3)
  {
    if (counter)
    { 
      if (_nummast == 1)      //Il salto pagina a rottura di mastrino viene
        printer().formfeed(); //fatto solo quando seleziono un mastrino per pagina
      
      reset_print();     // per evitare che stampi di nuovo il totale prec.  
      _stampa_progressivi_si  = TRUE;
      _stampa_footer_si       = TRUE;
      _riporto_dare           = ZERO;
      _riporto_avere          = ZERO;   
      _riporto_footer_dare    = ZERO;
      _riporto_footer_avere   = ZERO;
      _riporto_parziale_dare  = ZERO;
      _riporto_parziale_avere = ZERO;
      _ddociva_len            = 0;
      
      return NEXT_PAGE;
    }
  }
  else
    if (_nummast == 2)
    { 
      int item_lista = _lista.items();
        
      if (counter && item_lista == 0)
      { 
        reset_print();     // per evitare che stampi di nuovo il totale prec.  
        _stampa_progressivi_si  = TRUE;  
        _stampa_footer_si       = TRUE;
        _riporto_dare           = ZERO;
        _riporto_avere          = ZERO; 
        _riporto_footer_dare    = ZERO;
        _riporto_footer_avere   = ZERO;
        _riporto_parziale_dare  = ZERO;
        _riporto_parziale_avere = ZERO;
        _ddociva_len            = 0;
        
        return NEXT_PAGE;
      }
    }

  switch (file)
  {
  case LF_SALDI:
  { 
    if (_nummast == 1 || _nummast == 3)
    {
      if (_selez_mastrini == 3)
      {
        reset_print();
        if (_numcarat == 1)
          stampa_totali132();
        else if (_numcarat == 2)
          stampa_totali198();

        if (_stampatotiva)     
          stampa_totaliiva();
      }
      else if (_selez_mastrini == 2)
           {
             reset_print();
             if ((_totale_saldo != 0.0) && (_puoi_stampare))
             {
               if (_numcarat == 1)
                 stampa_totali132();
               else
                 stampa_totali198();
             }
             if (_stampatotiva)      
               stampa_totaliiva();
       }
       else if (_selez_mastrini == 1)
            {
              reset_print();
              if (_puoi_stampare)
              {
                if (_numcarat == 1)
                  stampa_totali132();
                else if (_numcarat == 2)
                  stampa_totali198();
              }

              if (_stampatotiva)     
                stampa_totaliiva();
            }
    }
    else
      if (_nummast == 2)             
      {                          
        if (!counter)                                                                                   
        { 
          if (_numcarat == 1)
            carica_array_totali132();
          else
            carica_array_totali198(); 
        }
        
        if (_selez_mastrini == 3)
        {
          reset_print();
          if (_numcarat == 1)
            stampa_totali132_II();
          else
            stampa_totali198_II();
        }
        else if (_selez_mastrini == 2)
             {
               reset_print();
               if ((_totale_saldo != 0.0) && (_puoi_stampare))
                 if (_numcarat == 1)
                   stampa_totali132_II();
                 else
                   stampa_totali198_II();
         }
         else if (_selez_mastrini == 1)
              {
                reset_print();
                if (_puoi_stampare)
                  if (_numcarat == 1)
                    stampa_totali132_II();
                  else
                    stampa_totali198_II();
              }
              
        int item_lista = _lista.items();   
        
        if (item_lista == 0)
        {   
          int righe_rimaste = righe_rimaste_da_stampare();
             
          righe_rimaste = righe_rimaste - _rw;  //_rw sono le righe dei totali gia' settate, mentre
                                               //righe rimaste conteneva le righe senza quelle dei totali gia' settate
          if (righe_rimaste > 0)
          {                                
            _rw++; //incremento la riga altrimenti copro l'ultimo totale settato con una riga bianca
            for (int i = 0; i < righe_rimaste; i++)
              set_row(_rw++,"@0g ");
          }
        }
      }

//    _stampa_progressivi_si = TRUE;
    return REPEAT_PAGE;
  }
  case LF_RMOV:  
    force_setpage();
    break;
  default:
    break;
  }
  return NEXT_PAGE;
}                                                 

print_action TMastrini_application::postprocess_print(int file, int counter)
{  
  if (file == LF_SALDI) 
  {
    reset_print();
//    stampa_totali_commessa();
    print_one(file);
  
    _msk->reset(-9);
  }

  return NEXT_PAGE;
}
// Stampa dei totali documenti iva se richiesta

void TMastrini_application::stampa_totaliiva()
{
  real totale;

  if (_nummast == 1 || _nummast == 3)
  {
    _rw = 7;                        
    _ddociva_len++;     
    
    if (_stampatotiva)
    {
      TString16 fmt; fmt.format("@%dg", _ddociva_len);
      fmt << "%15s";
      for (int j = 0; j < _b.items(); j++)
      {
        TDociva& riga = (TDociva&)_b[j];
        set_row(_rw+j, "@0g%s",(const char*) riga._descrdoc);   
        totale = riga._totdociva;
        TString string = real2str(totale);
        set_row(_rw+j, fmt, (const char*)string);
      }
    }
    _b.destroy();
  } 
}

// Ricerca della descrizione relativa al codice causale di MOV.dta
// sull'archivio CAUS.dta
void TMastrini_application::descrizione_causale()
{
	const TRectype & caus = cache().get(LF_CAUSALI, _codcaus);

  _descrcaus = caus.get(CAU_DESCR);
}       

// Ricerca sulla tabella dei tipi documento, la descrizione e la natura del
// documento, accedendovi tramite il tipo documento trovato su MOV.dta

void TMastrini_application::documenti_iva()
{
  TString dep;
 
  _tabtpd->curr().zero();
  dep << format ("%2s",(const char*) _tipodoc);
  _tabtpd->curr().put("CODTAB", (const char*) dep);
  _tabtpd->read();
  _descrdociva = _tabtpd->curr().get("S0");
  _natdoc = atoi(_tabtpd->curr().get("I0"));
}     

void TMastrini_application::ricerca_regiva()
{
  TString16 dep;
  _tabreg->curr().zero();
  dep << format("%04d", _annoiva); 
  dep << format("%3s" , (const char*) _regiva);
  _tabreg->curr().put("CODTAB", (const char*) dep);
  _tabreg->read();
  _tipo = _tabreg->get_int("I0");
}    

bool TMastrini_application::preprocess_print(int file, int counter) 
{  
  if (file == LF_SALDI)
  {
    _g_prec = 0;
    _c_prec = 0;
    _s_prec = 0; 
    
    _saldo_periodo = ZERO;
    _totale_periodo_dare = ZERO;
    _totale_periodo_avere = ZERO;
    _saldo_progre = ZERO;
    _totprogre_dare = ZERO;
    _totprogre_avere = ZERO;
    _saldo_progre_al = ZERO;
    _totprogre_dare_al = ZERO;
    _totprogre_avere_al = ZERO;
    _progredare = ZERO;
    _progreavere = ZERO;
    _totale_prima_dare = ZERO;
    _totale_prima_avere = ZERO;
    _saldo_movimenti = ZERO;
    _saldo_progressivi = ZERO;
    _saldo_progre_prec = ZERO;
    _riporto_parziale_dare = ZERO;
    _riporto_parziale_avere = ZERO;
    _protiva = 0;
     
    _flag_del_cazzo = _nummast == 1;
 
    _stampa_progressivi_si = TRUE; 
    _stampa_footer_si      = TRUE;
  }
  
  return TRUE;
}

bool TMastrini_application::set_print(int m)
{
  KEY tasto = K_ENTER;
  while (tasto == K_ENTER)                    
  {
    _puoi_stampare = TRUE;   
    // Controlla se esistono impostazioni di stampa in coda                 
    if (sheet2mask())
    {
      // Simula l'immediata pressione del tasto stampa senza nemmeno lanciare la maschera
      tasto = K_ENTER;
    }  
    else
    {  
      tasto = _msk->run();
      if (tasto == K_ENTER)
      {                                                          
        // Se lo sheet e' vuoto allora usa solo la maschera corrente per la stampa,
        // altrimenti estrae il primo elemento sovrascrivendo la maschera corrente.
        // Questa figata cerca di correggere gli errori MI6185 e MI3592 in una botta
        TSheet_field& sht = (TSheet_field&)_msk->field(F_SCELTE);
        if (sht.items() != 0)
          sheet2mask();     // Estrae la prima riga dalla coda di stampa
      }  
    }  
    if (tasto != K_ENTER)
      break;
    
    _noseparator = _msk->get_bool(F_SEPARATOR);
    if (_noseparator)
      _real_picture = "################";
    else
      _real_picture = "####.###.###.###";
    set_real_picture(_real_picture);
    set_magic_currency(TRUE);
  
    _codice_ditta       = get_firm();
    _annomsk            = _msk->get_int(F_ANNO);
      
    int gruppoini       = _msk->get_int(F_GRUPPOINI);
    int contoini        = _msk->get_int(F_CONTOINI_CONTO);
    long sottocontoini  = _msk->get_long(F_SOTTOCINI_CONTO);
    int gruppofine      = _msk->get_int(F_GRUPPOFINE);
    int contofine       = _msk->get_int(F_CONTOFINE_CONTO);
    long sottocontofine = _msk->get_long(F_SOTTOCFINE_CONTO);
  
    _stampaprogre       = _msk->get_bool(F_STAMPAPROGRE);
    _stampatotiva       = _msk->get_bool(F_STAMPATOTIVA);
    _stampanum          = _msk->get_int(F_STAMPANUM);
    _stampa_mov_prov    = _msk->get_bool(F_STAMPAMOVPROV); 
    _selez_mastrini         = _msk->get_int(F_SELEZ_STAMPA);
  
    _numcarat           = _msk->get_int(F_NUMCARAT);
    _stampa_saldo_des   = _numcarat==2 ? _msk->get_int(F_SALDO_DES) : 0;
    _nummast            = _msk->get_int(F_NUMMAST);
    _data_ini           = _msk->get_date(F_DATAINI);
    _data_fine          = _msk->get_date(F_DATAFINE);
  
    TEsercizi_contabili esc;   
  
    if (_annomsk != 0)
      _anno_corrente = _annomsk;
    else               
    {                                                        
      _anno_ghost = esc.date2esc(_data_ini);
      _anno_corrente = _anno_ghost;
      _inizioes = esc[_anno_ghost].inizio();
    }
  
    data_fine_esercizio(_anno_corrente); // Ricalcola _data_inizioese e _data_finese
    if (!_data_ini.ok())  _data_ini  = _data_inizioese;
    if (!_data_fine.ok()) _data_fine = _data_finese;
         
    _anno_precedente = esc.pred(_anno_corrente);
  
    ricerca_dati_ditta();
  
    if (_nummast == 1 || _nummast == 3)
      printer().footerlen(4);
    else                               
      printer().footerlen(2);
        
//Crea il cursore su gruppo, conto e sottoconto del file RMOV
  
    reset_files();         //resetta l'albero di stampa
    add_file(LF_SALDI);
    add_file(LF_RMOV,LF_SALDI);   
      
    if (_msk->get_bool(F_SORTDESC))
      select_cursor(_cur2);
    else
      select_cursor(_cur1);
        
    TRectype da(LF_SALDI), a(LF_SALDI);       
    da.put(SLD_GRUPPO,gruppoini);        
    da.put(SLD_CONTO,contoini);
    da.put(SLD_SOTTOCONTO,sottocontoini);
    a.put(SLD_GRUPPO,gruppofine);        
    a.put(SLD_CONTO,contofine);
    a.put(SLD_SOTTOCONTO,sottocontofine); 
    current_cursor()->setregion(da, a);
    if (_stampatotiva)   
      _b.destroy();
  
    //_inizio_stampa   = TRUE;    
    _numero_pag      = 1;
    if (_nummast == 3)
      _pagina = 0;
    else      
      _pagina          = 1;
    _cambia_mastrino = FALSE; 
    _rw              = 0;
    _conta_mastrini  = 0;
    _indice_lista    = 0; 
    _ddociva_len     = 0;                                                           
                                                                 
    _riga.destroy();
    _lista.destroy();
      
    switch (_selez_mastrini)
    {
      case 1: _totale_saldo = 1.0; break;
      case 2: _totale_saldo = 0.0; break;
      case 3: _totale_saldo = 1.0; break;
      default: break;
    }
     
    enable_print_menu();
    enable_link("Collegamento prima nota: ", 'b');
    
    _print_cdc = _msk->get_bool(F_PRINTCDC);
    
    if (_msk->field(F_DACDC).active() && (_msk->get(F_DACDC).not_empty() || _msk->get(F_ACDC).not_empty()))
    {
      TRelation rel("CMS");
      TRectype darec(rel.curr()), arec(rel.curr());
      darec.put("CODTAB", _msk->get(F_DACDC));
      arec.put("CODTAB", _msk->get(F_ACDC));
      TCursor cur(&rel, "", 1, &darec, &arec);
      const long items = cur.items();
      cur.freeze();
      
      TRelation fscrel("FSC");
      TRectype da_fsc(fscrel.curr()), a_fsc(fscrel.curr());
      da_fsc.put("CODTAB", _msk->get(F_DAFSC));
      a_fsc.put("CODTAB", _msk->get(F_AFSC));
      TCursor fsccur(&fscrel, "", 1, &da_fsc, &a_fsc);
      const TRecnotype fsc_items =  fsccur.items();
      fsccur.freeze();

      for (cur = 0L; cur.pos() < items; ++cur)
      {
        _cdc = rel.curr().get("CODTAB"); 
         if (!da_fsc.empty() || !a_fsc.empty())
        { 
          for (fsccur = 0L; fsccur.pos() < fsc_items; ++fsccur)
          { 
            _fsc = fsccur.curr().get("CODTAB");
            do 
            {
              _totale_commessa_dare = _totale_commessa_avere = ZERO;
              print();
            } 
            while (need_to_repeat_print());
          }
        }    
        else
        {
          _fsc.cut(0);
          do 
          {
            _totale_commessa_dare = _totale_commessa_avere = ZERO;
            print();
          } 
          while (need_to_repeat_print());
        }
      }
    }
    else
    {
      _cdc.cut(0);
      _fsc.cut(0);
      do 
        print();
      while (need_to_repeat_print());
    }
    _msk->reset(-8);

  }
  return FALSE;
}

void TMastrini_application::data_fine_esercizio(int anno)
{
  TEsercizi_contabili esc;
  _data_inizioese = esc[anno].inizio();
  _data_finese    = esc[anno].fine();
}

void TMastrini_application::preprocess_header()
{                         
  if (_nummast == 1)
  {
    if (_selez_mastrini == 3) // Tutti
      crea_intestazione();
    else
      if (_selez_mastrini == 2) // Con saldo non nullo
      {
        if ((!_totale_saldo.is_zero()) && (_puoi_stampare))
          crea_intestazione();
      }
      else if (_selez_mastrini == 1)
             if (_puoi_stampare)
               crea_intestazione();
  }                
  else
    if (_nummast == 3 && !_gia_stampata_intestazione)
    {
      if (_selez_mastrini == 3) // Tutti
        crea_intestazione();
      else
        if (_selez_mastrini == 2) // Con saldo non nullo
        {
          if ((!_totale_saldo.is_zero()) && (_puoi_stampare))
            crea_intestazione();
        }
        else if (_selez_mastrini == 1) // Movimentati nel periodo
               if (_puoi_stampare)
                 crea_intestazione();
    }                
}  

void TMastrini_application::preprocess_footer()
{   
  reset_footer();
  
  if (_nummast != 1 && _nummast != 3)
    return;
      
  if (_devi_stampare_footer)
  {                    
    real dep_dare,dep_avere;
      
    if (_stampa_footer_si)
    {
      _riporto_footer_dare  = _progredare  + _riporto_parziale_dare;
      _riporto_footer_avere = _progreavere + _riporto_parziale_avere;
      
      real imp_d,imp_a;
      imp_d = _sezione == "D" ? _importo : ZERO;
      imp_a = _sezione == "A" ? _importo : ZERO;
      dep_dare  = _stampato ? _riporto_footer_dare  : _riporto_footer_dare - imp_d;
      dep_avere = _stampato ? _riporto_footer_avere : _riporto_footer_avere - imp_a;
      
      _stampa_footer_si = FALSE;
    }                           
    else
    {
      _riporto_footer_dare  += _riporto_parziale_dare;
      _riporto_footer_avere += _riporto_parziale_avere;

      real imp_d,imp_a;
      imp_d = _sezione == "D" ? _importo : ZERO;
      imp_a = _sezione == "A" ? _importo : ZERO;
      dep_dare  = _stampato ? _riporto_footer_dare  : _riporto_footer_dare - imp_d;
      dep_avere = _stampato ? _riporto_footer_avere : _riporto_footer_avere - imp_a;
    }
    
    if (_nummast != 3 || dep_dare != ZERO || dep_avere != ZERO)
    {     
      TString dare  (real2str(dep_dare));
      TString avere (real2str(dep_avere));
      if (_numcarat == 1)                  
      {
        set_footer (2,FR("@32gA RIPORTO@83g%s"), (const char*) dare);
        set_footer (2,"@100g%s", (const char*) avere);
      }  
      else
        if (_numcarat == 2) 
        {
          set_footer (2,FR("@32gA RIPORTO@100g%s"), (const char*) dare);
          set_footer (2,"@117g%s", (const char*) avere);
        }  
    }             
  }                
}  

void TMastrini_application::conto(int gruppo, int conto, bool no_contropartita)
{
	TString16 key;
	
	key.format("%d|%d|", gruppo, conto);
	
	const TRectype & pconti = cache().get(LF_PCON, key);


  if (no_contropartita)
  {
    _indbil = pconti.get_int(PCN_INDBIL);
    _tmcf   = pconti.get_char(PCN_TMCF);
  }
  else
    _tipo_contr = pconti.get_char(PCN_TMCF);
}

void TMastrini_application::ricerca_dati_ditta()
{
  long app;

  const TRectype & nditte = cache().get(LF_NDITTE, _codice_ditta);
  
	app = nditte.get_long(NDT_CODDITTA);
  _ragsoc = nditte.get(NDT_RAGSOC);
 
  TString16 key;
	
	key.format("%ld|1", app);

	const TRectype & unloc = cache().get(LF_UNLOC, key);
  
	_indulc= unloc.get(ULC_INDULC);
  _civulc= unloc.get(ULC_CIVULC);   
  int len = _indulc.len();
  if (len <= 31)
  {
    if (len <= 26)
      _indulc << " " << _civulc;
    else
      _indulc << " " << _civulc.mid(0,5);
  }
  else
  {
    _indulc = _indulc.mid(0,31);
    _indulc << " " << _civulc.mid(0,5);
  }
  _capulc= unloc.get(ULC_CAPULC);
  _comulc= unloc.get(ULC_COMULC);
 
	key.format("|%s", (const char *) _comulc);
  const TRectype & comuni = cache().get(LF_COMUNI, key);
	
  _com = comuni.get(COM_DENCOM);
  _prov = comuni.get(COM_PROVCOM);
}

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

void TMastrini_application::crea_intestazione()
{
  TString sep(133),sep1(198); 
  reset_header();
  
  int np = get_page_number();
  
  if (_cambia_mastrino)
  { 
    if (_nummast != 3)
      _pagina = 1;
    _cambia_mastrino = FALSE;
  }
  if (_numcarat == 1)
  {
    if (_nummast == 3)
    {
      if (_pagina != np)
        sep << "Pag. @#";
    }     
    else
      sep << "Pag. " << _pagina;
    sep.right_just(132);
    set_header(1,(const char*) sep);
  }
  else if (_numcarat == 2)
       {
         if (_nummast == 3)
         {         
           if (_pagina != np)
            sep1 << "Pagina @#";
         }             
         else          
           sep1 << "Pagina " << _pagina;
         sep1.right_just(198);
         set_header(1,(const char*) sep1);
       }
  if (_nummast != 3)     
    _pagina++;
  
  if (_nummast != 3 || _pagina != np)
  {
    set_header (1, "@0g%s@6g%5ld", TR("DITTA"), _codice_ditta);
    set_header (1, "@12g%-.45s", (const char*) _ragsoc);
    set_header (1, "@59g%s", (const char*) _indulc);
    //set_header (1, "@86g%-.9s", (const char*) _civulc);
    set_header (1, "@97g%-.5s", (const char*) _capulc);
    set_header (1, "@103g%-.18s", (const char*) _com);
    set_header (1, "@122g%-.3s", (const char*) _prov);
  }     

  if (_cdc.not_empty())
  {                                                                           
    const TString& desc_cdc = cache().get("CMS", _cdc, "S0");                     
    if (_fsc.not_empty())
    {
      const TString& desc_fsc = cache().get("FSC", _fsc, "S0");                     
      set_header(2, FR("@bCommessa %s %s - Fase %s %s"), 
                 (const char*)_cdc, (const char*)desc_cdc,
                 (const char*)_fsc, (const char*)desc_fsc);
    }
    else
      set_header(2, FR("@bCommessa %s %s"), (const char*)_cdc, (const char*)desc_cdc);
  }

  if (_nummast == 3)
    set_header (3, "@0g%s@12g@b%3d %3d %6ld", TR("Sottoconto"), _gruppo, _conto, _sottoc);
  else
    set_header (3, "@0g%s@12g%3d %3d %6ld", TR("Sottoconto"), _gruppo, _conto, _sottoc);
    
  switch(_tmcf)  
  {
  case 'C': _tipo_mask = 1; break;
  case 'F': _tipo_mask = 2; break;
  default : _tipo_mask = 3; break;
  }

  switch (_tipo_mask)
  {
    case 1: ricerca_clifo();
              break;
    case 2: ricerca_clifo();
              break;
    case 3: ricerca_gruppo();
              break;
    default:  break;
  }    

  if (_numcarat == 1)
  {
    sep.fill('_');                            //Stampa 132 - (sep(132))      
    set_header (6, (const char *) sep);
    set_header (7,"%s@19g%s@117g%s@132g%s", 
                TR("Operazione"), TR("Documento"), TR("Contro"), TR("A"));
    if (_stampa_mov_prov)
      set_header(7,"@130gM");
    set_header (8, TR("Data"));
    if (_stampanum < 3)
      set_header (8,"@11g%s", TR("Numero"));
    set_header (8,"@19g%s@30g%s@38g%s@61g%s@95g%s@111g%s@117g%s@127g%s@132g%s",
                TR("Data"), TR("Numero"), TR("Cod.Causale"), TR("Descrizione"),
                TR("Dare"), TR("Avere"), TR("Partita"), TR("Prot."), TR("C"));
    if (_stampa_mov_prov)
      set_header(8,"@130g%s", TR("P"));
    sep.fill('_');
    set_header (9, (const char *) sep);
  }
  else
  {
   sep1.fill('_');                    //Stampa 198 - (sep1(198))      
   set_header (6,"@0g%s", (const char*)sep1);
   if (_stampa_saldo_des == 3)
   {
     set_header (7,"%s@23g%s@183g%s@190g%s@197g%s",
                 TR("Operazione"), TR("Documento"),
                 TR("Reg"), TR("Numero"), TR("A"));
   }
   else
   {
     set_header (7,"%s@23g%s@169g%s@183g%s@190g%s@197g%s",
                 TR("Operazione"), TR("Documento"), TR("Contro"),
                 TR("Reg"), TR("Numero"), TR("A"));
   }
   if (_stampa_mov_prov)
     set_header(7,"@195g%s", TR("M"));
   set_header (8,TR("Data"));
   if (_stampanum < 3)
     set_header (8,"@11g%s", TR("Numero"));
     
   switch (_stampa_saldo_des)
   {
   case 1:
     set_header (8,"@23g%s@34g%s@42g%s@70g%s@112g%s@127g%s@135g%s@152g%s@169g%s@183g%s@189g%s@197g%s",
                 TR("Data"), TR("Numero"), TR("Cod.Causale"), TR("Descrizione"), TR("Dare"), TR("Avere"),
                 TR("Saldo progre."), TR("Saldo movim."), TR("Partita"), TR("Iva"), TR("Protoc."), TR("C"));
     break;
   case 2:
     set_header (8,"@23g%s@34g%s@42g%s@70g%s@112g%s@127g%s@135g%s@152g%s@169g%s@183g%s@189g%s@197g%s",
                 TR("Data"), TR("Numero"), TR("Cod.Causale"), TR("Descrizione"), TR("Dare"), TR("Avere"),
                 TR("Saldo scalare"), TR("Saldo movim."), TR("Partita"), TR("Iva"), TR("Protoc."), TR("C"));
     break;
   case 3:
     set_header (8,"@23g%s@34g%s@42g%s@70g%s@112g%s@127g%s@135g%s@183g%s@189g%s@197g%s",
                 TR("Data"), TR("Numero"), TR("Cod.Causale"), TR("Descrizione"), TR("Dare"), TR("Avere"),
                 TR("Contropartita"), TR("Iva"), TR("Protoc."), TR("C"));
     break;
   default:
     break;
   }
               
   if (_stampa_mov_prov)
     set_header(8,"@195g%s", TR("P"));
   sep1.fill('_');
   set_header (9,"@0g%s", (const char*)sep1);
  } 
       
  calcola_progressivi();
  _saldo_progressivi += _saldo_progre_prec;          
        
  if (_stampa_progressivi_si)
  {
    if (_numcarat == 1)
    { 
      set_header (10,"@42g%s@66g%s", TR("PROGRESSIVI PRECEDENTI"), real2str(_saldo_progre_prec));
      set_header (10,"@83g%s", real2str(_progredare));
      set_header (10,"@100g%s", real2str(_progreavere));
    }
    else
    {
      set_header (10,"@70g%s@100g%s", TR("PROGRESSIVI PRECEDENTI"), real2str(_progredare));
      set_header (10,"@117g%s", real2str(_progreavere));
      if (_stampa_saldo_des < 3)
        set_header (10,"@135g%s", real2str(_saldo_progre_prec));
    }
    _riporto_dare = _progredare;
    _riporto_avere = _progreavere;
    _stampa_progressivi_si = FALSE;
  }
  else
  {
    _riporto_dare += _riporto_parziale_dare;
    _riporto_avere += _riporto_parziale_avere;

    real dep_dare,dep_avere,imp_d,imp_a;
    imp_d = _sezione == "D" ? _importo : ZERO;
    imp_a = _sezione == "A" ? _importo : ZERO;
    dep_dare = _stampato ? _riporto_dare : _riporto_dare - imp_d;
    dep_avere = _stampato ? _riporto_avere : _riporto_avere - imp_a;

    if (_nummast != 3 || dep_dare != ZERO || dep_avere != 0)
    {
      if (_numcarat == 1)
      {
        set_header (10,"@32g%s@83g%s", TR("A RIPORTO"), real2str(dep_dare));
        set_header (10,"@100g%s", real2str(dep_avere));
      }
      else
      {
        set_header (10,"@32g%s@100g%s", TR("A RIPORTO"), real2str(dep_dare));
        set_header (10,"@117g%s", real2str(dep_avere));
      }
    }  
    _riporto_parziale_dare = ZERO;
    _riporto_parziale_avere = ZERO;
  }

  if (_numcarat == 1)
  {
    sep ="";
    set_header(11,"@0g%s",(const char*) sep);
  }
  else
  {
    sep1 ="";
    set_header(11,"@0g%s",(const char*) sep1);
  }

  if (_pagina != np && _nummast == 3)
    _pagina = np;       
}

int TMastrini_application::crea_intestazione(int start_riga)
{
  TString   sep(132),sep1(198); 
  int       r = start_riga + 2;
  sep = "";

  reset_header();

  int np = get_page_number();
    
  _conta_mastrini++;
    
  if (_nummast == 3)
    _gia_stampata_intestazione = TRUE;
      
  if (_nummast == 2)
    if (_cambia_mastrino)
    {
      _numero_pag = 1;
      _cambia_mastrino = FALSE;
    }
  if (_nummast == 3)
  {
    if (_pagina != np)
    {
      if (_numcarat == 1)
      {
        sep << FR("Pag. @#");
        set_row(r,"@126g%s", (const char*) sep);
      }     
      else if (_numcarat == 2)
      {
        sep << FR("Pagina @#");
        set_row(r,"@190g%s", (const char*) sep);
      }       
    }     
  }          
  else
  {
    if (_numcarat == 1)
      set_row(r,"@126g%s %2d", TR("Pag."), _numero_pag++);
    else if (_numcarat == 2)
      set_row(r,"@190g%s %2d", TR("Pagina"),_numero_pag++);
  }              
  if (_nummast != 3 || _pagina != np)
  {
    set_row (r, "@0g%s@6g%5ld", TR("DITTA"), _codice_ditta);
    set_row (r, "@12g%-45s", (const char*) _ragsoc);
    set_row (r, "@59g%s", (const char*) _indulc);
    //set_row (r, "@86g%-9s", (const char*) _civulc);
    set_row (r, "@97g%-5s", (const char*) _capulc);
    set_row (r, "@103g%-18s", (const char*) _com);
    set_row (r, "@122g%-3s", (const char*) _prov);
    r += 2;                 
  }   
  if (_nummast == 3)
    set_row (r, "@0g%s@12g@b%3d %3d %6ld", TR("Sottoconto"), _gruppo, _conto, _sottoc);
  else
    set_row (r, "@0g%s@12g%3d %3d %6ld", TR("Sottoconto"), _gruppo, _conto, _sottoc);
  
  if (_tmcf == 'C')                       
    _tipo_mask = 1;                       
  else if (_tmcf == 'F')                
    _tipo_mask = 2;               
  else if (_tmcf == '\0')        
    _tipo_mask = 3;        
  
  switch (_tipo_mask)
  {
    case 1: r = ricerca_clifo(r);
              break;
    case 2: r = ricerca_clifo(r);
              break;
    case 3: r = ricerca_gruppo(r);
              break;
    default:  break;
  }    
  
  r++;
  
  if (_numcarat == 1)
  {
    sep.fill('_');                            //Stampa 132 - (sep(132))      
    set_row (r++,"@0g%s", (const char *) sep);
    set_row (r++,"%s@19g%s@117g%s@131g%s", TR("Operazione"), TR("Documento"), TR("Contro"), TR("A"));
    if (_stampa_mov_prov)
      set_header(r-1,"@130g%s", TR("M"));
    set_row (r, TR("Data"));
    if (_stampanum < 3)
      set_row (r,"@11g%s", TR("Numero"));
    set_row (r++,FR("@19gData@30gNumero@38gCod.Causale@61gDescrizione@95gDare@111gAvere@117gPartita@131gC"));
    if (_stampa_mov_prov)
      set_header(r-1,"@130gP");
    sep.fill('_');
    set_row (r++,"@0g%s", (const char*)sep);
  }
  else
  {
   sep1.fill('_');                    //Stampa 198 - (sep1(198))      
   set_row (r++,"@0g%s", (const char*)sep1);
   if (_stampa_saldo_des == 2)
     set_row (r++,FR("Operazione@23gDocumento@183gReg@190gNumero@197gA"));
   else  
     set_row (r++,FR("Operazione@23gDocumento@169gContro@183gReg@190gNumero@197gA"));
   if (_stampa_mov_prov)
     set_row(r-1,"@195gM");
   set_row (r,"Data");
   if (_stampanum < 3)
     set_row (r,"@11gnumero");
   set_row (r,FR("@23gData@34gNumero@42gCod.Causale@70gDescrizione@112gDare@127gAvere"));
   if (_stampa_saldo_des == 2)
     set_row (r++,FR("@135gContropartita@183gIva@189gProtoc.@197gC"));
   else  
     set_row (r++,FR("@135gSaldo progre.@152gSaldo movim.@169gPartita@183gIva@189gProtoc.@197gC"));
   if (_stampa_mov_prov)
     set_row (r-1,"@195gP");
   sep1.fill('_');
   set_row (r++,"@0g%s", (const char*)sep1);
  }   
  _pagina = np;       
  return r;     
}
          
int TMastrini_application::stampa_progre_riporto(int start_riga)
{ 
  TString sep(132),sep1(198);                                  
  int r = start_riga;
  
  if (_stampa_progressivi_si)
  {
    r = stampa_progressivi(r);
    _riporto_dare = _progredare;
    _riporto_avere = _progreavere;
    _stampa_progressivi_si = FALSE;
  }
  else
  {
    _riporto_dare += _riporto_parziale_dare;
    _riporto_avere += _riporto_parziale_avere;
    
    real dep_dare,dep_avere,imp_d,imp_a;
    imp_d = _sezione == "D" ? _importo : ZERO;
    imp_a = _sezione == "A" ? _importo : ZERO;
    dep_dare = _stampato ? _riporto_dare : _riporto_dare - imp_d;
    dep_avere = _stampato ? _riporto_avere : _riporto_avere - imp_a;

    if (_nummast != 3 || dep_dare != ZERO || dep_avere != ZERO)
    {
      if (_numcarat == 1)
      {
        set_row (r,"@32g%s@83g%r", TR("A RIPORTO"), &dep_dare);
        set_row (r++,"@100g%r", &dep_avere);
      }
      if (_numcarat == 2)
      {
        set_row (r,"@32g%s@100g%r", TR("A RIPORTO"), &dep_dare);
        set_row (r++,"@117g%r", &dep_avere);
      }
    }     
    _riporto_parziale_dare = ZERO;
    _riporto_parziale_avere = ZERO;
  }
  if (_numcarat == 1)
  {
    sep ="";
    set_row(r++,"@0g%s",(const char*) sep);
  }
  else
  {
   sep1 ="";
   set_row(r++,"@0g%s",(const char*) sep1);
  }            
  return r;
} 
         
void TMastrini_application::calcola_progressivi_al(const TDate& data_fin)
{
  TLocalisamfile& rmov_file = current_cursor()->file(LF_RMOV);
  const TRecnotype record = rmov_file.recno(); 

  _totale_prima_dare  = ZERO;
  _totale_prima_avere = ZERO;
  
  TRelation rel(LF_RMOV);     
  rel.add(LF_MOV, "NUMREG==NUMREG");
  TRectype& rmov = rel.curr(); 
  const TRectype& mov = rel.curr(LF_MOV); 
  
  TString filter;
  if (_cdc.not_empty())
  {
    filter << RMV_CODCMS << "==\"" << _cdc << "\"";
    if (_fsc.not_empty())
      filter << "&&(" << RMV_FASCMS << "==\"" << _fsc << "\")";
  } 
  rmov.zero();
  rmov.put(RMV_GRUPPO,     _gruppo);
  rmov.put(RMV_CONTO,      _conto);
  rmov.put(RMV_SOTTOCONTO, _sottoc);
  TCursor cur(&rel, filter, 2, &rmov, &rmov);
  const long items = cur.items();
  cur.freeze();
  for (cur = 0L; cur.pos() < items; ++cur)
  {
    const int annoes = rmov.get_int (RMV_ANNOES);
    TDate datareg = rmov.get(RMV_DATAREG);
    const char sezione = rmov.get_char(RMV_SEZIONE);
    const real importo = rmov.get(RMV_IMPORTO);
    long numreg = rmov.get_long(RMV_NUMREG);

	  const TRectype & mov = cache().get(LF_MOV, numreg);
    const TDate datacomp = (mov.get(MOV_DATACOMP));
		TDate data;
    const TString16 provvis (mov.get(MOV_PROVVIS));


    if (_stampa_mov_prov || (!_stampa_mov_prov && provvis.blank()))
    {
      if (_annomsk == 0)
      {
        datareg = rmov.get_date(RMV_DATAREG); 
        data = _inizioes;
      }
      else
      {
        datareg = datacomp;
        data = _data_inizioese;
      }  

      const int gruppo = rmov.get_int(RMV_GRUPPO);
      const int conto  = rmov.get_int(RMV_CONTO);
      const long sottoc = rmov.get_long(RMV_SOTTOCONTO);
      if ((gruppo != _gruppo)||(conto != _conto)||(sottoc != _sottoc))
        break;
      else 
      {
        //Legge movimenti con data > inizio esercizio e < data_fin
        if (((annoes==_annomsk)||(_annomsk == 0))&&(datareg >= data)&&(datareg <= data_fin)) 
          if (sezione == 'D')
            _totale_prima_dare += importo;
          else
            _totale_prima_avere += importo;
      }
    } // if ((_stampa_mov_prov) || ((!_stampa_mov_prov) && (provvis.trim().empty())))              
  }  
  
  // Riposiziona rmov
  rmov_file.readat(record);
}

void TMastrini_application::calcola_progressivi(bool finali)
{
   /* fv 20/3/96: aggiustato per nuova struttura saldi - modificata ricerca
    * record scaricati e assegnazione dare/avere relativo - Controllare che
    * non occorra considerare il saldo di chiusura (SALDOFIN) aggiunto al
    * record */

   TLocalisamfile saldi(LF_SALDI);
   real progdare_attuale,progavere_attuale,progdare_prec,progavere_prec;
   real saldo,progredare_eseprec,progreavere_eseprec,saldoini_attuale,saldofine_attuale;
   char salini,salini_attuale,salfine_attuale;

   saldo         = ZERO;    // Saldo iniziale (Guy: Ovvio no?)  
   
   if (_cdc.empty())
   {
  // Ricerca sull'archivio saldi dei record con gruppo,conto,sottoconto
  // uguali a quelli di rmov per il calcolo dei progressivi precedenti
  
     saldi.setkey(2);
     saldi.zero();
     saldi.put(SLD_GRUPPO,     _gruppo);
     saldi.put(SLD_CONTO,      _conto);
     saldi.put(SLD_SOTTOCONTO, _sottoc);
     const TRectype record(saldi.curr());
    
     for (saldi.read(_isgteq); saldi.good() && saldi.curr() == record; saldi.next())
     {             
       if (!saldi.get_bool(SLD_FLSCA))
       {
         const int annoes_saldi = saldi.curr().get_int(SLD_ANNOES);
       
  //Calcola i progressivi dell'esercizio attuale
         if (annoes_saldi == _anno_corrente)
         {
           progdare_attuale  = saldi.get_real(SLD_PDARE);
           progavere_attuale = saldi.get_real(SLD_PAVERE);
           if (_stampa_mov_prov)
           {
             progdare_attuale += saldi.get_real(SLD_PDAREPRO);
             progavere_attuale += saldi.get_real(SLD_PAVEREPRO);
           }
  
           saldo             = saldi.get_real(SLD_SALDO);
           salini            = saldi.get(SLD_FLAGSALINI)[0]; 
           _ultima_data_reg  = saldi.get_date(SLD_DATAULMOV);
           saldoini_attuale  = saldi.get_real(SLD_SALDO);
           salini_attuale    = saldi.get_char(SLD_FLAGSALINI); 
           saldofine_attuale = saldi.get_real(SLD_SALDOFIN);
           salfine_attuale   = saldi.get_char(SLD_FLAGSALFIN);
         }
       }   // if (!saldi.get_bool(SLD_FLSCA))
     }   // FOR
     
  //Se il saldo dell'esercizio attuale non e' diverso da zero, allora il saldo
  // finale dell'esercizio precedente devo calcolarmelo tenendo conto dell'indbil
                             
     if (_annomsk != 0)
     {    
       if ((_indbil == 1) || (_indbil == 2) || (_indbil == 5))
       {           
         const TRecnotype pos = saldi.recno();                                      
         // W96SALDI del 18-07-96 saldofin_esprec usa il flag TRUE xche' deve
         // considerare anche il saldo finale
         saldo = _sld->saldofin_esprec(_anno_corrente,_gruppo,_conto,_sottoc,TRUE, _stampa_mov_prov);
         saldi.readat(pos);
             
         if (saldo > ZERO)
         {
           progredare_eseprec  = saldo;
           progdare_prec = saldo;
         }
         else if (saldo < ZERO)
         {
           saldo = -saldo;
           progreavere_eseprec = saldo;
           progavere_prec = saldo;
         }
       }
     }
   }
   
   if (finali)
   {
     calcola_progressivi_al(_data_fine);
   }
   else
   {
     TDate giorno_prima = _data_ini; --giorno_prima;       // CM500429
     calcola_progressivi_al(giorno_prima);
   }
  
//Calcolo dei progressivi precedenti: somma di tutti quei movimenti di rmov
//che hanno la data di registrazione inferiore alla data di inizio stampa,
//dei progressivi dell'anno esercizio precedente, e dei progressivi dei
//movimenti scaricati dell'esercizio attuale.

   _progredare  = progredare_eseprec   + _totale_prima_dare;
   _progreavere = progreavere_eseprec + _totale_prima_avere;
   _saldo_progre_prec = _progredare - _progreavere;

//Calcolo dei progressivi al <ultima data registrazione>  

//Se sulla maschera e' stato selezionato il controllo competenza esercizio
//Sommo i progressivi dell'esercizio precedente e quelli dell'esercizio attuale
//altrimenti solo quelli dell'esercizio attuale

   if (_annomsk != 0)
   {
     _totprogre_dare_al     = progdare_attuale  + progdare_prec;
     _totprogre_avere_al    = progavere_attuale + progavere_prec;  

     if (salini_attuale == 'D')
       _totprogre_dare_al += saldoini_attuale;
     else
       _totprogre_avere_al += saldoini_attuale;
     if (salfine_attuale == 'D')
       _totprogre_dare_al += saldofine_attuale;
     else
       _totprogre_avere_al += saldofine_attuale;       
   }
   else
   {
     _totprogre_dare_al = progdare_attuale;
     _totprogre_avere_al = progavere_attuale;

     if (salini_attuale == 'D')
       _totprogre_dare_al += saldoini_attuale;
     else if (salini_attuale == 'A')
            _totprogre_avere_al += saldoini_attuale;
     if (salfine_attuale == 'D')
       _totprogre_dare_al += saldofine_attuale;
     else if (salfine_attuale == 'A')
       _totprogre_avere_al += saldofine_attuale;       
   } 
}

int TMastrini_application::stampa_progressivi(int start_riga)
{                                                           
  int r = start_riga;
  
  if (_numcarat == 1)
  { 
    set_row (r,FR("@42gPROGRESSIVI PRECEDENTI@66g%r"), &_saldo_progre_prec);
    set_row (r,"@83g%r", &_progredare);
    set_row (r++,"@100g%r", &_progreavere);
  }
  else
  {
    set_row (r,FR("@70gPROGRESSIVI PRECEDENTI@100g%r"), &_progredare);
    set_row (r,"@117g%r", &_progreavere);
    if (_stampa_saldo_des < 3)
      set_row (r++,"@135g%r", &_saldo_progre_prec);
  }       
         
  return r;
}

// Se la ricerca selezionata nella maschera e' per clienti, oppure fornitori,  // allora ricerco su CLIFO i relativi dati, e su PCON il relativo gruppo,conto,// sottoconto e IV direttiva CEE

void TMastrini_application::ricerca_clifo()
{
  TString ragsoc,paiv,cofi,indcf,capcf,ptel,tel,statocf,comcf,dencom,provcom,dep;
  TString16 dataini,datafine; 
  TString   descriz,descriz2;
  int     numrivd;
  
  indcf = "";
  
  TString16 key;

  key.format("%c|%ld", _tmcf, _sottoc);

  const TRectype & clifo = cache().get(LF_CLIFO, key);
  TConto tc (_gruppo,_conto,_sottoc,_tmcf);
  
  ragsoc  = tc.descrizione();
  paiv    = clifo.get(CLI_PAIV);
  cofi    = clifo.get(CLI_COFI);
  indcf   = clifo.get(CLI_INDCF);
  indcf.trim();
  indcf << " " << clifo.get(CLI_CIVCF);
  capcf   = clifo.get(CLI_CAPCF);
  ptel    = clifo.get(CLI_PTEL);
  tel     = clifo.get(CLI_TEL);
  statocf = clifo.get(CLI_STATOCF);
  comcf   = clifo.get(CLI_COMCF);

	key.format("%s|%s", (const char *) statocf, (const char *) comcf);
	const TRectype & comuni = cache().get(LF_COMUNI, key);

  if (!comuni.empty())
  {
    dencom = comuni.get(COM_DENCOM);
    provcom = comuni.get(COM_PROVCOM);
  }
  else
  {
    dencom = clifo.get(CLI_LOCCF);
    provcom="";
  }
	
	key.format("%d|%d|", _gruppo, _conto);
  
	const TRectype & pconti = cache().get(LF_PCON, key);
  _sezivd  = pconti.get_char(PCN_SEZIVD);
  _lettivd = pconti.get_char(PCN_LETTIVD);
  numrivd  = pconti.get_int(PCN_NUMRIVD); 
  _numrivd = itor(numrivd);
  _numivd  = pconti.get_int(PCN_NUMIVD);

  descriz = descrizione_classe(_sezivd,_lettivd,numrivd,_numivd);    
 
  if (_numivd != 0)      //Ora devo stampare la descrizione del livello della
  {                      //classe immediatamente precedente a quello appena
   if (_numrivd != "")   //stampato
     descriz2 = descrizione_classe(_sezivd,_lettivd,_numrivd_int,0);
   else
     descriz2 = descrizione_classe(_sezivd,_lettivd,0,0);
  }
  else
    if (_numrivd != "")
      descriz2 = descrizione_classe(_sezivd,_lettivd,0,0);   
    else
      descriz2 = "";
 
  set_header(3,"@27g%-.30s",(const char*) descrizione_gruppo());
  set_header(3,"@59g%-.30s",(const char*) descrizione_conto());
  set_header(3, "@91g%-.41s",(const char*) ragsoc);
  if (_nummast == 3)
    set_header(4, "@r%s@8g@b%c", TR("Classe"), _lettivd);
  else
    set_header(4, "%s@8g%c", TR("Classe") , _lettivd);  
  set_header(4, "@10g%-8s", (const char*) _numrivd);
  if (_numivd != 0)
    set_header(4, "@19g%2d", _numivd);
  if (descriz2 != "")                              
  {
    set_header(4,"@23g%-50s",(const char*) descriz2);
    set_header(4,"@80g%-50s",(const char*) descriz);                                                  
  }
  else
    set_header(4,"@23g%-50s",(const char*) descriz);
    
  dataini = _data_ini.string();   
  datafine = _data_fine.string();

  if (_annomsk == 0)
  {                         
    if (_nummast == 3)
    {
      set_header (5, FR("@rPeriodo@10g@b%s"), (const char*) dataini);
      set_header (5, "@22g@b%s@r", (const char*) datafine);    
    }
    else
    {
      set_header (5, FR("Periodo@10g%s"), (const char*) dataini);
      set_header (5, "@22g%s", (const char*) datafine);
    }
  }
  else
  {                         
    if (_nummast == 3)
    {
      set_header (5, FR("@rComp. da@9g@b%s"), (const char*) dataini);
      set_header (5, "@20g@ra@22g@b%s@r", (const char*) datafine);    
    }
    else
    {
      set_header (5, FR("Comp. da@9g%s"), (const char*) dataini);
      set_header (5, "@20ga@22g%s", (const char*) datafine);
    }
  }

  set_header (5, FR("@33gP.I.@37g%-11s"),(const char*) paiv);
  set_header (5, FR("@49gCF@52g%-16s"),(const char*) cofi);
  set_header (5, "@66g%-.25s",(const char*) indcf);
  set_header (5, "@95g%-5s",(const char*) capcf);
  set_header (5, "@101g%-.24s",(const char*) dencom);
  set_header (5, "@126g%-5s",(const char*) provcom);
 
  if (_numcarat == 2)
  {
    set_header (5,"@135g%-4s",(const char*) ptel);
    if (tel != "")
      set_header (5,"@138g/@139g%-10s",(const char*) tel);
  }
}

int TMastrini_application::ricerca_clifo(int start)
{
  TString ragsoc,paiv,cofi,indcf,capcf,ptel,tel,statocf,comcf,dencom,provcom,dep;
  TString16 dataini,datafine; 
  TString   descriz,descriz2;
  int     numrivd;
  int   r = start;
  
  indcf = "";
  
  TString16 key;

  key.format("%c|%ld", _tmcf, _sottoc);

  const TRectype & clifo = cache().get(LF_CLIFO, key);
  TConto tc (_gruppo,_conto,_sottoc,_tmcf);
  
  ragsoc  = tc.descrizione();
  paiv    = clifo.get(CLI_PAIV);
  cofi    = clifo.get(CLI_COFI);
  indcf   = clifo.get(CLI_INDCF);
  indcf.trim();
  indcf << " " << clifo.get(CLI_CIVCF);
  capcf   = clifo.get(CLI_CAPCF);
  ptel    = clifo.get(CLI_PTEL);
  tel     = clifo.get(CLI_TEL);
  statocf = clifo.get(CLI_STATOCF);
  comcf   = clifo.get(CLI_COMCF);

	key.format("%s|%s", (const char *) statocf, (const char *) comcf);

	const TRectype & comuni = cache().get(LF_COMUNI, key);
	
  if (!comuni.empty())
  {
    dencom = comuni.get(COM_DENCOM);
    provcom = comuni.get(COM_PROVCOM);
  }
  else
  {
    dencom=clifo.get(CLI_LOCCF);
    provcom="";
  }

  key.format("%d|%d|", _gruppo, _conto);

  const TRectype & pconti = cache().get(LF_PCON, key);
  _sezivd  = pconti.get_char(PCN_SEZIVD);
  _lettivd = pconti.get_char(PCN_LETTIVD);
  numrivd  = pconti.get_int(PCN_NUMRIVD); 
  _numrivd = itor(numrivd);
  _numivd  = pconti.get_int(PCN_NUMIVD);

  descriz = descrizione_classe(_sezivd,_lettivd,numrivd,_numivd);    
 
  if (_numivd != 0)      //Ora devo stampare la descrizione del livello della
  {                      //classe immediatamente precedente a quello appena
   if (_numrivd != "")   //stampato
     descriz2 = descrizione_classe(_sezivd,_lettivd,_numrivd_int,0);
   else
     descriz2 = descrizione_classe(_sezivd,_lettivd,0,0);
  }
  else
    if (_numrivd != "")
      descriz2 = descrizione_classe(_sezivd,_lettivd,0,0);   
    else
      descriz2 = "";
 
  set_row (r,"@27g%-30s",(const char*) descrizione_gruppo());
  set_row (r,"@59g%-30s",(const char*) descrizione_conto());
  set_row(r++, "@91g%-30s",(const char*) ragsoc);
  if (_nummast == 3)                  
    set_row(r, "@r%s@8g@b%c", TR("Classe"), _lettivd);
  else
    set_row(r, "%s@8g%c", TR("Classe"), _lettivd);
  set_row(r, "@10g%-8s", (const char*) _numrivd);
  if (_numivd != 0)
    set_row(r, "@19g%2d", _numivd);
  if (descriz2 != "")                              
  {
    set_row(r,"@23g%-50s",(const char*) descriz2);
    set_row(r++,"@80g%-50s",(const char*) descriz);                                                  
  }
  else
    set_row(r++,"@23g%-50s",(const char*) descriz);
                                       
  dataini = _data_ini.string();   
  datafine = _data_fine.string();

  if (_annomsk == 0)
  {                          
    if (_nummast == 3)       
    {
      set_row (r, "@r%s@10g@b%s", TR("Periodo"), (const char*) dataini);
      set_row (r, "@22g%s@r", (const char*) datafine);    
    }
    else
    {
      set_row (r, "%s@10g%s", TR("Periodo"), (const char*) dataini);
      set_row (r, "@22g%s", (const char*) datafine);
    }
  }
  else
  {                        
    if (_nummast == 3)
    {
      set_row (r, "@r%s@9g@b%s", TR("Comp.dal"), (const char*) dataini);
      set_row (r, "@20g@r%s@22g@b%s@r", TR("al"), (const char*) datafine);    
    }
    else
    {
      set_row (r, "%s@9g%s", TR("Comp.dal"), (const char*) dataini);
      set_row (r, "@20g%s@22g%s", TR("al"), (const char*) datafine);
    }
  }

  set_row (r, FR("@33gP.I.@37g%-11s"),(const char*) paiv);
  set_row (r, FR("@49gCF@52g%-16s"),(const char*) cofi);
    set_row (r, "@66g%-.25s",(const char*) indcf);
  set_row (r, "@95g%-5s",(const char*) capcf);
  set_row (r, "@101g%-.24s",(const char*) dencom);
  set_row (r, "@126g%-5s",(const char*) provcom);
 
  if (_numcarat == 2)
  {
    set_row (r,"@135g%-4s",(const char*) ptel);
    if (tel != "")
      set_row (r++,"@138g/@139g%-10s",(const char*) tel);
  }
  return r;
}


// Se la ricerca selezionata sulla maschera e' per gruppo, conto, sottoconto
// ricerca i corrispondenti su PCON, con relativa IV direttiva CEE

void TMastrini_application::ricerca_classe_IV(bool scelta)
{
	TString16 key;
  
	if (scelta)
    key.format("%d|%d|%ld", _gruppo, _conto, _sottoc);
	else
    key.format("%d|%d|", _gruppo, _conto);

  const TRectype & pconti = cache().get(LF_PCON, key);
  _sezivd  = pconti.get_char(PCN_SEZIVD);
  _lettivd = pconti.get_char(PCN_LETTIVD);
  _numrivd_int  = pconti.get_int (PCN_NUMRIVD); 
  _numrivd = itor(_numrivd_int);
  _numivd  = pconti.get_int (PCN_NUMIVD);
}
 
void TMastrini_application::ricerca_gruppo()
{ 
  TString80 descr,descriz,descriz2,dep;
  TString dataini,datafine;
                           
  ricerca_classe_IV (TRUE);    //Esiste a livello di sottoconto
  
  if (_sezivd == '0')           //Non esiste a livello di sottoconto
    ricerca_classe_IV (FALSE);  //Allora la cerco a livello di conto
                             
  descriz = descrizione_classe(_sezivd,_lettivd,_numrivd_int,_numivd);
  if (_numivd != 0)      //Ora devo stampare la descrizione del livello della
  {                      //classe immediatamente precedente a quello appena
   if (_numrivd != "")   //stampato
     descriz2 = descrizione_classe(_sezivd,_lettivd,_numrivd_int,0);
   else
     descriz2 = descrizione_classe(_sezivd,_lettivd,0,0);
  }
  else
    if (_numrivd != "")
      descriz2 = descrizione_classe(_sezivd,_lettivd,0,0);   
    else
      descriz2 = "";

  set_header(3,"@27g%-.30s",(const char*) descrizione_gruppo());
  set_header(3,"@59g%-.30s",(const char*) descrizione_conto());

  set_header(3,"@91g%-.41s",(const char*) descrizione_sottoconto());
  if (_nummast == 3)
    set_header(4, "@0g@r%s@12g@b%c", TR("Classe"), _lettivd);
  else
    set_header(4, "@0g%s@12g%c", TR("Classe"), _lettivd);
  set_header(4, "@14g%-8s",(const char*) _numrivd); 
  if (_numivd != 0)
    set_header(4, "@23g%d", _numivd); 
  if (descriz2 != "")
  {
    set_header(4,"@27g%-50s",(const char*) descriz2);
    set_header(4,"@80g%-50s",(const char*) descriz);                                                  
  }
  else
    set_header(4,"@27g%-50s",(const char*) descriz);
  
  dataini = _data_ini.string();
  datafine = _data_fine.string();

  if (_annomsk == 0)
  { 
    if (_nummast == 3)
    {
      set_header (5, "@r%s@12g@b%s", TR("Periodo"), (const char*) dataini);
      set_header (5, "@24g@b%s@r", (const char*) datafine);    
    }
    else
    {
      set_header (5, "%s@12g%s", TR("Periodo"), (const char*) dataini);
      set_header (5, "@24g%s", (const char*) datafine);
    }
  }
  else
  {                             
    if (_nummast == 3)
    {
      set_header (5, "@r%s@23g@b%s", TR("Periodo di competenza"), (const char*) dataini);
      set_header (5, "@35g%s@r", (const char*) datafine);    
    }
    else
    {
      set_header (5, "%s@23g%s", TR("Periodo di competenza"), (const char*) dataini);
      set_header (5, "@35g%s", (const char*) datafine);
    }
  }
}

int TMastrini_application::ricerca_gruppo(int start)
{ 
  TString80 descr,descriz,descriz2,dep;
  TString dataini,datafine;
  int   r = start;
                           
  ricerca_classe_IV (TRUE);    //Esiste a livello di sottoconto
  
  if (_sezivd == '0')           //Non esiste a livello di sottoconto
    ricerca_classe_IV (FALSE);  //Allora la cerco a livello di conto
                             
  descriz = descrizione_classe(_sezivd,_lettivd,_numrivd_int,_numivd);
  if (_numivd != 0)      //Ora devo stampare la descrizione del livello della
  {                      //classe immediatamente precedente a quello appena
   if (_numrivd != "")   //stampato
     descriz2 = descrizione_classe(_sezivd,_lettivd,_numrivd_int,0);
   else
     descriz2 = descrizione_classe(_sezivd,_lettivd,0,0);
  }
  else
    if (_numrivd != "")
      descriz2 = descrizione_classe(_sezivd,_lettivd,0,0);   
    else
      descriz2 = "";

  set_row(r,"@27g%-.30s",(const char*) descrizione_gruppo());
  set_row(r,"@59g%-.30s",(const char*) descrizione_conto());

  set_row(r++,"@91g%-.41s",(const char*) descrizione_sottoconto());
  if (_nummast == 3)
    set_row(r, "@0g@r%s@12g@b%c", TR("Classe"), _lettivd);
  else
    set_row(r, "@0g%s@12g%c", TR("Classe"), _lettivd);
  set_row(r, "@14g%-8s",(const char*) _numrivd); 
  if (_numivd != 0)
    set_row(r, "@23g%d", _numivd); 
  if (descriz2 != "")
  {
    set_row(r,"@27g%-50s",(const char*) descriz2);
    set_row(r++,"@80g%-50s",(const char*) descriz);                                                  
  }
  else
    set_row(r++,"@27g%-50s",(const char*) descriz);
  
  dataini = _data_ini.string();
  datafine = _data_fine.string();

  if (_annomsk == 0)
  {                              
    if (_nummast == 3)
    {
      set_row (r, "@r%s@12g@b%s", TR("Periodo"), (const char*) dataini);
      set_row (r, "@24g%s@r", (const char*) datafine);    
    }
    else
    {
      set_row (r, "%s@12g%s", TR("Periodo"), (const char*) dataini);
      set_row (r, "@24g%s", (const char*) datafine);
    }
  }
  else
  {                        
    if (_nummast == 3)
    {
      set_row (r, "@r%s@23g@b%s", TR("Periodo di competenza"), (const char*) dataini);
      set_row (r, "@35g%s@r", (const char*) datafine);    

      if (_cdc.not_empty())
      {                                                                           
        const TString& desc_cdc = cache().get("CMS", _cdc, "S0");                     
        if (_fsc.not_empty())
        {
          const TString& desc_fsc = cache().get("FSC", _fsc, "S0");                     
          set_row(++r, FR("@bCommessa %s %s - Fase %s %s"), 
                     (const char*)_cdc, (const char*)desc_cdc,
                     (const char*)_fsc, (const char*)desc_fsc);
        }
        else
          set_row(++r, FR("@bCommessa %s %s"), (const char*)_cdc, (const char*)desc_cdc);
      }
    }
    else
    {
      set_row (r, "%s@23g%s", TR("Periodo di competenza"), (const char*) dataini);
      set_row (r, "@35g%s", (const char*) datafine);
    }
  }
  return r;
}

const char* TMastrini_application::descrizione_classe(char sezione, char lettera, int numr, int numero)
{
  TString16 key;

  if (numr == 0 && numero == 0)
    key.format("%c%c",sezione,lettera);
  else                        
    if (numero == 0)
	    key.format("%c%c%04d",sezione, lettera, numr);
    else                                         
    {
      if (numr != 0)
        key.format("%c%c%04d%02d",sezione, lettera, numr,numero);
      else
        key.format("%c%c    %02d",sezione,lettera,numero);
    }
       
  return cache().get("%IVD", key, "S0");
}     

//Ricerca la descrizione relativa al gruppo da stampare

const char* TMastrini_application::descrizione_gruppo()
{  
	TString16 key;
	key.format("%d", _gruppo);

  return cache().get(LF_PCON, key, PCN_DESCR);
}

// Ricerca la descrizione relativa al conto da stampare

const char* TMastrini_application::descrizione_conto()
{ 
	TString16 key;
	key.format("%d|%d", _gruppo, _conto);

  return cache().get(LF_PCON, key, PCN_DESCR);
}

const char* TMastrini_application::descrizione_sottoconto()
{ 
	TString16 key;
	key.format("%d|%d|%ld", _gruppo, _conto, _sottoc);

  return cache().get(LF_PCON, key, PCN_DESCR);
}

// Funzione per settare tutti gli handlers della maschera principale
// o di quella dello spreadsheet della seconda pagina
void TMastrini_application::set_handlers(TMask* msk) const
{
  msk->set_handler(F_ANNO,               anno_hnd);
  msk->set_handler(F_DATAINI,            data_inizio);
  msk->set_handler(F_DATAFINE,           data_fine);
  msk->set_handler(F_GRUPPOFINE,         gruppo_hnd);
  msk->set_handler(F_TIPOCF_INI,         tipocf_hnd);
  msk->set_handler(F_TIPOCF_FINE,        tipocf_hnd);
  msk->set_handler(F_CONTOINI_CONTO,     contoi_hnd);
  msk->set_handler(F_CONTOFINE_CONTO,    contof_hnd);

  msk->set_handler(F_SOTTOCINI_CONTO,    sottoc_handler_ini);
  msk->set_handler(F_SOTTOCINI_CLIENTE,  sottoc_handler_ini);
  msk->set_handler(F_SOTTOCINI_FORN,     sottoc_handler_ini);
  msk->set_handler(F_SOTTOCFINE_CONTO,   sottoc_handler_fine);
  msk->set_handler(F_SOTTOCFINE_CLIENTE, sottoc_handler_fine);
  msk->set_handler(F_SOTTOCFINE_FORN,    sottoc_handler_fine);
  msk->set_handler(F_DACDC,   cdc_handler);
  msk->set_handler(F_ACDC,    cdc_handler);
}

// Copia i parametri della prima pagina in una nuova riga dello spreadsheet
// a meno che non ci siano gia'
bool TMastrini_application::mask2sheet()
{ 
  bool ok = _msk->check_fields();
  
  if (ok)
  {
    TToken_string row(120);
    short id = F_ANNO;
    for (int pos = _msk->id2pos(id); pos >= 0; pos = _msk->id2pos(++id))
      row.add(_msk->fld(pos).get());
    
    if (!row.empty_items())
    {
      TSheet_field& sht = (TSheet_field&)_msk->field(F_SCELTE);
      TString_array& rows = sht.rows_array();
      ok = rows.find(row) < 0; // Aggiunge solo se non c'e' gia'
      if (ok)              
      {
        rows.add(row);
        sht.force_update();
      }  
    }
  }
  
  return ok;  
}

bool TMastrini_application::sheet2mask()
{ 
  TSheet_field& sht = (TSheet_field&)_msk->field(F_SCELTE);
  bool ok = sht.items() > 0;
  if (ok)
  {
    TString_array& rows = sht.rows_array();
    TToken_string& row = rows.row(0);

    short id = F_ANNO;
    FOR_EACH_TOKEN(row, val)
    {
      // Scarta i listbox perche' azzerano i conti!
      if (id != F_TIPOCF_INI && id != F_TIPOCF_FINE)
        _msk->set(id, val);
      id++;  
    }

    rows.destroy(0, TRUE);
  }
  return ok;
}

bool TMastrini_application::user_create()
{
  TToken_string exp;

  _rel = new TRelation(LF_SALDI);
  _rel->lfile().set_curr(new TMastrini_record);

  exp.add("GRUPPO=GRUPPO");
  exp.add("CONTO=CONTO");
  exp.add("SOTTOCONTO=SOTTOCONTO");
  _rel->add(LF_RMOV,exp,2,LF_SALDI);
  
  _rel->add("CMS", "CODTAB==CODCMS", 1, LF_RMOV, 501);
  _rel->add("FSC", "CODTAB==FASCMS", 1, LF_RMOV, 502);

  _cur1=add_cursor(new TCursor(_rel,"FLSCA=\" \"",2)); 
  open_files(LF_TAB, LF_TABCOM,LF_NDITTE, LF_UNLOC, LF_COMUNI, LF_MOV,
						 LF_CLIFO, LF_CAUSALI, 0);
  _cur2=add_cursor(new TSorted_cursor(_rel,"DESCR","FLSCA=\" \"",2)); 
  
  _tabivd = new TTable (TAB_IVD);
  _tabtpd = new TTable (TAB_TPD);
  _tabreg = new TTable (TAB_REG);
  _sld    = new TSaldo ();
  
  _d18   = new TParagraph_string ("",18);
  _d22   = new TParagraph_string ("",22);
  _d30   = new TParagraph_string ("",30);
  
  _msk = new TMask("cg3200a");     
  set_handlers(_msk);
  _msk->set_handler(F_MEMORIZZA, memorizza_handler);
  
  TSheet_field& sht = (TSheet_field&)_msk->field(F_SCELTE);
  sht.set_notify(scelte_notify);
  TMask& sm = sht.sheet_mask();
  set_handlers(&sm);
    
  _gia_stampata_intestazione = FALSE;
  
  return TRUE;
}

bool TMastrini_application::user_destroy()
{
  delete _msk;
  delete _rel;
  delete _tabivd;
  delete _tabtpd;
  delete _tabreg;
  delete _sld;
  delete _d18;
  delete _d22;
  delete _d30;
  
  return TRUE;
}

int cg3200(int argc, char* argv[])
{
  TMastrini_application a;
  a.run(argc, argv, TR("Stampa Mastrini"));
  return 0;
}