diff --git a/sv/sv1200.cpp b/sv/sv1200.cpp
index 4cc332e3b..0b8865e2a 100755
--- a/sv/sv1200.cpp
+++ b/sv/sv1200.cpp
@@ -1,14 +1,21 @@
-#include <applicat.h>
+#include <printapp.h>
 #include <mask.h>
+#include <progind.h>
 #include <urldefid.h>
 #include <xvtility.h>
 
 #include "../mg/mglib.h"
 #include "sv1.h"
 #include "sv1200a.h"
+#include "sv1200b.h"
 #include "svlib01.h"
 
 #include "svriep.h"
+#include "svstat.h"
+#include "..\mg\umart.h"
+#include "..\mg\anamag.h"
+#include "..\pr\agenti.h"
+#include "..\ve\clifor.h"
 
 ///////////////////////////////////////////////////////////
 // TPeriodo
@@ -284,24 +291,56 @@ TDate TFrequenza_colonne::column_last_day(int n) const
 // Stampa statistiche
 ///////////////////////////////////////////////////////////
 
-class TStampa_stat : public TApplication
+class TStampa_stat : public TPrint_application
 {
-  enum { MAX_ROWS = 8 };
+  enum { MAX_ROWS = 8 }; // numero massimo di raggruppamenti
 
-  TMask* _msk;
+  enum { LINEA_DATI='D', LINEA_CONFRONTI='C', LINEA_TARGET='T'}; // codici per le righe
+
+  TMask * _msk,*_print_msk;
 
   TStats_agg _stats;
   TFrequenza_colonne _freq;
   TCodart_livelli* _liv_art;
   TCodgiac_livelli* _liv_giac;
+  TRecord_cache *_magazz,*_tipodoc,*_catven,*_zone,*_ums;
+  TLocalisamfile *  _umart,*_anamag,*_clifor,*_agenti;
+
+  TLocalisamfile *  _outstat;
+  
   TToken_string _key;
   TString _last_key;
+  TArray _files;
 
-protected:
-  virtual bool menu(MENU_TAG mt);
-  virtual bool create();
-  virtual bool destroy();
-  virtual void on_config_change();
+  bool _ragg_per_um;
+
+  TStat_cache * _cache;
+  
+  int         _last_lev_grp;
+  TArray      _group_recs;
+private:
+  const TString& partkey_name(const char *lev_code) ;
+  const TString& get_part(const char *lev_code, TSVriep_record & rieprec) const;
+  const TString& get_descrpart(const char *lev_code, TSVriep_record &rieprec);
+
+  void set_ragg_per_um();
+  
+  void put_column(TRectype & statrec,int col,TSVriep_record& curr);
+  const real fc_um(TRectype & statrec,const TSVriep_record& rieprec);
+  void invalid_columns(TRectype & statrec);
+  void standardize_um(TSVriep_record& rieprec, bool force=FALSE);
+
+  void azzera_file();
+  void update_file(const char * key, const char * code,const char tipo, const int level, const int col, TSVriep_record& curr);
+  void genera_file();
+  void esporta_file();
+
+  bool filtro_chiavi(TSVriep_record &curr);
+
+  // handler per i campi di maschera
+  static bool chiave_notify(TSheet_field& f, int r, KEY k);
+  static bool chiave_handler(TMask_field& f, KEY k);
+  static bool campo_handler(TMask_field& f, KEY k);
 
   static bool codice_handler(TMask_field& f, KEY k);
   static bool multiplo_handler(TMask_field& f, KEY k);
@@ -311,28 +350,316 @@ protected:
   static bool datafin_handler(TMask_field& f, KEY k);
   static bool raffronto_handler(TMask_field& f, KEY k);
   static bool dataraf_handler(TMask_field& f, KEY k);
+protected:
+  virtual bool user_create();
+  virtual bool user_destroy();
+  virtual bool set_print(int i);
+  virtual void set_page(int file, int count);
+  virtual bool preprocess_page(int file, int counter);
+  virtual print_action postprocess_page(int file, int counter);
+  virtual void preprocess_header();
+  virtual void preprocess_footer();
 
+  virtual void on_config_change();
+
+  void set_rows_colonne(int &row, TString & r, TRectype &strec);
+  
   bool test_field(const TString& cod, TMask_field& f) const;
 
-  static bool chiave_notify(TSheet_field& f, int r, KEY k);
-  static bool chiave_handler(TMask_field& f, KEY k);
-  static bool campo_handler(TMask_field& f, KEY k);
-  
-public:       
-  TMask& curr_mask() { return *_msk; }
+  void set_printmask();
+
   void fill_field_list(TMask& m);
   void set_frequency();
   bool set_column_frequency();
   bool recalc_period();
 
   TString& build_key(const TRectype& rec);
-  void genera_file();
+public:       
+  TMask& selmask() { return *_msk; }
+  TMask& printmask() { return *_print_msk; }
+  virtual bool menu(MENU_TAG);
 };
 
 inline TStampa_stat& app() { return (TStampa_stat&)main_app(); }
 
+bool TStampa_stat::preprocess_page(int file, int count)
+{
+  if (!file)
+  {
+    ;
+  }
+  return TPrint_application::preprocess_page(file,count);
+}
+
+print_action TStampa_stat::postprocess_page(int file, int count)
+{
+  if (!file)
+  {
+    return (_outstat->next()==NOERR) ? REPEAT_PAGE : NEXT_PAGE;
+  }
+  return TPrint_application::postprocess_page(file,count);
+}
+
+bool TStampa_stat::set_print(int i)
+{
+  _outstat->first();
+  bool ok=printmask().run() != K_QUIT;
+  return (ok);
+}
+
+#define LARG_COLCODICE  49
+#define POS_PRIMACOL  50
+#define PICTURE_VALORI "###.###.###.###"
+#define LARG_COLVAL 16 
+#define PICTURE_QUANTITA "###.###.###,###"
+#define LARG_COLQTA 16 
+#define PICTURE_PERCENT  "###.###.###,##"
+#define LARG_COLPERC 7 
+
+#define PICTURE   (*selmask().get(F_TIPODATO)=='V'? PICTURE_VALORI:PICTURE_QUANTITA)
+
+void TStampa_stat::set_page(int file, int count)
+{
+  // prepara la pagina di stampa 
+  const int max_rows=selmask().sfield(F_CHIAVE).items();
+  TRectype & strec=_outstat->curr();
+  const int level=strec.get_int(SVS_LIVELLO);
+
+  TString r;
+  int row=0;
+  
+  // *****************
+  // gestione totali di raggruppamento
+  while (level!=max_rows && level>_last_lev_grp)
+  {
+    // ho lasciato un livello "basso"
+    TRectype & rec_grp1=(TRectype &)_group_recs[_last_lev_grp+1];
+    TRectype & rec_grp2=(TRectype &)_group_recs[_last_lev_grp+2];
+    const int lencode=rec_grp2.get(SVS_CODICE).len();
+    r << "@" << (max_rows-_last_lev_grp)*2 <<"g";
+    r << "Totale " << partkey_name(rec_grp1.get(SVS_LEVCODE));
+    r << " " << rec_grp1.get(SVS_CODICE).mid(lencode);
+    set_rows_colonne(row, r ,rec_grp1);
+    _last_lev_grp++;
+    r = "";
+  }
+  if (_last_lev_grp!=strec.get_int(SVS_LIVELLO))
+    _last_lev_grp=strec.get_int(SVS_LIVELLO);
+  if (level>0)
+  {
+    // salva i record dei livelli di raggruppamento
+    if (level==max_rows)
+      strec.put(SVS_CODICE,"");
+    _group_recs.add(strec,level);
+  }
+
+  // *****************
+  // gestione delle "righe"
+  if (level != max_rows && *strec.get(SVS_TIPO)==LINEA_DATI)
+  {
+    TRectype & _rec_grp=(TRectype &)_group_recs[level+1];
+    const int lencode=_rec_grp.get(SVS_CODICE).len();
+    r << "@" << (max_rows-level)*2 <<"g";
+    r << partkey_name(strec.get(SVS_LEVCODE));
+    r << " " << strec.get(SVS_CODICE).mid(lencode);
+    if (level==0)
+    {
+      set_rows_colonne(row, r,strec);
+    } else {
+      reset_row(++row);
+      set_row(row,(const char *)r);
+    }
+  }
+  // *****************
+  // separatore di righe
+  if (printmask().get_bool(F_STRAFFRONTO)) 
+  {
+    reset_row(++row);
+    set_row(row,"");
+  }
+}
+
+// fa le set row per la "riga" contenente i valori delle colonne di statistica
+void TStampa_stat::set_rows_colonne(int &row,TString & r, TRectype &strec)
+{
+  //**********
+  // setta le colonne
+  TString colname,r1;
+  int largcolonna = *selmask().get(F_TIPODATO)=='V' ? LARG_COLVAL : LARG_COLQTA; // valori o quantità
+  const int max_rows=selmask().sfield(F_CHIAVE).items();
+  const bool sttotriga=printmask().get_bool(F_STTOTALIRIGA);
+  const int numcolonne = selmask().get_bool(F_PERIODO);
+  for (int col=0; col < numcolonne; col++) // colonne 
+  {
+    colname << SVS_COLNAME << col;
+    r << "@" << POS_PRIMACOL+col*(sttotriga ? largcolonna+LARG_COLPERC : largcolonna) <<"g";
+    r1=r;
+    switch (*printmask().get(F_TIPORAFFRONTO))
+    {
+      case AS_VALUE:
+        r << strec.get_real(colname).string(PICTURE);
+        break;
+      case AS_DIFF:
+        r << strec.get_real(colname).string(PICTURE);
+        break;
+      case AS_PERC:
+        r << strec.get_real(colname).string(PICTURE_PERCENT);
+        break;
+    }
+    // colonna con la percentuale rispetto al totale di riga
+    if (sttotriga) 
+    {
+      r << "@" << POS_PRIMACOL+col*(largcolonna+LARG_COLPERC)+largcolonna <<"g";
+      r << real(strec.get_real(colname)/strec.get_real(SVS_TOTALERIGA)*100.0).string(PICTURE_PERCENT);
+      r << "%%";
+    }
+    // riga con i totali di colonna
+    if (printmask().get_bool(F_STTOTALICOL)) 
+    {
+      TRectype & _rec_totale=(TRectype &)_group_recs[max_rows];
+      if (!_rec_totale.get_real(colname).is_zero())
+      {
+        r1 << real(strec.get_real(colname)/_rec_totale.get_real(colname)*100.0).string(PICTURE_PERCENT);
+        r1 << "%%";
+      }
+    }
+  }
+  // colonna totale di riga
+  if (sttotriga) 
+  {
+    r << "@" << POS_PRIMACOL+numcolonne*(largcolonna+LARG_COLPERC) <<"g";
+    r << strec.get_real(SVS_TOTALERIGA).string(PICTURE);
+    r << "@" << POS_PRIMACOL+numcolonne*(largcolonna+LARG_COLPERC)+largcolonna <<"g";
+    r << real(100).string(PICTURE_PERCENT);
+    r << "%%";
+  }
+  // *****************
+  // stampa la riga
+  reset_row(++row);
+  set_row(row,(const char *)r);
+  // *****************
+  // stampa totale di colonna
+  if (printmask().get_bool(F_STTOTALICOL)) 
+  {
+    reset_row(++row);
+    set_row(row,(const char *)r1);
+  }
+}
+
+
+void TStampa_stat::preprocess_header()
+{}
+
+void TStampa_stat::preprocess_footer()
+{}
+
+
+bool TStampa_stat::user_create()
+{ 
+  _print_msk= NULL;  
+  _msk = new TMask("sv1200a");                  
+  _msk->set_handler(F_CODICE, codice_handler);
+  _msk->set_handler(F_MULTIPLO, multiplo_handler);
+  _msk->set_handler(F_NUMERO, numero_handler);
+  _msk->set_handler(F_PERIODO, periodo_handler);
+  _msk->set_handler(F_DATAINI, dataini_handler);
+  _msk->set_handler(F_DATAFIN, datafin_handler);
+  _msk->set_handler(F_RAFFRONTO, raffronto_handler);
+  _msk->set_handler(F_DATARAF, dataraf_handler);
+  _msk->set_handler(F_CHIAVE, chiave_handler);
+  _msk->sfield(F_CHIAVE).set_notify(chiave_notify); 
+  
+  TMask& sm = _msk->sfield(F_CHIAVE).sheet_mask();
+  sm.set_handler(S_CAMPO, campo_handler);
+
+  _files.add(new TLocalisamfile(LF_SVRIEP));
+  _files.add(new TLocalisamfile(LF_SVSTAT));
+
+  // cache R/W per le statistiche   
+  _cache= new TStat_cache();
+
+  // oggetti per la gestione delle parti del codice
+  _liv_art = new TCodart_livelli;
+  _liv_giac = new TCodgiac_livelli;
+
+  _ums = new TRecord_cache("%UMS");
+  _tipodoc = new TRecord_cache("%NUM");
+  _catven = new TRecord_cache("CVE");
+  _zone = new TRecord_cache("ZON");
+
+  _umart = new TLocalisamfile(LF_UMART);
+  _anamag = new TLocalisamfile(LF_ANAMAG);
+  _clifor = new TLocalisamfile(LF_CLIFO);
+  _agenti = new TLocalisamfile(LF_AGENTI);
+  
+  _outstat = new TLocalisamfile(LF_SVSTAT);
+  // cursore di stampa
+  add_file(LF_SVSTAT);
+  //add_cursor(new TCursor(new TRelation(LF_SVSTAT)));
+
+  // impone force setpage
+  force_setpage();
+  set_real_picture("");
+
+  return TRUE;
+}
+
+bool TStampa_stat::user_destroy()
+{ 
+  delete _msk;
+  if (_print_msk) delete _print_msk;
+
+  delete _liv_art;
+  delete _liv_giac;          
+  // cancella le cache
+  delete _cache;
+  delete _ums;
+  // cancella i files
+  delete _umart;
+  delete _anamag;
+  delete _clifor;
+  delete _agenti;
+  delete _outstat;
+  return TRUE;
+} 
+
+
+bool TStampa_stat::menu(MENU_TAG )
+{
+  TMask& m = selmask();
+  TSheet_field& sheet = m.sfield(F_CHIAVE);
+  TString tmp;
+  KEY k;
+  while ((k = m.run()) != K_QUIT)
+  {     
+    set_column_frequency();
+    
+    _key.cut(0);
+    for (int r = 0; r < sheet.items(); r++)
+    {
+      tmp = sheet.row(r).get(0);
+      if (!tmp.blank())
+        _key.add(tmp);
+    }
+    
+    if (k == K_SAVE)
+    {
+      set_ragg_per_um();
+      genera_file();
+      esporta_file();
+    } else {
+      set_printmask();
+      do_print(1);
+    }
+  } 
+  return FALSE;
+}
+
+
+
 void TStampa_stat::fill_field_list(TMask& m)
 {                                  
+  // opzioni per il tipo di dato
   TList_field& tipoart = (TList_field&)m.field(F_TIPOART);
   TToken_string codes, descr;
   codes = "M|P";
@@ -344,6 +671,7 @@ void TStampa_stat::fill_field_list(TMask& m)
   }
   tipoart.replace_items(codes, descr);
 
+  // opzioni per i campi della chiave
   TSheet_field& s = m.sfield(F_CHIAVE);
   TMask& sm = s.sheet_mask();
 
@@ -381,6 +709,7 @@ void TStampa_stat::fill_field_list(TMask& m)
     list.add(row);
   }
   
+  list.add("U|Unita' di misura");  
   list.add("D|Tipo documento");  
   list.add("V|Categoria vendita");  
   list.add("C|Codice cliente");
@@ -393,7 +722,7 @@ void TStampa_stat::set_frequency()
 {                           
   TPeriodo::set_frequency(_stats.frequency());
 
-  TMask& m = curr_mask();   
+  TMask& m = selmask();   
 
   char freq[2] = { frequency2char(_stats.frequency()), '\0' };
   m.set(F_FREQUENZA, freq); 
@@ -408,8 +737,8 @@ void TStampa_stat::set_frequency()
     multiplo.enable();
     
   TToken_string std_codes("G|S|Q|1|2|3|4|6|A");
-  TToken_string std_descr("Giornaliera|Settimanale|Quindicinale|Mensile|"
-                          "Bimestrale|Trimestrale|Quadrimestrale|Semestrale|Annuale");
+  TToken_string std_descr("Giorni|Settimane|Quindicine|Mesi|"
+                          "Bimestri|Trimestri|Quadrimestri|Semestri|Anni");
     
   TToken_string codes(8), descr(80);
   switch(_stats.frequency())
@@ -437,6 +766,10 @@ void TStampa_stat::set_frequency()
   }
     
   multiplo.replace_items(codes, descr);
+
+  // setta la durata dell'anno
+  m.set(F_COL_ANNO, last_period(1992,_stats.frequency())); 
+
 }
 
 void TStampa_stat::on_config_change()
@@ -452,7 +785,7 @@ void TStampa_stat::on_config_change()
 
 bool TStampa_stat::set_column_frequency()
 {
-  const TMask& m = curr_mask();
+  const TMask& m = selmask();
   const TDate data_inizio = m.get(F_DATAINI);
   bool ok = data_inizio.year() >= 1900;
   if (ok)                      
@@ -492,87 +825,478 @@ TString& TStampa_stat::build_key(const TRectype& rec)
   return _last_key;
 }
 
+void TStampa_stat::update_file(const char * key, const char *lev_code,const char tipo, const int level, const int col, TSVriep_record& curr)
+{
+  CHECK(col>=0,"Le colonne partono da 0");
+
+  static TRectype statrec(LF_SVSTAT);
+  TToken_string cachekey(key);
+  cachekey.rtrim();
+  cachekey.add(tipo);
+  statrec = _cache->get(cachekey);
+  if (_cache->io_result()!=NOERR)
+  {
+    // nuovo record;
+    statrec.put(SVS_CODICE,key);         
+    statrec.put(SVS_LEVCODE,lev_code);
+    statrec.put(SVS_LIVELLO,level);
+    statrec.put(SVS_TIPO,tipo);
+    if (_msk->get(F_TIPODATO)=="Q")
+      statrec.put(SVS_UMQTA,curr.get(SVR_UMQTA));
+  }
+  if (*lev_code== 'T') // totale generale
+    statrec.put(SVS_DESCR,"Totale generale");
+  else
+    statrec.put(SVS_DESCR,get_descrpart(lev_code,curr).left(SVS_LEN_DESCR));
+  put_column(statrec,col,curr);
+  _cache->put(statrec);
+}
+
+// aggiorna la colonna del record statrec con i dati di SVriep
+void TStampa_stat::put_column(TRectype & statrec,int col,TSVriep_record& rieprec)
+{
+  real r,fc;
+  static TString colname("Rxx");
+  CHECK(col>=0,"Le colonne partono da 0");
+  colname=SVS_COLNAME;
+  colname << col;
+  r=statrec.get_real(colname);
+  if (_msk->get(F_TIPODATO)=="V")
+  {
+    r+=rieprec.get_real(SVR_VALORE);
+    statrec.put(colname,r);
+    statrec.put(SVS_TOTALERIGA,statrec.get_real(SVS_TOTALERIGA)+rieprec.get_real(SVR_VALORE));
+  } else {
+    if (statrec.get(SVR_UMQTA).not_empty())
+    {
+      if ((fc=fc_um(statrec,rieprec))==0.0)
+        invalid_columns(statrec);
+      else
+      {
+        r+=rieprec.get_real(SVR_QUANTITA)*fc;
+        statrec.put(colname,r);
+        statrec.put(SVS_TOTALERIGA,statrec.get_real(SVS_TOTALERIGA)+rieprec.get_real(SVR_QUANTITA)*fc);
+      }
+    } // no UM ? no valid data!
+  }
+}
+
+// Converte le UM scrivendo la nuova UM sul record e restituendo il fattore di conv.
+void TStampa_stat::standardize_um(TSVriep_record& rieprec, bool force)
+{
+  if (force || _ragg_per_um)
+  {
+    static TString um;
+    real fc;
+    if (rieprec.get(SVR_TIPOART)=="M")
+    {
+      // è un articolo (<M>erce); converto alla UM principale dell'art.
+      _umart->setkey(1);
+      _umart->put(UMART_CODART,rieprec.get(SVR_CODART));
+      _umart->put(UMART_NRIGA,1);
+      _umart->read();
+      um=_umart->get(UMART_UM);
+      fc=_umart->get_real(UMART_FC);
+    } else {
+      // non è un articolo: converte in base alla UM di riferimento in tabella
+      um=_ums->get(um).get("S7");
+      fc=_ums->get(um).get_real("R10");
+    }
+    if (um!=rieprec.get(SVS_UMQTA))
+    {
+      // conversione tra UM diverse
+      fc=fc*rieprec.get_real(SVR_QUANTITA);
+      rieprec.put(SVR_QUANTITA,fc);
+      rieprec.put(SVR_UMQTA,um);
+    }
+  } 
+}
+
+// aggiunge al valore passat la quantità del record riep, correggendola con il fattore di conv. necessario
+const real TStampa_stat::fc_um(TRectype & statrec,const TSVriep_record& rieprec) 
+{
+  static TString um;
+  real fc(1.0);
+  um=rieprec.get(SVR_UMQTA);
+  if (um!=statrec.get(SVS_UMQTA))
+  {
+    // converte in base alla UM di riferimento in tabella
+    if (rieprec.get(SVR_TIPOART)=="M")
+    {
+      // è un articolo (<M>erce)
+      _umart->setkey(2);
+      _umart->put(UMART_CODART,rieprec.get(SVR_CODART));
+      _umart->put(UMART_UM,rieprec.get(SVR_UMQTA));
+      if (_umart->read()==NOERR)
+      {
+        fc=_umart->get_real(UMART_FC);
+        _umart->put(UMART_UM,statrec.get(SVS_UMQTA));
+        if (_umart->read()==NOERR)
+        {
+          // è una UM dell'articolo: uso i fc per convertirla
+          um=_umart->get(UMART_UM);
+          fc=fc/_umart->get_real(UMART_FC);
+        }
+      } else 
+        fatal_box("Archivio $UMART inconsistente con $RDOC"); // altrimenti ... errore di inconsistenza!
+    }
+    if (um != statrec.get(SVS_UMQTA))
+    {
+      um=_ums->get(um).get("S7");
+      fc=_ums->get(um).get_real("R10");
+    }
+    if (um != statrec.get(SVS_UMQTA))
+    {
+      // impossibile associare al totale una unità di misura
+      fc = 0.0;
+    }
+  }
+  return fc;
+}
+
+// rende non validi i valori delle colonne
+void TStampa_stat::invalid_columns(TRectype & statrec)
+{
+  statrec.put(SVS_UMQTA,"");
+  char colname[9];
+  for (int col=0; col <SVS_NUMCOLONNE; col ++)
+  {
+    sprintf(colname,"%s%d",SVS_COLNAME,col);
+    statrec.put(colname,0);
+  }
+  statrec.put(SVS_TOTALERIGA,0);
+}
+
+
+bool TStampa_stat::filtro_chiavi(TSVriep_record &curr)
+{
+  TSheet_field & s_chiave = selmask().sfield(F_CHIAVE);
+  const int num_liv_output=s_chiave.items();
+  TString est1,est2;
+  bool ok=TRUE;
+  for (int l=0; ok && l< num_liv_output; l++)
+  {
+    static TString code_campo;
+    static TString val_stringa;
+    int val_intero;
+        
+    code_campo=s_chiave.cell(l,s_chiave.cid2index(S_CAMPO));
+    if (code_campo=="C") // cliente/fornitore ha in testa il TIPOCF
+      val_intero=atoi(get_part(code_campo,curr)+1);
+    else if (code_campo=="G") // agente è numerico
+      val_intero=atoi(get_part(code_campo,curr));
+    else 
+    {
+      val_stringa=get_part(code_campo,curr);
+      val_stringa.trim();
+    }
+    if (!(est1=s_chiave.cell(l,s_chiave.cid2index(S_DAL))).blank())
+    {
+      if (code_campo=="C" || code_campo=="G") // cliente/fornitore o agente sono numerici
+        ok &= val_intero>=atoi((const char *)est1);
+      else
+        ok &= val_stringa>=est1;
+    }
+    if (ok && !(est2=s_chiave.cell(l,s_chiave.cid2index(S_AL))).blank())
+    {
+      if (code_campo=="C" || code_campo=="G") // cliente/fornitore o agente sono numerici
+        ok &= val_intero<=atoi((const char *)est2);
+      else
+        ok &= val_stringa<=est2;
+    }    
+  }
+  return ok;
+}
+
+
+// ritorna se la query è suddivisa per unità di misura
+void TStampa_stat::set_ragg_per_um()
+{
+  TSheet_field & s_chiave = selmask().sfield(F_CHIAVE);
+  for (int l=0; l< s_chiave.items(); l++)
+  {
+    if (*s_chiave.cell(l,s_chiave.cid2index(S_CAMPO))=='U')
+    {
+      _ragg_per_um=FALSE;
+      return;
+    }
+  }
+  _ragg_per_um=TRUE;
+}
+
 void TStampa_stat::genera_file()
 {
-  const TMask& m = curr_mask();
-  const int first = -m.get_int(F_RAFFRONTO);
-  const int columns = m.get_int(F_PERIODO);
+
+  const TMask& m = selmask();
+  const char alg=m.get(F_TIPOCALC)[0];
+  const int columns = m.get_int(F_PERIODO);  //numero di colonne osservate
+  const int col_anno =m.get_int(F_COL_ANNO);  //numero di colonne che formano un "Anno"
+  const int first_col = - (alg=='M' ? col_anno-1:0);      // prima colonna dati da osservare
+  const int first_raffr = -m.get_int(F_RAFFRONTO)- (alg=='M' ? col_anno-1:0);// prima colonna dati da confrontare
+  const int first_data = first_raffr ;       // prima colonna dati 
+  TSheet_field & s_chiave = m.sfield(F_CHIAVE);
+
 
   TLocalisamfile riep(LF_SVRIEP);
-  TRectype& curr = riep.curr();
+  riep.set_curr(new TSVriep_record);
+  
+  TSVriep_record& curr = (TSVriep_record&)(riep.curr());
   const TRecfield fr_anno(curr, SVR_ANNO);
   const TRecfield fr_periodo(curr, SVR_PERIODO);
   
-  for (int err = riep.first(); err == NOERR; err = riep.next())
+  curr.put(SVR_ANNO,m.get_date(F_DATARAF).year());
+  curr.put(SVR_PERIODO,_stats.date2period(m.get_date(F_DATARAF)));
+  int err = riep.read(_isgteq);
+  
+  const int num_liv_output=s_chiave.items();
+  const long start_status=period2long(curr.get_int(SVR_ANNO),curr.get_int(SVR_PERIODO),_stats.frequency());
+  
+  TProgind statusbar(date2long(m.get_date(F_DATAFIN),_stats.frequency())-start_status
+    , "Creazione del file di output", FALSE, TRUE, 60);
+
+  azzera_file();  
+  _cache->clear();
+
+  // **********************
+  // ciclo principale: scorre il riepilogo statistiche per anno+periodo
+  // e genera i risultati in una cache
+
+  for (; err == NOERR && 
+    (curr.get_int(SVR_ANNO)<=m.get_date(F_DATAFIN).year() || 
+    (curr.get_int(SVR_ANNO)==m.get_date(F_DATAFIN).year() && 
+    curr.get_int(SVR_PERIODO)<=_stats.date2period(m.get_date(F_DATAFIN))))
+      ; err = riep.next())
   {
-    const TPeriodo periodo(fr_anno, fr_periodo);
-    int col = _freq.period2column(periodo);
-    if (col >= first && col < columns)
+    statusbar.setstatus(period2long(curr.get_int(SVR_ANNO),curr.get_int(SVR_PERIODO),_stats.frequency())-start_status);
+
+    if (filtro_chiavi(curr))
     {
-    }
-  }
+      const TPeriodo periodo(fr_anno, fr_periodo);
+      const int col = _freq.period2column(periodo);
+      
+      if (col >= first_data && col < columns)
+      {
+        standardize_um(curr); //!?!? eventualmente sarebbe utile forzare l'uso della standard se è una riga non comprendente l'articolo
+        // costruisce il file statistiche...
+        TString key,um;
+        for (int l=0; l< num_liv_output; l++)
+        {
+          static TString lev_code;
+          lev_code=s_chiave.cell(l,s_chiave.cid2index(S_CAMPO));
+          key << get_part(lev_code,curr);
+          // setta il ragne in base all'algoritmo (Valori/progressivi/mobili)
+          const int range=(alg=='V'? col : alg=='P' ? ((1+int(col/col_anno))*col_anno-1) : (col+col_anno-1));
+          if (col>=first_col) // periodo da osservare
+          {
+            if (l==0)     
+              for (int c=max(col,0);c <= range ; c++)
+                update_file(" Totale","T",LINEA_DATI,num_liv_output,c,curr);
+            if (*s_chiave.cell(l,s_chiave.cid2index(S_TOTALE))=='X')
+              for (int c=max(col,0);c <= range ; c++)
+                update_file(key,lev_code,LINEA_DATI,num_liv_output-l-1,c,curr);
+          }
+          if (first_raffr !=first_col  && col >= first_raffr &&  col<=first_raffr+columns) // periodo da confrontare
+          {
+            if (l==0) 
+              for (int c=max(col,0); c <= range; c++)
+                update_file(" Totale","T",LINEA_CONFRONTI, num_liv_output , c -first_raffr,curr);
+            if (*s_chiave.cell(l,s_chiave.cid2index(S_TOTALE))=='X')
+              for (int c=max(col,0); c <= range; c++)
+                update_file(key,lev_code,LINEA_CONFRONTI,num_liv_output-l-1, c -first_raffr , curr);
+          }
+        }
+      }
+    } // filtro
+  } // ciclo 
+  statusbar.setstatus(date2long(m.get_date(F_DATAFIN),_stats.frequency())-start_status);
+  _cache->flush();
 }
 
-bool TStampa_stat::menu(MENU_TAG)
+
+void TStampa_stat::set_printmask()
 {
-  TMask& m = curr_mask();
-  TSheet_field& sheet = m.sfield(F_CHIAVE);
-  TString tmp;
-  KEY k;
-  while ((k = m.run()) != K_QUIT)
-  {     
-    set_column_frequency();
-    
-    _key.cut(0);
-    for (int r = 0; r < sheet.items(); r++)
-    {
-      tmp = sheet.row(r).get(0);
-      if (!tmp.blank())
-        _key.add(tmp);
-    }
-    
-    genera_file();
+  TMask  &mp=selmask();
+  
+  if (_print_msk) delete _print_msk;
+  _print_msk= new TMask("sv1200b");
+
+  const nlivelli=mp.sfield(F_CHIAVE).items();  
+  TString80 nomeliv;
+  for (int f=0; f<nlivelli; f++)
+  {
+    nomeliv="Stampa totale ";
+    nomeliv << partkey_name(mp.sfield(F_CHIAVE).cell(f,mp.sfield(F_CHIAVE).cid2index(S_CAMPO)));
+    printmask().add_boolean(F_FLAGSTOTALI+f, 0 ,nomeliv,2+36*int(f/(18-Y_FLAGSTOTALI)),Y_FLAGSTOTALI+(f% (18-Y_FLAGSTOTALI)));
+  }
+  if (mp.get_date(F_DATARAF).empty())
+  {
+    printmask().field(F_STRAFFRONTO).disable();
+    printmask().field(F_TIPORAFFRONTO).disable();
   }
-  return FALSE;
 }
 
-bool TStampa_stat::create()
-{ 
-  _msk = new TMask("sv1200a");                  
-  _msk->set_handler(F_CODICE, codice_handler);
-  _msk->set_handler(F_MULTIPLO, multiplo_handler);
-  _msk->set_handler(F_NUMERO, numero_handler);
-  _msk->set_handler(F_PERIODO, periodo_handler);
-  _msk->set_handler(F_DATAINI, dataini_handler);
-  _msk->set_handler(F_DATAFIN, datafin_handler);
-  _msk->set_handler(F_RAFFRONTO, raffronto_handler);
-  _msk->set_handler(F_DATARAF, dataraf_handler);
-  _msk->set_handler(F_CHIAVE, chiave_handler);
-  _msk->sfield(F_CHIAVE).set_notify(chiave_notify); 
-  
-  TMask& sm = _msk->sfield(F_CHIAVE).sheet_mask();
-  sm.set_handler(S_CAMPO, campo_handler);
-  
-  _liv_art = new TCodart_livelli;
-  _liv_giac = new TCodgiac_livelli;
-                                   
-  dispatch_e_menu(BAR_ITEM(1));
-  return TRUE;
+void TStampa_stat::esporta_file()
+{}
+
+
+void TStampa_stat::azzera_file()
+{
+  TLocalisamfile stat(LF_SVSTAT);
+  int err=NOERR;
+  while (err==NOERR)
+  {
+    err=stat.first();
+    if (err==NOERR) 
+      err=stat.remove();
+  }
+}
+
+
+
+const TString& TStampa_stat::partkey_name(const char *lev_code) 
+{
+  static TString park(' ',25);
+  int lev_code_num=atoi(lev_code+1);
+  switch (*lev_code)
+  {
+    case 'D': // tipo documento
+      park="tipo documento";
+      break;
+    case 'A': // articolo
+      if (lev_code_num)
+        park =_liv_art->name(lev_code_num);
+      else
+        park="articolo";
+      break;
+    case 'L': // liv giac
+      CHECK(lev_code_num>0,"I livelli di giacenza sono utilizzabili solo singolarmente");
+      park =_liv_giac->name(lev_code_num);
+      break;
+    case 'V': // cat. vendita
+      park="categoria di vendita";
+      break;
+    case 'C': // cliente / fornitore
+      park="cliente";
+      break;
+    case 'G': // agente
+      park="agente";
+      break;
+    case 'M': // mag
+      park="magazzino";
+      break;
+    case 'Z': // zona
+      park="zona";
+      break;
+    case 'U': // unità di misura
+      park="unita' di misura";
+      break;
+    default:
+      fatal_box("ai chent recognaiz the code of the key part!");
+      return "";
+  }
+  return park;
+}
+
+
+const TString& TStampa_stat::get_part(const char *lev_code, TSVriep_record &rieprec) const
+{
+  static TString park(' ',25);
+
+  int lev_code_num=atoi(lev_code+1);
+  switch (*lev_code)
+  {
+    case 'D': // tipo documento
+        return rieprec.get(SVR_TIPODOC);
+    case 'A': // articolo
+      if (lev_code_num==0)
+      {
+        park=rieprec.get(SVR_CODART);
+        return park.rpad(25);
+      }
+      else
+      {
+        park =_liv_art->unpack_grpcode(rieprec.get(SVR_CODART),lev_code_num);
+        return park.rpad(_liv_art->code_length(lev_code_num));
+      }
+    case 'L': // liv giac
+      CHECK(lev_code_num>0,"I livelli di giacenza sono utilizzabili solo singolarmente");
+      park = _liv_giac->unpack_grpcode(rieprec.get(SVR_GIAC),lev_code_num);
+      return park.rpad(_liv_giac->code_length(lev_code_num));
+    case 'V': // cat. vendita
+      park=rieprec.get(SVR_CATVEN);
+      return park.rpad(3);
+    case 'C': // cliente / fornitore
+      park.format("%c%6d",rieprec.get_char(SVR_TIPOCF),rieprec.get_int(SVR_CODCF));
+      return park;
+    case 'G': // agente
+      park.format("%5d",rieprec.get_int(SVR_CODAG));
+      return park;
+    case 'M': // mag
+      park=rieprec.get(SVR_MAG);
+      return park.rpad(3);
+    case 'Z': // zona
+      park=rieprec.get(SVR_ZONA);
+      return park.rpad(3);
+    case 'U': // unità di misura
+      park=rieprec.get(SVR_UMQTA);
+      return park.rpad(3);
+    default:
+      fatal_box("ai chent recognaiz the code of the key part!");
+      return "";
+  }
+}
+
+const TString& TStampa_stat::get_descrpart(const char *lev_code, TSVriep_record &rieprec)
+{
+  int lev_code_num=atoi(lev_code+1);
+  switch (*lev_code)
+  {
+    case 'D': // tipo documento
+      return _tipodoc->get(rieprec.get(SVR_TIPODOC)).get("S0");
+    case 'A': // articolo
+      if (lev_code_num==0 || lev_code_num== _liv_art->last_level())
+      {
+        _anamag->put(ANAMAG_CODART,rieprec.get(SVR_CODART));
+        _anamag->read();
+        return _anamag->get(ANAMAG_DESCR);
+      }
+      else
+      {
+        return _liv_art->group_descr(rieprec.get(SVR_CODART),lev_code_num);
+      }
+    case 'L': // liv giac
+      CHECK(lev_code_num>0,"I livelli di giacenza sono utilizzabili solo singolarmente");
+      return _liv_giac->group_descr(rieprec.get(SVR_GIAC),lev_code_num);
+    case 'V': // cat. vendita
+      return _catven->get(rieprec.get(SVR_CATVEN)).get("S0");
+    case 'C': // cliente
+    {
+      _clifor->put(CLI_TIPOCF,rieprec.get_char(SVR_TIPOCF));
+      _clifor->put(CLI_CODCF,rieprec.get_int(SVR_CODCF));
+      _clifor->read();
+      return _clifor->get(CLI_RAGSOC);
+    }
+    case 'G': // agente
+      _agenti->put(AGE_CODAGE,rieprec.get(SVR_CODAG));
+      return _agenti->get(AGE_RAGSOC);
+    case 'M': // mag
+      return _magazz->get(rieprec.get(SVR_MAG)).get("S0");
+    case 'Z': // zona
+      return _zone->get(rieprec.get(SVR_ZONA)).get("S0");
+    case 'U': // Unità di misura
+      return _ums->get(rieprec.get(SVR_UMQTA)).get("S0");
+    default:
+      fatal_box("ai chent recognaiz the code of the key part!");
+      return "";
+  }
 }
 
-bool TStampa_stat::destroy()
-{ 
-  delete _liv_art;
-  delete _liv_giac;          
-  delete _msk;
-  return TRUE;
-} 
 
 bool TStampa_stat::recalc_period()
 {   
   bool ok = set_column_frequency();
   
-  TMask& m = curr_mask();
+  TMask& m = selmask();
   if (ok)
   {
     TDate data(m.get(F_DATAFIN));
@@ -771,6 +1495,16 @@ bool TStampa_stat::test_field(const TString& cod, TMask_field& f) const
   
   switch(cod[0])  
   {              
+  case 'A': 
+    if (cod[1] != '\0' && !_liv_art->enabled())
+      ok = f.error_box("I livelli di codice articolo non sono abilitati");
+    break;  
+  case 'L': 
+    if (!_stats.grp_giacenza())
+      ok = f.error_box("Le statistiche sono raggruppate per livello di giacenza");
+    else if (!_liv_giac->enabled())
+      ok = f.error_box("I livelli di giacenza non sono abilitati");
+    break;  
   case 'C': 
     if (!_stats.grp_cliente())
       ok = f.error_box("Le statistiche sono raggruppate per cliente");
@@ -779,10 +1513,6 @@ bool TStampa_stat::test_field(const TString& cod, TMask_field& f) const
     if (!_stats.grp_agente())
       ok = f.error_box("Le statistiche sono raggruppate per agente");
     break;  
-  case 'L': 
-    if (!_stats.grp_giacenza())
-      ok = f.error_box("Le statistiche sono raggruppate per livello di giacenza");
-    break;  
   case 'M': 
     if (!_stats.grp_magazzino())
       ok = f.error_box("Le statistiche sono raggruppate per magazzino");
@@ -848,7 +1578,7 @@ bool TStampa_stat::campo_handler(TMask_field& f, KEY k)
 
 int sv1200(int argc, char* argv[])
 {
-  TStampa_stat app;
-  app.run(argc, argv, "Stampa statistiche");
+  TStampa_stat mainapp;
+  mainapp.run(argc, argv, "Stampa statistiche");
   return 0;
 }