campo-sirio/cg/cg4400.cpp

// cg4400.cpp
// Stampa tabella registri
#include "cg4.h"
#include "cg4400.h"
#include "cg4400a.h"

static TString256 TMP;

HIDDEN CG4400_application * app() { return (CG4400_application*) MainApp(); }

bool filter_func (const TRelation * r)
{
  TLocalisamfile * mov = r->lfile(LF_MOV);
  TString codreg  = mov->get(MOV_REG);
  TDate   datareg = mov->get_date(MOV_DATAREG);  
  int     annoiva = mov->get_int(MOV_ANNOIVA);
  
  if (codreg != (app()->_codreg) || annoiva != (app()->_annoes)) 
    return FALSE;           
  
  if (app()->_data_da.string() != "" && app()->_data_a.string() != "")
    if ( (datareg < app()->_data_da || datareg > app()->_data_a ) || (!datareg.ok()) )
      return FALSE;           
  
  return TRUE;
}

HIDDEN int compare_rows(const TObject** o1, const TObject** o2)
{
  TRiga* r1 = (TRiga*)*o1;
  TRiga* r2 = (TRiga*)*o2;
  
  return (strcmp((const char*)r1->_codiva, (const char*)r2->_codiva));
}

HIDDEN int compare(const TObject** o1, const TObject** o2)
{
  TRigaiva* r1 = (TRigaiva*)*o1;
  TRigaiva* r2 = (TRigaiva*)*o2;
  TString campo1;
  TString campo2;
  
  campo1.format("%d%4s", r1->_tipodet, (const char*)r1->_codiva); 
  campo2.format("%d%4s", r2->_tipodet, (const char*)r2->_codiva); 
  return (strcmp((const char*)campo1, (const char*)campo2));
}

/*
   bool CG4400_application::libro_giornale_iva_unico()
   {
   TConfig conf(CONFIG_DITTA);

   return conf.get("StLgiU") == "X";
   }
   */

bool mask_select (TMask_field& f, KEY k)
{
  long j, cnt, chk; int i;
  TString from = f.mask().get(DA_CODICE);
  TString to   = f.mask().get(A_CODICE);
  TBit_array selected = app()->_selected;
  
  // build sheet
  if (k == K_SPACE)
  { 
    f.mask().field(DA_CODICE).set("");
    f.mask().field(A_CODICE).set("");
    app()->_ditte->destroy(); chk = 0l;
    for (i = 0; i < app()->_nomiditte.items(); i++)
    {
      if (app()->_selected[i]) continue;
      TToken_string d = (const char*)((TToken_string&)app()->_nomiditte[i]);
      TString cod     = d.get(0);
      app()->_ditte->add(d);
      
      if (!from.empty() || !to.empty())
      {
        if (from.empty()) from = "0";
        if (to.empty()) to = "999999999";
        if (atol(cod) >= atol(from) && atol(cod) <= atol(to))
          app()->_ditte->check(chk++);
      }
    }
    // seleziona e aggiungi alle gia' selezionate 
    if (app()->_ditte->run() == K_ENTER)
    {
      cnt = 0;
      for (j = 0l; j < app()->_n_ditte; j++)
      {
        if (app()->_selected[j]) continue;
        if (app()->_ditte->checked(cnt++))
          selected.set(j);
      }
      app()->_selected |= selected;
      selected.reset();
    }
    long numd = app()->_selected.ones();
    f.mask().set(F_SELECT,numd);
  }
  return TRUE;
}       

bool mask_verifica (TMask_field& f, KEY k)
{
  int i;

  if (k == K_SPACE)
  {
    app()->_ditte->destroy();
    for (i = 0; i < app()->_nomiditte.items(); i++)
    {
      TToken_string d = (const char*)((TToken_string&)app()->_nomiditte[i]);
      app()->_ditte->add(d);
      if (app()->_selected[i]) app()->_ditte->check(i);
    }
    app()->_ditte->disable_check();
    app()->_ditte->run();
    app()->_ditte->enable_check(); 
  }
  return TRUE;
}

bool mask_annulla (TMask_field& f, KEY k)
{
  if (k == K_SPACE)
  {
    app()->_selected.reset();
    f.mask().set(F_SELECT, "0");
  }
  return TRUE;
}

bool mask_mese (TMask_field& f, KEY k)
{
  if (k == K_ENTER) 
  {
    int mese  = f.mask().get_int(MESE);
    int umese = f.mask().get_int(ULTIMO_MESE);

    if (mese != umese+1)
    { 
      f.warning_box ("Le stampe devono essere richieste mese per mese! I mesi successivi a %s non sono ancora stati stampati.", itom(umese));    
      return FALSE;
    }
  }
  return TRUE;
}

bool mask_cod (TMask_field& f, KEY k)
{ 
  TTable TabLbu ("%LBU");
  TString codtab; 
  int anno;
  
  //if ( (k == K_TAB) && f.mask().is_running() )  
  if ( (k == K_SPACE)||(k == K_TAB) )
  {
    TString codlib = f.mask().get(CODICE_LIB_UN);
    anno = f.mask().get_int(ANNO);
    
    TabLbu.zero();
    codtab.format ("%04d%-3s", anno, (const char*)codlib);
    TabLbu.put ("CODTAB", codtab);
    TabLbu.read();
    if ( TabLbu.good() )
    {
      // f.mask().set(MESE,TabLbu.get_long("I0")+1);
      f.mask().set(ULTIMO_MESE,TabLbu.get_long("I0"));
      f.mask().set(ULTIMA_PAGINA,TabLbu.get_long("I1"));
    }
  }
  return TRUE;
}

bool mask_data (TMask_field& f, KEY k)
{
  const short id = f.dlg();
  
  if (k == K_ENTER)
  {
    int anno = f.mask().get_int(ANNO);
    TDate data = f.mask().get(id);
    if (data.ok()) 
      if (data.year() != anno)
      {
        f.warning_box("L'anno delle date limite deve essere uguale all'anno iva specificato");
        return FALSE;
      }  
  } 
  return TRUE;
} 

/*
   bool mask_fino_a_mese (TMask_field& f, KEY k)
   { 
   if (k == K_ENTER)
   {
   TTable TabReg ("REG");
   TString16 codtab;
   int giorni_del_mese;
   TString codreg = f.mask().get(CODICE_LIBRO);
   int tipo       = f.mask().get_int(TIPO_STAMPA);
   int anno       = f.mask().get_int(ANNO);
   
   if ( (tipo == 1) || (tipo == 4) ) 
   { 
   int fino_a_mese = f.mask().get_int(FINO_A_MESE);
   if (fino_a_mese == 12)
   giorni_del_mese = 31;
   else
   {
   TDate primo = format("01/%02d/%4d", fino_a_mese+1, anno);
   --primo;
   giorni_del_mese = primo.day();
   }
   TDate datasup = format("%02d/%02d/%4d",giorni_del_mese,fino_a_mese,anno);       
   if (codreg != "")
   {
   TabReg.zero();
   codtab << anno << codreg;
   TabReg.put ("CODTAB", codtab);
   TabReg.read();
   if ( TabReg.good() )
   {
   TDate data = TabReg.get_date("D3");
   if (datasup < data)
   {
   TString16 datas = format("%02d/%4d", data.month(), data.year());
   f.warning_box ("La data specificata non deve essere inferiore al %s (ultima data di stampa specificata sul registro)", (const char*)datas);    
   return FALSE;
   }
   }
   }
   if (tipo == 4)
   {
   TabReg.zero();
   TabReg.put ("CODTAB", anno);
   TRectype r (TabReg.curr());
   TabReg.read(_isgteq);
   for (; !TabReg.eof(); TabReg.next())
   {
   if (TabReg.curr() != r) break;
   
   int tiporeg = TabReg.get_int("I0");
   if (tiporeg == 5) //libro giornale
   {    
   TDate data = TabReg.get_date("D3");
   if (datasup > data)
   {
   TString16 datas = format("%02d/%4d", data.month(), data.year());
   f.warning_box ("La data specificata non deve essere superiore al %s (ultima data di stampa del libro giornale)", (const char*)datas);    
   return FALSE;
   }
   }
   }
   } 
   }
   }
   return TRUE;
   }
   */

//da una SHEET non e' possibile mandare messaggi nella maschera!!!
HIDDEN bool my_handler (TMask_field& f, KEY k)
{
  if (k == K_TAB) 
  {
    TMask& m = f.mask();
    int stampa_su   = m.get_int(TIPO_STAMPA);
    if ( (stampa_su == 1) || (stampa_su == 4) ) 
    {  
      m.hide (CODICE_LIB_UN);
      m.hide (CODICE_LIBRO_PROVA);
      m.hide (MESE);
      m.hide (ULTIMO_MESE);
      m.hide (ULTIMA_PAGINA);
      m.hide (CODICE_LIBRO_IVA);
      m.hide (DATA_STAMPA);
      m.hide (DA_DATA);
      m.hide (A_DATA);
      m.show (CODICE_LIBRO);
      m.show (TIPO_RIEPILOGATIVO);
      m.show (FINO_A_MESE);
    }
    if (stampa_su == 2)
    {
      m.show (CODICE_LIB_UN);
      m.hide (CODICE_LIBRO_PROVA);
      m.show (MESE);
      m.show (ULTIMO_MESE);
      m.show (ULTIMA_PAGINA);
      m.show (CODICE_LIBRO_IVA);
      m.hide (DATA_STAMPA);
      m.hide (DA_DATA);
      m.hide (A_DATA);
      m.hide (CODICE_LIBRO);
      m.hide (TIPO_RIEPILOGATIVO);
      m.hide (FINO_A_MESE);       
    } 
    if (stampa_su == 3)
    {
      m.hide (CODICE_LIB_UN);
      m.hide (MESE);
      m.hide (ULTIMO_MESE);
      m.hide (ULTIMA_PAGINA);
      m.hide (CODICE_LIBRO_IVA);
      m.hide (CODICE_LIBRO);
      m.show (CODICE_LIBRO_PROVA);
      m.show (DATA_STAMPA);
      m.show (DA_DATA);
      m.show (A_DATA);
      m.hide (TIPO_RIEPILOGATIVO);
      m.hide (FINO_A_MESE);       
    } 
  }
  return TRUE;
} 

const char * CG4400_application::descr_doc(const char * tipo)
{
  TTable  tab_tpd("%TPD");
  TString codtab = format ("%-2s", tipo);
  
  tab_tpd.zero();
  tab_tpd.put("CODTAB", codtab);
  if (tab_tpd.read()==NOERR)
    TMP = tab_tpd.get("S0");
  else
    TMP = "";

  return TMP;
} 

const char * CG4400_application::descr_iva(const char * cod)
{
  TTable  tab_iva("%IVA");
  TString codtab = format ("%-4s", cod);
  
  tab_iva.zero();
  tab_iva.put("CODTAB", codtab);
  if (tab_iva.read()==NOERR)
    TMP = tab_iva.get("S0");
  else
    TMP = "";

  return TMP;
} 

const char * CG4400_application::desc_attivita(const char * codatt)
{
  TTable attiv ("%AIS");

  attiv.zero();
  attiv.put("CODTAB", codatt);
  if (attiv.read()==NOERR)
    TMP = attiv.get("S0");
  else
    TMP = "";
  return TMP;
}

const char * CG4400_application::ricerca_cf(char tipocf, long codcf)
{
  _clifo->zero();
  _clifo->put(CLI_TIPOCF, tipocf);
  _clifo->put(CLI_CODCF, codcf);
  if (_clifo->read() == NOERR)
    TMP = _clifo->get(CLI_RAGSOC);
  else
    TMP = "";
  return TMP;
}

const char * CG4400_application::ricerca_occ(const char * occ)
{
  TLocalisamfile occas (LF_OCCAS);

  occas.zero();
  occas.put(OCC_CFPI, occ);
  
  if (occas.read() == NOERR)
    TMP = occas.get(OCC_RAGSOC);
  else
    TMP = "";
  return TMP;
}

void CG4400_application::user_create()
{
  _nditte = new TLocalisamfile(LF_NDITTE);
  _ditte  = new TArray_sheet(-1, -1, 0, 0, "Selezione Ditte",
                             "@1|Cod.@5|Ragione Sociale@50");
  _n_ditte = 0l;
  for (_nditte->first(); !_nditte->eof(); _nditte->next())
  {
    TString cod  = _nditte->get("CODDITTA");
    _n_ditte++;
    TToken_string* d = new TToken_string(" ");
    d->add(cod);
    d->add(_nditte->get("RAGSOC"));
    _nomiditte.add(d);
  }
  _tab    = new TLocalisamfile(LF_TAB);
  _tabcom = new TLocalisamfile(LF_TABCOM);
  _tabreg = new TTable("REG");
  _tablbu = new TTable("%LBU");
  _tabinl = new TTable("%INL");
  _tablim = new TTable("LIM");
  _tabpim = new TTable("PIM");  
  _clifo  = new TLocalisamfile(LF_CLIFO);
  _occas  = new TLocalisamfile(LF_OCCAS);
  _rel    = new TRelation (LF_MOV);
  _rel->add(LF_CAUSALI,"CODCAUS=CODCAUS",1,LF_MOV);
  _rel->add(LF_RMOVIVA,"NUMREG=NUMREG",1,LF_MOV);
  _cur = new TCursor(_rel, "", 1);
  //_cur->set_filterfunction(filter_func);

  add_cursor(_cur);
  add_file(LF_MOV);
  add_file(LF_RMOVIVA);
}

void CG4400_application::user_destroy()
{
  delete _ditte;
  delete _nditte;
  delete _tab;
  delete _tabcom;
  delete _cur;
  delete _rel;
  delete _clifo;
}


void CG4400_application::calcola_progressivi(real& r0, real& r1, const char* codiva, const int tipocr) 
{
  TTable  pim ("PIM");  
  TString chiave;
  int i, num=0;
  
  if (_tipo_stampa == 1)
    num = _datareg.month();
  if ( (_tipo_stampa == 2) || (_tipo_stampa == 4) )  
    num = _fino_a_mese;
  
  if (_frequiva == 'T')
    for (i=3; i<num+3; i+=3)
    {
      chiave = "";
      chiave << _annoes << _codatt << _codreg << i << tipocr << codiva;
      pim.put("CODTAB", chiave);
      if (pim.read()==NOERR)
      {
        r0 += pim.get_real("R0");
        r1 += pim.get_real("R1");
      }
    }
  else //frequenza mensile
    for (i=1; i<=num; i++)
    {
      chiave = "";
      chiave << _annoes << _codatt << _codreg << i << tipocr <<codiva;
      pim.put("CODTAB", chiave);
      if (pim.read()==NOERR)
      {
        r0 += pim.get_real("R0");
        r1 += pim.get_real("R1");
      }
    }       
}

int CG4400_application::riga_rmoviva()
{ 
  TString  codiva;
  real     impo, impos, impop, imposp;
  int      tipodet, tipocr;    

  _cur->save_status();
  bool ok = _cur->is_first_match(LF_RMOVIVA);
  int nrec = 0;
  
  while (ok)
  {
    nrec++;
    TRectype iva (_cur->file(LF_RMOVIVA)->curr());
    tipodet = iva.get_int (RMI_TIPODET);
    tipocr  = iva.get_int (RMI_TIPOCR); 
    impo    = iva.get_real(RMI_IMPONIBILE);
    impos   = iva.get_real(RMI_IMPOSTA);
    codiva  = iva.get(RMI_CODIVA);
    
    impop = imposp = 0.00;
    _riga_rmi.add_riga(impo,impos,codiva,tipodet,impop,imposp);
    
    if (_tipo_reg == 2) //registro acquisti
    {
      if (_tipo_stampa != 3)  //stampa definitiva
        calcola_progressivi(impop,imposp,codiva,tipocr);
      _iva_array.add_riga(impo,impos,codiva,tipodet,impop,imposp);
    }
    
    impop = imposp = 0.00;
    if (_tipo_stampa != 3)
      calcola_progressivi(impop,imposp,codiva,tipocr); 
    
    _tot_iva_array.add_riga(impo,impos,codiva,impop,imposp);
    
    ok = _cur->next_match(LF_RMOVIVA);
  }
  _cur->restore_status();
  
  return nrec;   
}

int CG4400_application::setta_riga(int r, const TRigaiva& riga, real& tot1, 
                                   real& tot2, real& tot3, real& tot4)
{
  set_row(r, "%3s", (const char*)riga._codiva);
  TString descr = descr_iva(riga._codiva); 
  set_row(r, "@5g%s",(const char*)descr); 
  set_row(r, "@25g%r", &riga._imponibile);
  set_row(r, "@41g%r", &riga._imposta);
  if (_tipo_stampa != 3)
  {
    set_row(r, "@81g%r", &riga._imponibilep);
    set_row(r++, "@98g%r", &riga._impostap); 
  }
  else r++;
  tot1 += riga._imponibile;
  tot2 += riga._imposta;
  tot3 += riga._imponibilep;
  tot4 += riga._impostap;
  
  return r;
}

bool CG4400_application::controlla_liquidazione()
{
  TTable lim ("LIM");
  TTable pim ("PIM");
  TString16 mesi_ric = "";
  TString16 mesi_cal = "";
  TString16 chiave = "";
  int i;
  
  if (lim.empty()) 
    return yesno_box("Non esiste la tabella liquidazione iva mensile! Vuoi ugualmente continuare la stampa?");
  if (pim.empty())
    return yesno_box("Non esiste la tabella progressivi iva mensile! Vuoi ugualmente continuare la stampa?");

  if (_frequiva == 'T') //nella tabella LIM ho solo i mesi 3, 6, 9, 12
  {
    for (i=3; i<=_fino_a_mese+3; i+=3)
    {
      chiave = "";
      chiave << _annoes << i;
      lim.put("CODTAB", chiave);
      if (lim.read() == NOERR)
      {
        bool calcolato = lim.get_bool("B0"); 
        if (!calcolato)
          
          // return yesno_box("La liquidazione relativa al mese di %s deve essere ricalcolata. Vuoi ugualmente continuare la stampa?", itom(i) );         
          mesi_ric << itom(i) << "\n\r";
      }
      else 
        //  return yesno_box("La liquidazione relativa al mese di %s non e' stata calcolata. Vuoi ugualmente continuare la stampa?", itom(i) );
        mesi_cal << itom(i) << "\n\r";  
    }
  }                
  if (_frequiva == 'M')
  {
    for (i=1; i<=_fino_a_mese; i++);
  {
    chiave = "";
    chiave << _annoes << i;
    lim.put("CODTAB", chiave);
    if (lim.read() == NOERR)
    {
      bool calcolato = lim.get_bool("B0"); 
      if (!calcolato)
        // return yesno_box("La liquidazione relativa al mese di %s deve essere ricalcolata. Vuoi ugualmente continuare la stampa?", itom(i) );
        mesi_ric << itom(i) << "\n\r";         
    }
    else 
      // return yesno_box("La liquidazione relativa al mese di %s non e' stata calcolata. Vuoi ugualmente continuare la stampa?", itom(i) );  
      mesi_cal << itom(i) << "\n\r";       
  } 
  }
  if (mesi_ric.not_empty())
  {
    warning_box ("Deve essere ricalcolata la liquidazione relativa ai mesi di:\n %s ", (const char *)mesi_ric);
    return yesno_box("Vuoi ugualmente continuare la stampa?");
  }

  if (mesi_cal.not_empty())
  {
    warning_box ("La liquidazione relativa al mese di %s non e' stata calcolata", (const char *)mesi_cal);
    return yesno_box("Vuoi ugualmente continuare la stampa?");
  }       
  return TRUE;   
}

//controlla che i movimenti con data di registrazione compresa tra l'anno precedente e l'ultima data stampata siano tutti gia' stati stampati in forma definitiva*/ 
bool CG4400_application::controlla_mov()
{
  TLocalisamfile mov (LF_MOV);
  bool ok = TRUE;
  byte tipo;
  TDate udata; 
  TDate data = format("01/01/%4d", _annoes - 1);
  TRecnotype rec = _tabreg->recno();
  for (mov.first(); !mov.eof(); mov.next())
  {
    TString16 reg = mov.get(MOV_REG);
    TDate datareg = mov.get_date(MOV_DATAREG);
    if (_stampa_tutti_i_registri)
      cerca_reg (reg, tipo, udata);
    else udata = _data_da;   
    if ( (_stampa_tutti_i_registri && ((tipo == 1)||(tipo == 2)))
        || ((!_stampa_tutti_i_registri)&&(reg == _codreg)) )
      if ( (datareg >= data) && (datareg <= udata) )
      {  
        bool stampato = mov.get_bool(MOV_STAMPATO);
        long numreg   = mov.get_long(MOV_NUMREG);
        if (!stampato)
        {
          warning_box("Il movimento con numero di registrazione %ld non e' ancora stato stampato in forma definitiva!", numreg);
          ok = FALSE;
        }
      }  
  }
  _tabreg->readat(rec);
  return ok;
}

void CG4400_application::cerca_reg(const TString& c, byte& t, TDate& d)
{
  TString16 cod = "";
  
  cod << _annoes << c;
  _tabreg->zero();
  _tabreg->put("CODTAB", cod); 
  if (_tabreg->read() == NOERR)
  {
    t = _tabreg->get_int ("I0");
    d = _tabreg->get_date("D3");
  }
}

/*
   bool CG4400_application::controlla_mov()
   {
   bool ok = TRUE;
   
   if (_stampa_tutti_i_registri)
   {
   TRecnotype rec = _tabreg->recno();//la first l'ho gia' fatta 
   for (; !_tabreg->eof(); _tabreg->next())
   {  
   TString codtab = _tabreg->get("CODTAB");
   int anno = atoi(codtab.mid(0,4));
   if (anno != _annoes) break;
   
   TDate data_da    = _tabreg->get_date("D3");
   TString16 codreg = codtab.mid(4,3);
   leggi_movimenti(data_da, codreg, ok);
   }
   _tabreg->readat(rec);
   }
   else
   leggi_movimenti(_data_da, _codreg, ok);
   
   return ok;
   }

   void CG4400_application::leggi_movimenti(const TDate& d, const TString& cod, bool& ok)          
   {
   TLocalisamfile mov (LF_MOV);
   bool stampato;
   long numreg; 
   TString codreg;
   
   TDate data = format("01/01/%4d", _annoes - 1);
   mov.zero();
   TRectype a (mov.curr());
   mov.put(MOV_DATAREG, data); 
   a.put  (MOV_DATAREG, d);
   mov.read(_isgteq);
   while (mov.curr() < a && !mov.eof())
   {
   stampato = mov.get_bool(MOV_STAMPATO);
   numreg   = mov.get_long(MOV_NUMREG);
   codreg   = mov.get(MOV_REG);
   if (codreg == cod)
   if (!stampato)
   {
   warning_box("Il movimento con numero di registrazione %ld non e' ancora stato stampato in forma definitiva!", numreg);
   ok = FALSE;
   }
   mov.next();
   }  
   }
   */

void CG4400_application::set_page_tot_reg()
{
  TString riga(_stampa_width);
  int r=1, rr=0, row=0;
  real tot_imponib, tot_imposta, tot_imponibp, tot_impostap;
  
  riga.fill('-');
  set_row(r, "%s", (const char *) riga);
  r++;
  set_row(r, "Legenda Tipo Operazione:  1=operazione intracomunitaria  2=AF art.34 comma 3");  
  set_row(r, "@78g3=operazione intracomunitaria e AF art.34 comma 3");
  r++;
  set_row(++r, "Tipo documento@30gTotale documento");
  r+=2; 
  for (int j = 0; j < _doc_array.items(); j++)
  {
    TTipodoc& doc = (TTipodoc&)_doc_array[j];
    rr = r+j;
    set_row(rr, "%2s",      (const char*) doc._tipodoc);
    set_row(rr, "@3g%.25s", (const char*) doc._descrdoc);
    set_row(rr, "@29g%r",   &doc._totdoc); 
  }
  _doc_array.destroy();
  
  rr++;
  set_row(++rr, "@26g---------- P E R I O D O ----------");
  if (_tipo_stampa != 3)
    set_row(rr,"@82g------ P R O G R E S S I V I ------");
  rr++;
  set_row(rr, "Cod.");
  if (_tipo_reg == 2)
  {
    set_row(rr, "@36gA C Q U I S T I");
    if (_tipo_stampa != 3)
      set_row(rr, "@92gA C Q U I S T I");
  }
  if (_tipo_reg == 1)
  {
    set_row(rr, "@37gV E N D I T E");
    if (_tipo_stampa != 3)
      set_row(rr, "@93gV E N D I T E");
  }      
  rr++;
  set_row(rr, "iva Descrizione@30gImponibile@49gImposta");
  if (_tipo_stampa != 3)
    set_row(rr++, "@86gImponibile@106gImposta");
  else rr++;
  rr++;

  tot_imponib = tot_imposta = tot_imponibp = tot_impostap = 0.00;

  _tot_iva_array.sort(compare_rows);

  for (int k = 0; k < _tot_iva_array.items(); k++)
  {
    TRiga& riga = (TRiga&)_tot_iva_array[k];
    row = rr+k;
    set_row(row, "%3s",    (const char*)riga._codiva);
    TString descr = descr_iva(riga._codiva); 
    set_row(row, "@5g%s",  (const char*)descr); 
    set_row(row, "@25g%r", &riga._imponibile);
    set_row(row, "@41g%r", &riga._imposta);
    if (_tipo_stampa != 3)
    {
      set_row(row, "@81g%r", &riga._imponibilep);
      set_row(row, "@98g%r", &riga._impostap); 
    }  
    tot_imponib  += riga._imponibile;
    tot_imposta  += riga._imposta;
    tot_imponibp += riga._imponibilep;
    tot_impostap += riga._impostap;
  }  
  _tot_iva_array.destroy();
  
  row++;
  set_row(++row, "TOTALE@25g%r@41g%r", &tot_imponib, &tot_imposta);
  if (_tipo_stampa != 3)
    set_row(row, "@81g%r@98g%r", &tot_imponibp, &tot_impostap);
  //la stampa "tipi di indetraibilita'" viene fatta solo per gli acquisti 
  if (_tipo_reg == 2)
  {
    row+=2;
    int tdetprec = -1;
    int rw = row;
    tot_imponib = tot_imposta = tot_imponibp = tot_impostap = 0.00;
    
    _iva_array.sort(compare);

    for (int s = 0; s < _iva_array.items(); s++)
    {
      TRigaiva& riga = (TRigaiva&)_iva_array[s];
      switch (riga._tipodet)
      {
      case 1: if (riga._tipodet != tdetprec)
      {    
        set_row(rw++, "----- Indetraibile su op.es. -----");
        set_row(rw, "Cod.");
        rw++;
        set_row(rw, "iva Descrizione@30gImponibile@49gImposta");
        if (_tipo_stampa != 3)
          set_row(rw++, "@86gImponibile@106gImposta"); 
        else rw++;
        rw++;
      }
              rw = setta_riga(rw, riga, tot_imponib, tot_imposta, tot_imponibp, tot_impostap);
              tdetprec = riga._tipodet;
              break;
            case 3: if (tdetprec == 1)
            {
              set_row(++rw, "TOTALE@25g%r@41g%r", &tot_imponib, &tot_imposta);
              if (_tipo_stampa != 3)
                set_row(rw, "@81g%r@98g%r", &tot_imponibp, &tot_impostap);
              tot_imponib = tot_imposta = tot_imponibp = tot_impostap = 0.00;
              rw+=2;
            }
              if (riga._tipodet != tdetprec)
              { 
                set_row(rw++, "----- Passaggi interni -----");
                set_row(rw, "Cod.");
                rw++;
                set_row(rw, "iva Descrizione@30gImponibile@49gImposta");
                if (_tipo_stampa != 3)
                  set_row(rw++, "@86gImponibile@106gImposta");
                else rw++;    
                rw++;
              }
              rw = setta_riga(rw, riga, tot_imponib, tot_imposta, tot_imponibp, tot_impostap);
              tdetprec = riga._tipodet;
              break;
            case 9: if ( (tdetprec == 1) || (tdetprec == 3) )
            {
              set_row(++rw, "TOTALE@25g%r@41g%r", &tot_imponib, &tot_imposta);
              if (_tipo_stampa != 3)
                set_row(rw, "@81g%r@98g%r", &tot_imponibp, &tot_impostap); 
              tot_imponib = tot_imposta = tot_imponibp = tot_impostap = 0.00;
              rw+=2;
            }
              if (riga._tipodet != tdetprec)
              {  
                set_row(rw++, "----- N.D. 9 - acquisti indeducibili per ART.19 -----");
                set_row(rw, "Cod.");
                rw++;
                set_row(rw, "iva Descrizione@30gImponibile@49gImposta");
                if (_tipo_stampa != 3)
                  set_row(rw++, "@86gImponibile@106gImposta");
                else rw++; 
                rw++;
              }
              rw = setta_riga(rw, riga, tot_imponib, tot_imposta, tot_imponibp, tot_impostap);
              tdetprec = riga._tipodet; 
              break;
            default: break;                         
            }
    }
    if (tdetprec == 9)
    {
      set_row(++rw, "TOTALE@25g%r@41g%r", &tot_imponib, &tot_imposta);
      if (_tipo_stampa != 3)
        set_row(rw, "@81g%r@98g%r", &tot_imponibp, &tot_impostap);
    }
    _iva_array.destroy();
  }                            
}

bool CG4400_application::compila_reg(const TMask& m)
{       
  int anno;
  long codditta = _nditte->get_long("CODDITTA"); 
  TString16 codtab = ""; 
  
  _tipo_stampa = m.get_int(TIPO_STAMPA);
  if (_tipo_stampa == 2)  //stampa su libro unico di studio
    _codreg = m.get(CODICE_LIBRO_IVA);
  else if (_tipo_stampa == 3) //stampa di prova
    _codreg = m.get(CODICE_LIBRO_PROVA);        
  else _codreg = m.get(CODICE_LIBRO);
  
  if (_codreg.trim().empty())
  {
    _stampa_tutti_i_registri = TRUE;
    _tabreg->first(); 
    if (!_tabreg->eof()) 
    { 
      codtab  = _tabreg->get("CODTAB");
      anno    = atoi(codtab.mid(0,4));
      if (anno > _annoes) 
      {
        warning_box("Non esistono registri IVA della Ditta %ld per l'anno %d", 
                    codditta, _annoes);
        return FALSE;
      }
    }
  }  
  else   // stampa un solo registro
  {
    _stampa_tutti_i_registri = FALSE;
    codtab << _annoes << _codreg;         
    _tabreg->zero();
    _tabreg->put("CODTAB", codtab);
    if (_tabreg->read() == NOERR)
    {
      _tipo_reg        = _tabreg->get_int("I0");
      _pagine_stampate = _tabreg->get_int("I1");
      //_pagine_numerate = tab_reg.get_int("I2");
      //_stampa_ok       = tab_reg.get_int("I7");
      //_nprog_da        = tab_reg.get_long ("I6");
      //_tot_dare        = tab_reg.get_real ("R1")
      //_tot_avere       = tab_reg.get_real ("R2");
      if (_tipo_stampa != 3) 
        _data_da      = _tabreg->get_date ("D3");
      if ( _tipo_stampa == 1 || _tipo_stampa == 4 )
        if ( _data_a < _data_da)
        {
          TString16 datas = format("%02d/%4d", _data_da.month(), _data_da.year());
          warning_box ("La data specificata non deve essere inferiore al %s (ultima data di stampa specificata sul registro)", (const char*)datas);    
          return FALSE;
        }       
      //_stampa_intesta  = _tabreg->get_bool ("B9");
      _codatt          = _tabreg->get("S8");
      _attivita        = desc_attivita(_codatt);
      _desc_lib        = _tabreg->get ("S0");
    }
    else
    {
      warning_box("Il registro IVA specificato non esiste nella \n Ditta %ld", codditta);
      return FALSE;
    }
  }
  
  if (_tipo_stampa == 4)
  {
    TString app(4);
    _tabreg->zero();
    app = format("%04d", _annoes);
    _tabreg->put ("CODTAB", app);
    TRectype r (_tabreg->curr());
    _tabreg->read(_isgteq);
    for (; !_tabreg->eof(); _tabreg->next())
    {
      if (_tabreg->curr() != r) break;
      
      int tiporeg = _tabreg->get_int("I0");
      if (tiporeg == 5) //libro giornale
      {    
        TDate data = _tabreg->get_date("D3");
        if (_data_a > data)
        {
          TString16 datas = format("%02d/%4d", data.month(), data.year());
          warning_box ("La data specificata non deve essere superiore al %s (ultima data di stampa del libro giornale)", (const char*)datas);    
          return FALSE;
        }
      }
    }
  }
  
  return TRUE;
}

bool CG4400_application::compila_lib()
{       
  TTable tab_lib ("%LBU");
  TString16 cod;
  
  cod << _annoes << _codlib;
  tab_lib.zero();
  tab_lib.put("CODTAB", cod);
  
  if (tab_lib.read() == NOERR)
  {
    _stampa_ind_ditta = tab_lib.get_bool("B1");
    return TRUE;
  }
  return FALSE;
}

bool CG4400_application::preprocess_print(int file, int counter)
{ 
  if (file == LF_MOV)
  {       
    _iva_array.destroy();
    _riga_rmi.destroy();
    _tot_iva_array.destroy();
    _doc_array.destroy();
    _dataregp  = "";
    _mov_empty = TRUE;
    //_primast   = get_page_number();
    set_print_zero();
  }
  return TRUE;
} 

bool CG4400_application::preprocess_page(int file, int counter)
{ 
  if (file == LF_MOV)
  {
    if (counter) return TRUE;
    int rr = 0;
    TString ragsoc;
    TString tipo_op = "";

    TLocalisamfile* mov  = _cur->file(LF_MOV);
    TLocalisamfile* caus = _cur->file(LF_CAUSALI);

    //long      annoes = mov->get_long(MOV_ANNOES);
    //TString16 codreg = mov->get(MOV_REG); 
    _datareg = mov->get_date(MOV_DATAREG);
    
    //if (codreg != _codreg || annoes != _annoes) 
    //   return FALSE;
    
    //if (_data_da.string() != "" && _data_a.string() != "")
    //   if ( (_datareg < _data_da || _datareg > _data_a) || (!_datareg.ok()) )
    //      return FALSE;           
    
    _mov_empty = FALSE;

    //if ( (_tipo_stampa == 1) || (_tipo_stampa == 4) )
    if ( (_datareg.month() != _dataregp.month()) && (_dataregp.ok()) )
    {
      if (_tipo_stampa == 2)
        ++ _u_stampata;
      printer().formfeed();
    }
    
    _dataregp = _datareg;

    TDate   datadoc  = mov->get_date(MOV_DATADOC);
    long    numreg   = mov->get_long(MOV_NUMREG);
    long    protiva  = mov->get_long(MOV_PROTIVA);
    real    totdoc   = mov->get_real(MOV_TOTDOC);
    TString numdoc   = mov->get(MOV_NUMDOC);
    char    tipocf   = mov->get(MOV_TIPO)[0];
    TString ocfpi    = mov->get(MOV_OCFPI);
    long    codcf    = mov->get_long(MOV_CODCF);
    long    numgio   = mov->get_long(MOV_NUMGIO);
    bool    stampato = mov->get_bool(MOV_STAMPATO);
    bool    intra    = caus->get_bool(CAU_INTRACOM);
    bool    autof    = caus->get_bool(CAU_AUTOFATT);
    TString descrcau = caus->get(CAU_DESCR);
    
    //aggiornamento di mov
    if (_tipo_stampa != 3)
      if (!stampato)
      {
        mov->put(MOV_STAMPATO,TRUE);
        mov->rewrite();
      }      
    
    if ( intra && autof)
      tipo_op = "3";
    else if (intra) 
      tipo_op = "1";
    else if (autof)
      tipo_op = "2";
    
    if ( (tipocf == 'C') || (tipocf == 'F') )
    {
      if (ocfpi.trim().empty())
        ragsoc = ricerca_cf(tipocf, codcf);
      else
        ragsoc = ricerca_occ(ocfpi);
    }
    else ragsoc = descrcau;
    
    _tipodoc   = mov->get(MOV_TIPODOC);
    _descr_doc = descr_doc(_tipodoc);
    TString app = datadoc.string(2, '/');
    
    _doc_array.add_riga(_tipodoc,_descr_doc,totdoc); 

    //setto le righe di stampa
    _r = 1;
    set_row(_r, "%s",       (const char*) _datareg.string(2, '/'));
    set_row(_r, "@9g%5d",   protiva);
    set_row(_r, "@15g%s",   (const char*) app);
    set_row(_r, "@24g%s",   (const char*) numdoc);
    set_row(_r, "@32g%6d",  codcf);
    set_row(_r, "@39g%.28s",(const char*) ragsoc);
    set_row(_r, "@68g%s",   (const char*) tipo_op);
    set_row(_r, "@70g%2s",  (const char*) _tipodoc);
    set_row(_r, "@72g%r",   &totdoc);
    
    int nrec = riga_rmoviva();
    if (nrec > 0)
    {
      for (int j = 0; j < _riga_rmi.items(); j++)
      {
        TRigaiva& riga = (TRigaiva&)_riga_rmi[j];
        rr = _r+j;
        set_row(rr, "@87g%r",   &riga._imponibile);
        set_row(rr, "@102g%4s",(const char*)riga._codiva);
        if (_tipo_reg == 2)
          set_row(rr, "@107g%d",  riga._tipodet);
        set_row(rr, "@108g%r",  &riga._imposta);
      } 
      _riga_rmi.destroy();
    }
    int tipocr = _cur->file(LF_RMOVIVA)->get_int(RMI_TIPOCR);
    set_row(_r, "@124g%d",  tipocr);
    if (_tipo_stampa == 3) //stampa di prova
    {
      set_row(_r, "@125g%6d", numreg);
      if (stampato)
        set_row(_r, "@131g*");
    }
    if (_tipo_stampa == 4) //stampa con riferimento al libro giornale
      set_row(_r, "@125g%ld", numgio);
  }
  return TRUE;
}

void CG4400_application::aggiorna_reg()
{
  TString16 codtab; 
  TTable Tabreg ("REG");
  TTable TabInl ("%INL");
  long pag;
  //long stampate;
  
  const word ultimast = get_page_number();
  
  codtab << _annoes << _codreg;
  Tabreg.zero();
  Tabreg.put("CODTAB", codtab);  
  if (Tabreg.read() == NOERR)
  {
    //stampate = ultimast + 1;
    if (!_mov_empty) //cioe' se e' stata stampata almeno una pagina
    {
      pag = _pagine_stampate + ultimast;
      Tabreg.put("I1", pag);
    }  
    Tabreg.put("D3", _data_a);
    Tabreg.rewrite();
  }
  if (_tipo_stampa == 2) //stampa su libro unico
    //sulla tabella %inl (indice libro unico) devo generare una riga per ogni registro stampato
  {
    bool trovato  = FALSE;
    codtab = "";
    codtab << _annoes << _codlib;
    TabInl.zero();
    TRectype nuovo   (TabInl.curr());
    TRectype recprec (TabInl.curr());
    TabInl.put("CODTAB", codtab);
    
    TRectype rec (TabInl.curr());
    TabInl.read (_isgteq);
    for (; !TabInl.eof(); TabInl.next())
    { 
      if (TabInl.curr() != rec) break;
      
      trovato = TRUE;
      recprec = TabInl.curr();
    }
    
    TString cod = "";
    if (trovato)
    {  
      TString16 cod_inl = recprec.get("CODTAB");
      long numero_riga  = atol(cod_inl.mid(7,6)) + 1;
      TString16 num_riga (format("%6d", numero_riga));
      cod_inl = cod_inl.mid(0,7); 
      nuovo   = recprec;
      cod << cod_inl << num_riga;
    }
    else
    {
      TString16 num_riga ( format("%6d", 1L) );
      cod << codtab << num_riga;
    }
    
    long numini = _pagine_stampate + 1;
    nuovo.put("CODTAB", cod);
    nuovo.put("I0", (long)_annoes);
    nuovo.put("I1", (long)_fino_a_mese);
    nuovo.put("I2", (long)_u_stampata + 1);
    nuovo.put("I3", (long)(_u_stampata + ultimast));
    nuovo.put("I4", get_firm());
    nuovo.put("S0", _codreg);
    nuovo.put("I5", (long)numini);
    nuovo.put("I6", (long)(numini + ultimast));
    
    if (trovato)
      TabInl.rewrite(nuovo);
    else      
      TabInl.write(nuovo);
    
    _u_stampata  += ultimast;
  }
}

void CG4400_application::aggiorna_lib()
{
  TString16 cod = ""; 
  TTable lbu ("%LBU");
  
  cod << _annoes << _codlib;
  lbu.zero();
  lbu.put("CODTAB", cod);  
  if (lbu.read() == NOERR)
  {
    lbu.put("I0", (long) _fino_a_mese);
    lbu.put("I1", (long) _u_stampata - 1);
    lbu.rewrite();
  }
}

print_action CG4400_application::postprocess_page (int file, int counter)
{
  if (file == LF_MOV)
    if (!counter)
    {
      bool FINITO = FALSE;
      TRecnotype pos   = _cur->pos();
      long       items = _cur->items();
      
      FINITO = (pos == items-1);
      
      if ( FINITO )  
      {
        set_page_tot_reg();
        return REPEAT_PAGE;
      }
      else //if ( (_tipo_stampa == 1) || (_tipo_stampa == 4) )
      {
        TLocalisamfile* mov = _cur->file(LF_MOV);
        _cur->save_status();
        ++(*_cur);
        _dataregs = mov->get_date(MOV_DATAREG);
        --(*_cur);
        _cur->restore_status();

        if (_dataregs.month() != _dataregp.month())
        {
          set_page_tot_reg();
          return REPEAT_PAGE; 
        } 
      } 
    }
  return NEXT_PAGE;
}

print_action CG4400_application::postprocess_print(int file, int counter)
{
  if (file == LF_MOV)
  {
    //aggiorna registri solo se non e' stampa di prova
    if ( (_tipo_stampa != 3) && (!_stampa_tutti_i_registri) )
      aggiorna_reg();
    if (_stampa_tutti_i_registri)
      if (!_mov_empty )
      {
        if (_tipo_stampa == 2)
          ++ _u_stampata;
        printer().formfeed();
      }     
    /*
       if (_stampa_tutti_i_registri)
       {
       TString16 codtab;
       int anno, tipo;
       //vado avanti dal punto in cui sono
       _tabreg->next();
       for (; !_tabreg->eof(); _tabreg->next())
       { 
       tipo = _tabreg->get_int("I0");
       if ( (tipo == 1) || (tipo == 2) ) //registro iva
       {
       codtab = _tabreg->get("CODTAB");
       anno = atoi(codtab.mid(0,4));
       break;
       }  
       }
       if ( (_tabreg->eof()) || (anno != _annoes) )
       { 
       if (_tipo_stampa == 2) //stampa su libro unico
       aggiorna_lib();
       return NEXT_PAGE;
       }  
       else
       {
       _tipo_reg        = _tabreg->get_int("I0");
       _desc_lib        = _tabreg->get("S0");
       _data_da         = _tabreg->get_date("D3");
       _pagine_stampate = _tabreg->get_int("I1");
       _codreg          = codtab.mid(4,3);
       _primast         = get_page_number();
       if (!_mov_empty )
       printer().formfeed();
       _cur->set_filterfunction(NULL);
       _cur->set_filterfunction(filter_func);
       _mov_empty = TRUE;
       return REPEAT_PAGE;
       }
       }
       */
  }  
  
  return NEXT_PAGE;   
}

bool CG4400_application::set_print(int n)
{
  TMask m("cg4400a");
  int giorni_del_mese; 
  
  if (set_ditte(m))
    if (_selected.ones() > 0l)
    {
      _annoes      = m.get_int(ANNO);
      _tipo_stampa = m.get_int(TIPO_STAMPA);
      //Se stampa di prova l'utente indica data_da e data_a
      if (_tipo_stampa == 3)                            
      {
        _data_stampa = m.get(DATA_STAMPA);
        _data_da     = m.get(DA_DATA);
        _data_a      = m.get(A_DATA);
        if (!_data_da.ok())
          _data_da = format("01/01/%4d", _annoes);
        if (!_data_a.ok())
          _data_a = format("31/12/%4d", _annoes);
        printer().setdate(_data_stampa);
      }
      // senno' data_da e' letta dal registro
      else   //stampe definitive
      {
        if ( (_tipo_stampa == 1) || (_tipo_stampa == 4) )
          _fino_a_mese = m.get_int(FINO_A_MESE);
        else  //stampa su libro unico
        { 
          _codlib      = m.get(CODICE_LIB_UN);      
          _fino_a_mese = m.get_int(MESE);
          _u_stampata  = m.get_int(ULTIMA_PAGINA);
          //set_page_number(_u_stampata + 1);
        }     
        if (_fino_a_mese == 12)
          giorni_del_mese = 31;
        else
        {
          TDate primo = format("01/%02d/%4d", _fino_a_mese+1, _annoes);
          --primo;
          giorni_del_mese = primo.day();
        }
        _data_a=format("%02d/%02d/%4d",giorni_del_mese,_fino_a_mese,_annoes);
        // NB data_da viene letta nella preprocess_page
      }
      if (_tipo_stampa == 2)
        compila_lib();
      stampa_registri_IVA(m);
    }
else warning_box("Nessuna ditta selezionata!"); 
  return FALSE;
}

void CG4400_application::stampa_registri_IVA(const TMask& m) 
{
  long l;
  long firm = TApplication::get_firm();
  bool ok = FALSE;

  for (l = 0l, _nditte->first(); !_nditte->eof(); l++, _nditte->next())
  {
    if (_selected[l])
    {
      TApplication::set_firm(_nditte->get_long("CODDITTA"));
      ok = compila_reg(m);   // cerca il primo registro valido (nel caso di stampa tutti i registri), senno' legge i dati del registro specificato
      if (!ok) continue;
      if (!_stampa_tutti_i_registri)
        _cur->set_filterfunction(filter_func); 
      _frequiva = _nditte->get("FREQVIVA")[0];
      if (_tipo_stampa != 3) //stampa definitiva
        ok = controlla_liquidazione() && controlla_mov();

      if (!ok) continue;

      if (!_stampa_tutti_i_registri)
        print();
      else
      {
        TString16 codtab;
        int anno, tipo;
        for (_tabreg->first(); !_tabreg->eof(); _tabreg->next())
        { 
          tipo = _tabreg->get_int("I0");
          codtab = _tabreg->get("CODTAB");
          anno = atoi(codtab.mid(0,4));
          if (anno > _annoes)
            break;
          if ( (tipo == 1) || (tipo == 2) ) //registro iva
          {
            _tipo_reg        = _tabreg->get_int("I0");
            _desc_lib        = _tabreg->get("S0");
            if (_tipo_stampa != 3)
              _data_da      = _tabreg->get_date("D3");
            _pagine_stampate = _tabreg->get_int("I1");
            _codreg          = codtab.mid(4,3);
            _codatt          = _tabreg->get("S8");
            _attivita        = desc_attivita(_codatt);
            _desc_lib        = _tabreg->get ("S0");
            //_primast       = get_page_number();
            //if (!_mov_empty )
            //   printer().formfeed();
            _cur->set_filterfunction(NULL);
            _cur->set_filterfunction(filter_func);
            //set_page_number(_u_stampata + 1);
            print();
            if (_tipo_stampa != 3) aggiorna_reg();
          }  
        }
      }
      if (_tipo_stampa == 2)
        aggiorna_lib();
    }           
  }
  
  TApplication::set_firm(firm);
}

bool CG4400_application::set_ditte(TMask& m)
{
  _selected.reset();
  
  m.field(F_SELECT).set("0");
  m.field(DA_CODICE).set("");
  m.field(A_CODICE).set("");
  m.field(TIPO_STAMPA).set("1");
  
  m.set_handler (TIPO_STAMPA, my_handler);
  m.set_handler (DA_DATA, mask_data);
  m.set_handler (A_DATA,  mask_data); 
  m.set_handler (MESE,    mask_mese);
  //m.set_handler (FINO_A_MESE, mask_fino_a_mese);
  m.set_handler (CODICE_LIB_UN, mask_cod);
  m.set_handler (DLG_SELECT, mask_select);
  m.set_handler (F_ANNULLA,  mask_annulla);
  m.set_handler (F_VERIFICA, mask_verifica); 
  
  KEY tasto;     

  _stampa_width = 132;
  set_real_picture("###.###.###.###");

  tasto = m.run();

  //  m.first_focus(tasto);
  
  return tasto == K_ENTER;
}

int CG4400_application::stampa_intestazione_ditta()
{
  TDati_ditta tditta(get_firm(), _stampa_width);
  TString riga (tditta.prima_riga());
  int r=1;
  
  set_header (r, "%s", (const char *) riga);
  r++;

  riga = tditta.seconda_riga();

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

void CG4400_application::preprocess_header()
{
  int r=1;
  TString cor, nd1, nd2; 
  TString riga(_stampa_width);
  TString data;   
  
  if (_tipo_stampa != 3) //cioe' si tratta di una stampa definitiva
  { 
    if ( (_tipo_stampa == 1) || (_tipo_stampa == 4) )
      data.format("%s %s %d", (const char*)"mese di", itom(_datareg.month()), 
                  _datareg.year());
    else data.format("%s %s %d", (const char*)"mese di", itom(_fino_a_mese), _annoes);                
  }
else 
  data = _data_da.string();

  reset_header();

  if (_tipo_stampa == 2)
  {
    if (_stampa_ind_ditta)
      r = stampa_intestazione_ditta();
    long num = _u_stampata + 1;
    set_header(r++, "@94gProgr.Studio %ld@114gProgr.Utente @#", num);
  }
  else
    r = stampa_intestazione_ditta();
  set_header(r, "Registro IVA: %s %s   %s    Attivita\' %s %s",
             (const char *) _codreg, (const char *) _desc_lib, 
             (const char *) data, (const char *) _codatt,
             (const char *) _attivita);
  r++;

  riga.fill('-'); 
  set_header(r, riga);
  r++;
  if (_tipo_reg == 1)  //registro vendite
  {
    cor = "R";
    nd1 = "";
    nd2 = "";
  }  
  if (_tipo_reg == 2)
  { 
    cor = "C";
    nd1 = "N";
    nd2 = "D";
  }
  if (_tipo_stampa == 3) //stampa di prova
  {
    set_header(r,"@10gNum.@19gDocumento@68gT Tipo@103gCod %s@121g@124gT@128gNum",  (const char*) nd1);
    r++;
    set_header(r, "Data reg. prot.@17gData@25gNumero Codice Ragione sociale/descrizione@68gO Doc.@76gTotale doc.@91gImponibile  Iva %s@112gImposta@124g%s@128gReg", (const char*) nd2, (const char*) cor);
    r++;
  }
  else
  {
    set_header(r,"@10gNum.@19gDocumento@68gT Tipo@103gCod %s@121g@124gT", (const char*) nd1);
    if (_tipo_stampa == 4) //stampa definitiva con rif. al libro giornale
      set_header(r, "@128gNum."); 
    r++;
    set_header(r, "Data reg. prot.@17gData@25gNumero Codice Ragione sociale/descrizione@68gO Doc.@76gTotale doc.@91gImponibile  Iva %s@112gImposta@124g%s", 
               (const char*) nd2, (const char*) cor);
    if (_tipo_stampa == 4)
      set_header(r, "@128gop."); 
    r++;
  } 
  riga.fill('-'); 
  set_header(r, riga);
}

int cg4400 (int argc, char * argv[])
{
  CG4400_application a;
  a.run(argc, argv, "Stampa registri IVA");
  return 0;
}