campo-sirio/cg/cg3100.cpp

//Lista movimenti

#include <mask.h>
#include <printapp.h>
#include <relation.h>
#include <tabutil.h>
#include <utility.h>
#include <urldefid.h>

#include <lffiles.h>

#include <mov.h>
#include <rmov.h>
#include <rmoviva.h>
#include <pconti.h>
#include <comuni.h>
#include <clifo.h>
#include <attiv.h>
#include <causali.h>
#include <nditte.h>
#include <msg.h>

#include "cg3.h"
#include "cg3100.h"
#include "cglib03.h"

static TString256 TMP;

enum liste {
  movimenti=1,
  fatture=2,
  movimenti_sezionale=3  
  };

bool filter_func (const TRelation *);
bool filter_func_fatture (const TRelation *);
bool annoes      (TMask_field&, KEY);  
bool data_inizio (TMask_field&, KEY);
bool data_fine   (TMask_field&, KEY);   

class CG3100_application : public TPrintapp
{
  friend bool filter_func (const TRelation *);
  friend bool filter_func_fatture (const TRelation *);
  friend bool annoes      (TMask_field&, KEY);
  friend bool data_inizio (TMask_field&, KEY);
  friend bool data_fine   (TMask_field&, KEY);

  TRigaiva_array _c;
  TTable * _tabiva, * _tabtpd, * _tabreg, * _tabes;
  TLocalisamfile * _caus,* _comuni,* _rmoviva, * _clifo, * _pcon, * _attiv, *_nditte;
  TRelation      * _relmov,* _relmov1,* _relmov2,* _relmov3;
  TCursor * _curr1, * _curr2, * _curr3; 
  TDate  _data_ini, _data_fin, _datareg, _data_prec;
  TString _descr, _descr_doc, _descr_causale, _totali_a, _totali_d;
  TString _totalegen_dare, _totalegen_avere, _tipo_ini, _masc, _causale;
  TString _causale_ini, _causale_fin, _registro,_registro_ini, _registro_fin;
  TString _tipoatt, _tipo_elenco,_tipo_clifo_prec,_cod,_tipoelsucc;
  TString _appoggio, _tipodoc, _tipodocumento, _err1, _msg, _err, _err2, _err3;
  TString _ragsoc, _indcf, _civcf, _paiv, _codcaus, _dencom, _provcom, _cofi;
  TString _capcf, _codval, _simbolo, _statocf, _comcf, _tipo_fin;
  TString _reg_causale;
  long _documenti, _codice_ini, _codice_fin, _numero_reg,_codcf;
  long _numreg, _numreg_fin, _numreg_ini, _codalleg, _numeroregp,_codclifosucc;
  long _codcf_prec, _numr;
  int  _anno, _annoes;
  real _totdocumenti, _totdoc, _totimponibile, _totimposta, _importo;
  real _op_esenti, _op_non_imp, _impo, _impos;
  real _tot_dare, _tot_avere, _tot_avere_giornaliero;
  real _tot_dare_giornaliero, _tot_dare_generale, _tot_avere_generale;
  bool _intracom, _no_preprocess_page, _salto_pagina, _stampa_anno_comp;
  bool _stampa_parte_iva,_alleg_causale,_stampa_mess_alleg_iva,_allegb,_ricser;
  bool _settata_prima_riga, _causale_gia_stampata;
  int  _cur1,_cur2,_cur2b,_cur3,_cur4,_decidi,_tipod,_controllo_mov_errati;
  int  _numero_riga, _alleg, _tiporegistro, _tipocr, _scelta_stampa, _nr, _n;
  liste _tipo_lista;
  word _flags;

protected:
  virtual void preprocess_header();
  virtual bool preprocess_page(int,int);
  virtual print_action postprocess_page(int,int);
  virtual print_action postprocess_print(int,int);
  virtual void set_page(int,int);
  virtual bool set_print(int m);
  void init_print(const TMask& m);

public:

  void user_create() ;
  void user_destroy();
  bool segnala_errori_primariga();
  bool segnala_errori_ogniriga();
  void stampa_errori_rmov();
  void stampa_errori_mov();
  void stampa_intestazione();
  void incrementa_totali();
  void compila_clifo();
  void compila_comuni();
//  int  my_next (TLocalisamfile&); 
  
  CG3100_application() {}
};

TDate InizioEsercizio(int anno)
{
  TTable TabEs ("ESC");
  TString16 codtab;
  TDate inizio_es;

  TabEs.zero();
  codtab.format ("%04d", anno);
  TabEs.put ("CODTAB", codtab);
  TabEs.read();
  if (TabEs.good())
      inizio_es= TabEs.get_date ("D0");

  return inizio_es;
}

TDate FineEsercizio(int anno)
{
  TTable TabEs ("ESC");
  TString16 codtab;
  TDate fine_es;

  TabEs.zero();
  codtab.format ("%04d", anno);
  TabEs.put ("CODTAB", codtab);
  TabEs.read();
  if (TabEs.good())
      fine_es = TabEs.get_date ("D1");
  else fine_es = botime;
  
  return fine_es;
}

bool annoes(TMask_field& f, KEY k)
{
  if (k == K_TAB)
  {
    int anno = f.mask().get_int (F_ANNO);
    if ( anno != 0 )
    {
      f.mask().field(F_DATAINI).set(InizioEsercizio(anno));
      TDate fine = FineEsercizio(anno + 1);
      if (fine == botime)
         fine = FineEsercizio(anno); 
      f.mask().field(F_DATAFIN).set(fine);
    }
  }
  return TRUE; 
} 

bool data_inizio(TMask_field& f, KEY k)
{
  CG3100_application * app = (CG3100_application*)MainApp();
  
  if (k == K_ENTER)
  {
    int decidi;
    int anno   = f.mask().get_int (F_ANNO);
    TDate data = f.mask().get(F_DATAINI);
    if (app->_masc == "cg3100a")
       decidi = f.mask().get_int (F_DECIDI);
    if ( anno != 0 && ( (app->_masc == "cg3100b") || 
         ((app->_masc == "cg3100a" ) && (decidi == 2)) ) )
    {
      if (!data.ok()) //se la data e' vuota
         f.mask().field(F_DATAINI).set(InizioEsercizio(anno));
      else
        if (data < InizioEsercizio(anno))
        {
          f.error_box("La data indicata non deve essere inferiore alla data di inizio esercizio");   
          return FALSE;
        }
    }
  }      
  return TRUE;
}

bool data_fine(TMask_field& f, KEY k)
{
  CG3100_application * app = (CG3100_application*)MainApp();
  
  if (k == K_ENTER)
  {
    int decidi;
    int anno      = f.mask().get_int (F_ANNO);
    TDate dataini = f.mask().get(F_DATAINI);
    TDate datafin = f.mask().get(F_DATAFIN); 
    if (app->_masc == "cg3100a")
       decidi = f.mask().get_int (F_DECIDI);
    if ( (app->_masc == "cg3100b") || 
         ((app->_masc == "cg3100a" ) && (decidi == 2)) ) 
       if ( dataini.ok() && datafin.ok() ) 
          if (dataini > datafin) 
          {
           f.error_box("La data iniziale non deve essere superiore alla data finale");
           return FALSE;
          }  
    if ( anno != 0 && ( (app->_masc == "cg3100b") || 
         ((app->_masc == "cg3100a" ) && (decidi == 2)) ) )
    {
      TDate fine = FineEsercizio(anno + 1);
      if (fine == botime)
         fine = FineEsercizio(anno); 
      if (!datafin.ok()) //se la data e' vuota 
         f.mask().field(F_DATAFIN).set(fine);
      else
        if (datafin > fine)
        {
          f.error_box("La data indicata non deve essere superiore alla data di fine esercizio successivo, oppure, in caso questo non esista, dell'esercizio indicato");   
          return FALSE;
        }
    }
  }      
  return TRUE;
}

void CG3100_application::compila_clifo()
{
  _clifo->setkey(1);
  _clifo->zero();
  _clifo->put(CLI_TIPOCF,_tipo_elenco);
  _clifo->put(CLI_CODCF,_codcf);
  _clifo->read();
  if (_clifo->bad())
    _clifo->zero();
  _alleg    = _clifo->curr().get_int(CLI_ALLEG);
  _statocf  = _clifo->curr().get(CLI_STATOCF);
  _comcf    = _clifo->curr().get(CLI_COMCF);
  _ragsoc   = _clifo->curr().get(CLI_RAGSOC);
  _indcf    = _clifo->curr().get(CLI_INDCF);
  _civcf    = _clifo->curr().get(CLI_CIVCF);
  _paiv     = _clifo->curr().get(CLI_PAIV);
  _capcf    = _clifo->curr().get(CLI_CAPCF);
  _cofi     = _clifo->curr().get(CLI_COFI); 
  _codalleg = _clifo->curr().get_long(CLI_CODALLEG);
}

void CG3100_application::compila_comuni()
{
  _comuni->setkey(1);
  _comuni->zero();
  _comuni->put(COM_STATO,_statocf);
  _comuni->put(COM_COM,_comcf);
  _comuni->read();
  if (_comuni->bad())
    _comuni->curr().zero();
  _dencom  = _comuni->get(COM_DENCOM);
  _provcom = _comuni->get(COM_PROVCOM);
}

const int AllegClifo (int gruppo, int conto, long sottoconto)
{  
  TLocalisamfile clifo(LF_CLIFO);
  int alleg;

  clifo.setkey(3);
  clifo.zero();
  clifo.put(CLI_GRUPPO, gruppo);
  clifo.put(CLI_CONTO,  conto);
  clifo.put(CLI_CODCF,  sottoconto);
  clifo.read();
  if (clifo.good())
    alleg = clifo.curr().get_int(CLI_ALLEG);  
  else
    alleg = 0;

  return alleg;
}

const char * DescrConto (long gruppo, long conto, long sottoconto, 
                         const char* tipocf)
{  
  TLocalisamfile pcon(LF_PCON);
  TLocalisamfile clifo(LF_CLIFO);
  
  pcon.setkey(1);
  pcon.zero();
  pcon.put(PCN_GRUPPO, gruppo);
  if (conto != 0)
    pcon.put(PCN_CONTO, conto);
  if (sottoconto != 0)
    pcon.put(PCN_SOTTOCONTO,sottoconto);
  pcon.read();
  if (pcon.good())
    TMP = pcon.curr().get(PCN_DESCR);
  else
  {
    clifo.setkey(1); 
    clifo.zero();
    clifo.put(CLI_CODCF, sottoconto);
    clifo.put(CLI_TIPOCF,tipocf);
    clifo.read();
    if (clifo.good())
      TMP = clifo.get(CLI_RAGSOC);
  }
  return TMP;  
}

bool CausAlleg (const char * cod)
{
  TLocalisamfile caus(LF_CAUSALI);
  bool allegb;
  
  caus.setkey(1);
  caus.zero();
  caus.put(CAU_CODCAUS,cod);
  caus.read();
  if (caus.bad())
    caus.zero();
  allegb = caus.get_bool(CAU_ALLEG);
  
  return allegb;
}

const char * TipoAttivita (const char * attreg, long codice_ditta)
{
  TLocalisamfile attiv(LF_ATTIV);

  attiv.setkey(1);
  attiv.zero();
  attiv.put(ATT_CODDITTA, codice_ditta);
  attiv.put(ATT_CODATT,   attreg);

  attiv.read();
  if (attiv.good())
    TMP = attiv.curr().get(ATT_TIPOATT);  
  else
    TMP = "";

  return TMP;
}

const char * SimboloValuta (const char * cod)
{
  TTable tab_val(TAB_VAL);
  TString codtab = format ("%-3s", cod); 
  
  tab_val.zero();
  
  tab_val.put("CODTAB", codtab);
  tab_val.read();
  if (tab_val.good())
    TMP = tab_val.get("S7");
  else 
    TMP = "";

  return TMP;
}

const char * DescrDoc (const char * tipo)
{
  TTable  tab_tpd(TAB_TPD);
  TString codtab = format ("%-2s", tipo);
  
  tab_tpd.zero();
  
  tab_tpd.put("CODTAB", codtab);
  tab_tpd.read();
  if (tab_tpd.good())
    TMP = tab_tpd.get("S0");
  else
    TMP = "";

  return TMP;
} 

const char * AttivitaRegistro (const char * cod, int anno)
{
  TTable tab_reg("REG");
  TString codtab ( format ("%04d%-3s", anno, cod) );
  
  tab_reg.zero();

  tab_reg.put("CODTAB", codtab);
  tab_reg.read();

  if (tab_reg.good())
    TMP = tab_reg.get("S8");
  else
    TMP = "";
  
  return TMP; 
}

const int CodiceRegistro (const char* cod, int anno)
{
  TTable tab_reg("REG");
  TString codtab;
  codtab.format("%4d%-3s", anno, cod);
  //sprintf (__tmp, "%04d%-3s", anno, cod);
  //TString codtab (__tmp);
  int tipo_reg;

  tab_reg.zero();

  tab_reg.put("CODTAB", codtab);
  tab_reg.read();

  if (tab_reg.good())
    tipo_reg = tab_reg.get_int("I0");
  else
    tipo_reg = 0;
  
  return tipo_reg; 
}

bool filter_func_fatture (const TRelation * rel)
{
  CG3100_application * app = (CG3100_application*)MainApp();
  int                  tipo_reg;
  int                  ann_reg;
  TString              cod_reg;
  TLocalisamfile*      mov = &(rel->lfile(LF_MOV)); 
  TRectype from (mov->curr());
  TRectype to (mov->curr());
  ann_reg  = mov->get_int (MOV_ANNOIVA); 
  cod_reg  = mov->get     (MOV_REG); 
  tipo_reg = CodiceRegistro (cod_reg, ann_reg);
  from.zero();
  to.zero();
  if (app->_annoes != 0) //anno esercizio specificato nella maschera
  {
    from.put(MOV_ANNOES, app->_annoes);
    to.put(MOV_ANNOES, app->_annoes);
  }
  if (app->_data_ini.ok())
     from.put(MOV_DATAREG, app->_data_ini);
  from.put(MOV_TIPO, app->_tipo_ini);
  if (app->_codice_ini != 0)
    from.put(MOV_CODCF, app->_codice_ini);
  if (app->_data_fin.ok())
     to.put(MOV_DATAREG, app->_data_fin);
  to.put(MOV_TIPO, app->_tipo_fin);
  if (app->_codice_fin != 0)
    to.put(MOV_CODCF, app->_codice_fin); 
  
  if (((mov->curr() >= from) && (mov->curr() <= to)) &&
      ((tipo_reg == 1) || (tipo_reg == 2)))
    return TRUE;
  
  return FALSE;
}

bool filter_func (const TRelation * rel)
{
  CG3100_application * app = (CG3100_application*)MainApp();
  int                  tipo_reg, ann_reg;
  TString              cod_reg, causale;
  TLocalisamfile*      mov = &(rel->lfile(LF_MOV)); 
  TRectype from (mov->curr());
  TRectype to   (mov->curr());
  switch (app->_scelta_stampa)
  {
   case 0:
     ann_reg  = mov->get_int(MOV_ANNOIVA); 
     causale  = mov->get    (MOV_CODCAUS);
     from.zero();
     to.zero();
     if ( (app->_decidi == 2) && (app->_annoes != 0) )
     { 
      from.put(MOV_ANNOES, app->_annoes);
      to.put(MOV_ANNOES, app->_annoes);
     }
     from.put(MOV_CODCAUS, app->_causale_ini);
     to.put(MOV_CODCAUS, app->_causale_fin);
     from.put(MOV_REG, app->_registro_ini);
     to.put(MOV_REG, app->_registro_fin);        
     if ((mov->curr() >= from) && (mov->curr() <= to)) 
       return TRUE;
     break;
   case 1:
     cod_reg  = mov->get      (MOV_REG); 
     ann_reg  = mov->get_int  (MOV_ANNOIVA); 
     tipo_reg = CodiceRegistro(cod_reg, ann_reg);
     causale  = mov->get      (MOV_CODCAUS);
     from.zero();
     to.zero();
     if ( (app->_decidi == 2) && (app->_annoes != 0) )
     {  
      from.put(MOV_ANNOES, app->_annoes);
      to.put(MOV_ANNOES, app->_annoes);
     }
     from.put(MOV_CODCAUS, app->_causale_ini);
     to.put(MOV_CODCAUS, app->_causale_fin);
    
     if (((mov->curr() >= from) && (mov->curr() <= to)) &&
        ((tipo_reg != 1) && (tipo_reg != 2)))
        return TRUE;
    
     break;

   default:
     break;
   }
   return FALSE;
}

void CG3100_application::stampa_errori_rmov()
{
    if (_controllo_mov_errati != 3)
    { 
      _nr = 2;
      if ( _tiporegistro != 1 && _tiporegistro != 2 )
      { 
       if (_err == ERR_64)
       { 
        reset_row(_nr); 
        set_row(_nr++, "@11g%s", ERR_64);
       } 
       if (_err1 == ERR_66)
       {
        reset_row(_nr); 
        set_row(_nr++, "@11g%s", ERR_66);
       } 
       if (_err2 == ERR_75)
       {
        reset_row(_nr); 
        set_row(_nr++, "@11g%s", ERR_75);
       } 
      }   
      if ((_tiporegistro == 1)||(_tiporegistro == 2)) 
      {  
        if ((_alleg == 1)||(_alleg == 2))
        {
          reset_row(_nr);
          set_row(_nr++, "@11g%s", MSG_31);
        }
        if (_err2 == ERR_1)
        {   
         reset_row(_nr);
         set_row(_nr++, "@11g%s",ERR_1);
        }            
        if (_err == ERR_2)
        {
         reset_row(_nr);
         set_row(_nr++, "@11g%s",ERR_2);
        }
        if (_err3 == ERR_4)
        {
         reset_row(_nr);
         set_row(_nr++, "@11g%s",ERR_4);
        }       
        if (_msg == MSG_54)
        {
         reset_row(_nr);
         set_row(_nr++, "@11g%s",MSG_54);
        }       
        if (_err1 == ERR_09)
        {
         reset_row(_nr);
         set_row(_nr, "@11g%s",ERR_09); 
        } 
      }        
    }
}

void CG3100_application::stampa_errori_mov()
{
    if (_controllo_mov_errati != 3)
    {
      //aggiungere il controllo anno di competenza
      
      if ( _tiporegistro == 1 || _tiporegistro == 2 ) //controlli su mov. iva
      {
       if (_caus->empty())
          set_row(++_n, "@11g%s", ERR_16);
       
       if (_tipodocumento != _tipodoc)
          set_row(++_n, "@11g%s", MSG_19);
      
       if ((_stampa_mess_alleg_iva)&&(!_alleg_causale))
          set_row(++_n, "@11g%s", MSG_20);
        
       if (_registro == "")
          set_row(++_n, "@11g%s", ERR_21);
      }
      if ( _tiporegistro != 1 && _tiporegistro != 2 ) //controlli su mov. di prima nota   
      {
        if (_registro.not_empty())
           if (CodiceRegistro(_registro,_anno) == 0)
              set_row(++_n, "@11g%s", ERR_62);
        if (_causale.not_empty())
        {
          if (_caus->empty())      
             set_row(++_n, "@11g%s", ERR_16);
          else    
            if ( _reg_causale != _registro && _registro.not_empty() )
               set_row(++_n, "@11g%s", ERR_59);  
        }     
      }
    }
}

void CG3100_application::set_page(int file, int count)
{
  switch (_tipo_lista)
  {
  case movimenti:
    if (file == LF_RMOVIVA)
      break;
    if (file == LF_RMOV)
    {
      _nr = 1;
      set_row(_nr,"@3n",FLD(LF_RMOV,RMV_NUMRIG));
      // set_row(_nr,"@5g@3s",FLD(LF_MOV,MOV_CODCAUS));
      // set_row(_nr,"@9g#.20t", &_descr_causale);
      set_row(_nr,"@30g@24s@r",FLD(LF_RMOV,RMV_DESCR));
      set_row(_nr,"@56g@4n",FLD(LF_RMOV,RMV_GRUPPO));
      set_row(_nr,"@61g@3n",FLD(LF_RMOV,RMV_CONTO));
      set_row(_nr,"@65g@6n",FLD(LF_RMOV,RMV_SOTTOCONTO));
      set_row(_nr,"@72g#.20t@r",&_descr);
      _appoggio = current_cursor()->curr(LF_RMOV).get(RMV_SEZIONE);
      if ((_appoggio=="D")||(_appoggio=="d"))
        set_row(_nr,"@93g@pN",FLD(LF_RMOV,RMV_IMPORTO,"###.###.###.###")); 
      else
        set_row(_nr,"@111g@pN",FLD(LF_RMOV,RMV_IMPORTO,"###.###.###.###"));
      set_row(_nr,"@130g@f",FLD(LF_MOV,MOV_STAMPATO));
    }                     
    else if (file == LF_MOV)
    {
      TString dep(132);
      dep = "";
      _n = 1;
      set_row (_n++,(const char*)dep); 
      set_row (_n, "Operazione n. @18g@7n", FLD(LF_MOV,MOV_NUMREG));
      //set_row (_n, "@23g@3s",FLD(LF_MOV,MOV_CODCAUS));
      set_row (_n, "@26gdel@30g@d",FLD(LF_MOV,MOV_DATAREG));
      set_row (_n, "@41g@40s@r",FLD(LF_MOV,MOV_DESCR));
      set_row (_n, "@82gdoc. @87g@7s",FLD(LF_MOV,MOV_NUMDOC));
      set_row (_n, "@95gdel@99g@d", FLD(LF_MOV,MOV_DATADOC));
      TString16 reg = current_cursor()->curr(LF_MOV).get(MOV_REG);
      int      anno = current_cursor()->curr(LF_MOV).get_int(MOV_ANNOIVA);
      int tipo = CodiceRegistro(reg, anno);
      if ( (tipo == 1) || (tipo == 2) )
      {
        set_row (_n, "@110greg @3s",FLD(LF_MOV,MOV_REG));
        set_row (_n, "@118gpr @5n",FLD(LF_MOV,MOV_PROTIVA));
      }
      if (_scelta_stampa == 0)
         if (_stampa_anno_comp)
            set_row (_n, "@127g@4n", FLD(LF_MOV,MOV_ANNOES)); 
      //set_row (_n, "@130g@f", FLD(LF_MOV,MOV_STAMPATO));
    }
    break;
    
  case fatture:
    break;
    
  case movimenti_sezionale:
    break; 
    
  default:
    break;
  }
}

void CG3100_application::stampa_intestazione()
{
  TString sep;     
  sep = "";
  set_row (1,(const char*)sep);
  if (_tipo_elenco == "C")
    set_row (2, "@bCliente@9g@6n", FLD(LF_MOV,MOV_CODCF));
  else 
    set_row (2, "@bFornitore@12g@6n", FLD(LF_MOV,MOV_CODCF));
  set_row (2, "@b@18g#35t", &_ragsoc);
  set_row (2, "@b@54gInd #29t", &_indcf);
  set_row (2, "@b@87g#10t", &_civcf);
  set_row (2, "@b@98gP.I. #11t", &_paiv);
  if (_alleg == 0)
    set_row (2, "@b@121gAllegato NO");
  else 
    set_row (2, "@b@121gAllegato SI");
  set_row (3, "@b@54gCap #5t",  &_capcf);
  set_row (3,"@b@64gLoc #20t",  &_dencom);
  set_row (3,"@b@89gPr #5t",   &_provcom);
  set_row (3, "@b@98gC.F. #16t", &_cofi);
  if (_alleg == 0)
    set_row (3, "@b@120gRifer@126g#6d", &_codalleg);
}

bool CG3100_application::preprocess_page(int file,int counter)
{

  TCursor * cur = current_cursor();

  if (counter) return TRUE;

  switch (_tipo_lista)
  {
  case movimenti:
    if (_scelta_stampa == 0)
    {
      if (file == LF_MOV)
      {
        _tot_avere = 0;
        _tot_dare  = 0;
        _c.destroy();
        _no_preprocess_page = FALSE;
        _causale = current_cursor()->curr(LF_MOV).get(MOV_CODCAUS);
        _registro = current_cursor()->curr(LF_MOV).get(MOV_REG);
        _anno = current_cursor()->curr(LF_MOV).get_int(MOV_ANNOIVA);
        _tipodoc = current_cursor()->curr(LF_MOV).get(MOV_TIPODOC);
        _datareg = current_cursor()->file(LF_MOV).get_date(MOV_DATAREG);
        _causale_gia_stampata = FALSE;

        //TDate data_corrente (current_cursor()->file(LF_MOV)->get_date(MOV_DATAREG));
        _tiporegistro = CodiceRegistro(_registro, _anno);

        TLocalisamfile* fl = &(current_cursor()->file(LF_MOV));
        TRectype da (fl->curr());
        TRectype a  (fl->curr());
        da.zero();
        a.zero();
        if (_annoes != 0)
        {  
          da.put(MOV_ANNOES, _annoes);
          a.put(MOV_ANNOES, _annoes);
        }  
        da.put(MOV_CODCAUS, _causale_ini);
        da.put(MOV_REG, _registro_ini);
        a.put(MOV_CODCAUS, _causale_fin);
        a.put(MOV_REG, _registro_fin);
        
        if ((fl->curr() >= da) && (fl->curr() <= a))
          //&&((_tiporegistro == 1)||(_tiporegistro == 2))) 
        {   
          _caus->setkey(1);
          _caus->curr().put(CAU_CODCAUS,_causale);
          _caus->read();
          if (_caus->bad())
            _caus->curr().zero();
          _reg_causale   = _caus->curr().get(CAU_REG);  
          _descr_causale = _caus->curr().get(CAU_DESCR); 
          _alleg_causale = _caus->curr().get_bool(CAU_ALLEG);
          _tipodocumento = _caus->curr().get(CAU_TIPODOC);
          
          bool controlla = segnala_errori_primariga();
          
          if ( (_controllo_mov_errati == 1 && controlla)
               || _controllo_mov_errati == 2 )
          {
            stampa_errori_mov();
            return TRUE;
          }
          else if ((_controllo_mov_errati == 1)&&(!controlla))
            return FALSE;
          else if (_controllo_mov_errati == 3)
            return TRUE;
        }
      }
    else if (file == LF_RMOV)
    {
      if (!_causale_gia_stampata)
      {
        set_row(_nr,"@4g%3s",   (const char*) _causale);
        set_row(_nr,"@8g%.20s@r", (const char*) _descr_causale);
        _causale_gia_stampata = TRUE;
      }
      
      bool verifica = segnala_errori_ogniriga();
      
      if (((_controllo_mov_errati == 1)&&(verifica))||(_controllo_mov_errati == 2)||(_controllo_mov_errati == 3))
      {
        int gruppo = current_cursor()->curr(LF_RMOV).get_int(RMV_GRUPPO);
        int conto  = current_cursor()->curr(LF_RMOV).get_int(RMV_CONTO);
        long sottoconto = current_cursor()->curr(LF_RMOV).get_long(RMV_SOTTOCONTO);
        TString tipoc = current_cursor()->curr(LF_RMOV).get(RMV_TIPOC);
        _descr = DescrConto(gruppo, conto, sottoconto, tipoc);
        _alleg = AllegClifo(gruppo, conto, sottoconto);
        _importo = current_cursor()->file(LF_RMOV).get_real(RMV_IMPORTO);
        _appoggio = current_cursor()->curr(LF_RMOV).get(RMV_SEZIONE);
        if (!_no_preprocess_page)
        {
          if ((_appoggio=="D")||(_appoggio=="d"))
          {
            _tot_dare_generale += _importo;
            _tot_dare          += _importo;
          }
          else if ((_appoggio=="A")||(_appoggio=="a"))
          {
            _tot_avere += _importo;
            _tot_avere_generale += _importo;
          }
          stampa_errori_rmov();  
        }
        return TRUE;                  
      }
    }
    else if ((_stampa_parte_iva)&&(file == LF_RMOVIVA))
    {
      TRectype iva(current_cursor()->file(LF_RMOVIVA).curr());
      _impo   = iva.get_real(RMI_IMPONIBILE);
      _impos  = iva.get_real(RMI_IMPOSTA);
      _tipocr = iva.get_int(RMI_TIPOCR);
      _tipod  = iva.get_int(RMI_TIPODET);
      _cod    = iva.get(RMI_CODIVA);        
      if (_stampa_parte_iva)
        _c.add_riga(_impo,_impos,_cod,_tipod,0.00,0.00);

      return TRUE;
    }
  }
  else //_scelta_stampa == 1
  {
    if (file == LF_MOV)
    {
      _tot_avere = 0;
      _tot_dare  = 0; 
      _no_preprocess_page = FALSE; 
      _causale = current_cursor()->curr(LF_MOV).get(MOV_CODCAUS);
      _registro = current_cursor()->curr(LF_MOV).get(MOV_REG);
      _anno = current_cursor()->curr(LF_MOV).get_int(MOV_ANNOES);
      _tipodoc = current_cursor()->curr(LF_MOV).get(MOV_TIPODOC);

      TLocalisamfile* fl = &(current_cursor()->file(LF_MOV));
      TRectype da (fl->curr());
      TRectype a (fl->curr());
      da.zero();
      a.zero();
      if (_annoes != 0)
      {  
        da.put(MOV_ANNOES, _annoes);
        a.put(MOV_ANNOES, _annoes);
      }
      da.put(MOV_CODCAUS, _causale_ini);
      a.put(MOV_CODCAUS, _causale_fin);
      
      if ((fl->curr() >= da) && (fl->curr() <= a))
        /*
           if ((_annoes == _anno) || (_annoes == 0)) 
           if ((_causale >= _causale_ini) && (_causale <= _causale_fin))
        */
      {
        _caus->setkey(1);
        _caus->curr().put(CAU_CODCAUS,_causale);
        _caus->read();
        _descr_causale = _caus->curr().get(CAU_DESCR); 
        _alleg_causale = _caus->curr().get_bool(CAU_ALLEG);
        _tipodocumento = _caus->curr().get(CAU_TIPODOC);

        _tiporegistro = CodiceRegistro (_registro, _anno);

        if ((_tiporegistro != 1)&&(_tiporegistro != 2))//se si tratta di un movimento di sola prima nota
          return TRUE;
      } 
    }
    else if (file == LF_RMOV)
    {
      long gruppo = atol(current_cursor()->curr(LF_RMOV).get(RMV_GRUPPO));
      long conto = atol(current_cursor()->curr(LF_RMOV).get(RMV_CONTO));
      long sottoconto = atol(current_cursor()->curr(LF_RMOV).get(RMV_SOTTOCONTO));
      TString tipoc = current_cursor()->curr(LF_RMOV).get(RMV_TIPOC); 
      _descr = DescrConto(gruppo, conto, sottoconto, tipoc);
      _importo = current_cursor()->file(LF_RMOV).get_real(RMV_IMPORTO);
      _appoggio = current_cursor()->curr(LF_RMOV).get(RMV_SEZIONE);
      if (!_no_preprocess_page)
      {
        if ((_appoggio=="D")||(_appoggio=="d"))
        {
          _tot_dare_generale += _importo;
          _tot_dare += _importo;
        }
        else if ((_appoggio=="A")||(_appoggio=="a"))
        {
          _tot_avere += _importo;
          _tot_avere_generale += _importo;
        }
      }
      return TRUE;
    }
  } 
  break;
    
  case fatture:
  {
    if (file == LF_MOV)
    {
      int anno       = cur->curr(LF_MOV).get_int(MOV_ANNOIVA);
      TString codreg = cur->curr(LF_MOV).get(MOV_REG);
      _numr        = current_cursor()->curr(LF_MOV).get_long(MOV_NUMREG); 
      _tipo_elenco = current_cursor()->curr(LF_MOV).get(MOV_TIPO); 
      _codcf       = current_cursor()->curr(LF_MOV).get_long(MOV_CODCF);
      int     tiporeg = CodiceRegistro   (codreg, anno);
      TString attreg  = AttivitaRegistro (codreg, anno); 
      
      if (tiporeg == 1 || tiporeg == 2)//se si tratta di un movimento iva
      {  
        _tipoatt     = TipoAttivita(attreg, get_firm());  
        _tipo_elenco = cur->curr(LF_MOV).get(MOV_TIPO);
        _codcf       = cur->curr(LF_MOV).get_long(MOV_CODCF);
        _codcaus     = cur->curr(LF_MOV).get(MOV_CODCAUS);
        _tipodoc     = cur->curr(LF_MOV).get(MOV_TIPODOC);      
        _codval      = cur->curr(LF_MOV).get(MOV_CODVAL); 
        _totdoc      = cur->curr(LF_MOV).get_real(MOV_TOTDOC);

        if ((_tipo_elenco != _tipo_clifo_prec) && 
            (_tipo_clifo_prec != "") && _salto_pagina)
           printer().formfeed();
        
        TLocalisamfile & file = cur->file(LF_MOV);
        TRectype da (file.curr());
        TRectype a (file.curr());
        da.zero();
        a.zero();  
        
        if (_annoes != 0) //anno specificato nella maschera
        {
          da.put(MOV_ANNOES, _annoes);
          a.put(MOV_ANNOES, _annoes);
        }
        if (_data_ini.ok())
           da.put(MOV_DATAREG, _data_ini);
        da.put(MOV_TIPO, _tipo_ini);
        if (_codice_ini != 0)
          da.put(MOV_CODCF, _codice_ini);
        if (_data_fin.ok())
           a.put(MOV_DATAREG, _data_fin);
        a.put(MOV_TIPO, _tipo_fin);
        if (_codice_fin != 0)
          a.put(MOV_CODCF, _codice_fin); 
        
        if ((file.curr() >= da) && (file.curr() <= a))
        {  
          compila_clifo();
          compila_comuni();
          
          if ((_tipo_clifo_prec == "")&&(_codcf_prec == 0l)) 
          {
            _tipo_clifo_prec = _tipo_elenco;
            _codcf_prec      = _codcf; 
            stampa_intestazione();
          }
          else
            if (_tipo_clifo_prec == _tipo_elenco && _codcf_prec == _codcf)
               _settata_prima_riga = FALSE;
            else
            {
             stampa_intestazione();
             _tipo_clifo_prec = _tipo_elenco;
             _codcf_prec      = _codcf;
             _settata_prima_riga = FALSE;
            }    
          return TRUE;
        }
      }
    }
    else if (file == LF_RMOVIVA)
    { 
      int  gruppo = current_cursor()->curr(LF_RMOV).get_int(RMV_GRUPPO);
      int  conto  = current_cursor()->curr(LF_RMOV).get_int(RMV_CONTO);          
      
      _pcon->zero();
      _pcon->put("GRUPPO",gruppo);  
      _pcon->put("CONTO", conto); 
      _pcon->put("SOTTOCONTO", 0L);
      
      if (_pcon->read() == NOERR)
        _ricser = _pcon->get_int("RICSER");
      
      _simbolo   = SimboloValuta(_codval);
      _allegb    = CausAlleg(_codcaus);
      _descr_doc = DescrDoc(_tipodoc);
      //_totdocumenti += _totdoc;
      //_ricser   = current_cursor()->curr(LF_RMOVIVA).get_int(RMI_RICSER);
      _intracom = current_cursor()->curr(LF_RMOVIVA).get_bool(RMI_INTRA);          
      
      if ((_codval != "LIT") && _intracom)
      {
        reset_row(1);
        set_row(1,"Corr.in lire@14g@pN",FLD(LF_MOV,MOV_CORRLIRE,"###.###.###.###"));
        set_row(1,"@34gCorr.in valuta@49g@pN",FLD(LF_MOV,MOV_CORRVALUTA,"###.###.###.###"));
        if (_simbolo.not_empty())
          set_row(1,"@65g%.5s", (const char *)_simbolo);
        else
          set_row(1,"@65g%.3s", (const char *)_codval);
      }
      else if (!_settata_prima_riga)
      {
        reset_row(1);    
        set_row(1,"@7n",FLD(LF_MOV,MOV_NUMREG));
        set_row(1,"@8g@d",FLD(LF_MOV,MOV_DATAREG)); 
        set_row(1,"@17g@3,rs",FLD(LF_MOV,MOV_REG));
        set_row(1,"@21g@5n",FLD(LF_MOV,MOV_PROTIVA));
        
        TString protiva  = cur->curr(LF_MOV).get(MOV_PROTIVA);
        TString uprotiva = cur->curr(LF_MOV).get(MOV_UPROTIVA);
        
        if (uprotiva.not_empty())
        {                            
          for (int i = 0; protiva[i] && (protiva[i] == uprotiva[i]); i++); 
          uprotiva = uprotiva.mid(i);
          set_row(1, "@24g/@25g%s", (const char*) uprotiva);
        }
        set_row(1, "@33g@d", FLD(LF_MOV,MOV_DATADOC)); 
        set_row(1,"@42g@6,rs",FLD(LF_MOV,MOV_NUMDOC));
        set_row(1,"@49g@3s",FLD(LF_MOV,MOV_CODCAUS));
        set_row(1,"@53g@2s",FLD(LF_MOV,MOV_TIPODOC));
        set_row(1,"@56g%.12s@r", (const char *)_descr_doc);
        set_row(1,"@68g@pN",FLD(LF_MOV,MOV_TOTDOC,"###.###.###.###"));
        set_row(1,"@84g@pN",FLD(LF_RMOVIVA,RMI_IMPONIBILE,"###.###.###.###"));      
        set_row(1,"@101g@4s",FLD(LF_RMOVIVA,RMI_CODIVA));
        set_row(1,"@105g@1n",FLD(LF_RMOVIVA,RMI_TIPODET));
        if (_tipoatt == "E")
          if (_ricser == 1)        
            set_row(1,"@109g1");
          else if (_ricser == 2)
            set_row(1,"@109g2");
        set_row(1,"@111g@f",FLD(LF_RMOVIVA,RMI_INTRA));
        set_row(1,"@113g@pN",FLD(LF_RMOVIVA,RMI_IMPOSTA,"###.###.###.###"));
        if (!_allegb)
          set_row(1,"@131g*");

        incrementa_totali();        
        _settata_prima_riga = TRUE;        
        ++_documenti;
      }       
      else if (_settata_prima_riga)
      {
        reset_row(1);
        set_row(1,"@84g@pN", FLD(LF_RMOVIVA,RMI_IMPONIBILE,"###.###.###.###"));
        set_row(1,"@101g@4s",   FLD(LF_RMOVIVA,RMI_CODIVA));
        set_row(1,"@113g@pN",  FLD(LF_RMOVIVA,RMI_IMPOSTA,"###.###.###.###"));
        incrementa_totali();                           
      }     
      return TRUE;                  
    }
  }      
    break;   

  case movimenti_sezionale:
    break;
    
  default:
    break;
  }
  return FALSE;
}

print_action CG3100_application::postprocess_page(int file,int count)
{
  if (count)
  {
    reset_print();
    return NEXT_PAGE;
  }
  switch (_tipo_lista)
  {
  case movimenti:
    if (file == LF_RMOV)
    {
      force_setpage();
      break;
    }
    if (file == LF_MOV)
    {       
        reset_print();
        int n = 1;
        if ( _scelta_stampa == 0 && _stampa_parte_iva )
        { 
          int r = 0;
          for (int j = 0; j < _c.items(); j++)
          {
            TRigaiva& riga = (TRigaiva&)_c[j];
            r = j+1;
            set_row(r, "Imponibile@12g%15.0r", &riga._imponibile);
            set_row(r, "@31gImposta@39g%15.0r",   &riga._imposta);
            set_row(r, "@58gCodice Iva@68g%3s", (const char*)riga._codiva);
            switch (riga._tipodet)
            {
              case 0 : set_row(r, "@73gDetraibile");
                       break;
              case 1 : set_row(r, "@73gIndetraibile su op.es.");
                       break;
              case 3 : set_row(r, "@73gPassaggi interni");
                       break;
              case 9 : set_row(r, "@73gIndetraibile art.19");
                       break;
              default: break;   
            } 
          } 
          _c.destroy();
          if (r > 0)
          {
            n = ++r;
            //return REPEAT_PAGE;
          }    
          //else 
          //  return NEXT_PAGE;
        }
      //}
        TRecnotype pos, items;
        bool FINITO = FALSE;
        //reset_print();
        //int n = 1;
        if ((_scelta_stampa == 0)&&(_controllo_mov_errati != 3)&&(_tot_dare != _tot_avere))
           set_row(n++, "@11g%s", ERR_77); 
      
 //       TLocalisamfile & mov = current_cursor()->file(LF_MOV);
        pos   = current_cursor()->pos();
        items = current_cursor()->items();
      
        FINITO = (pos == items-1);

        _datareg = current_cursor()->file(LF_MOV).get_date(MOV_DATAREG);
        _numreg  = current_cursor()->file(LF_MOV).get_long(MOV_NUMREG); 

        TDate datarec (_datareg);
        if (!FINITO)
        {
         TCursor * cur = current_cursor();
         cur->save_status();
         ++(*cur);
         datarec     = cur->file(LF_MOV).get_date(MOV_DATAREG);
         --(*cur);
         cur->restore_status();
        }
       
        _tot_avere_giornaliero += _tot_avere;
        _tot_dare_giornaliero  += _tot_dare;                    

        //stampa i totali giornalieri
        if ( FINITO ||
           (_datareg != datarec)||(_numreg == _numreg_fin)) 
        {
         if ((  (_scelta_stampa == 0) && (_controllo_mov_errati != 1) && (_decidi == 2)) || ((_scelta_stampa == 1)&&(_decidi == 2))) 
         {
           TString data = _datareg.string();
           set_row(n, "@b@50gTotali del");
           set_row(n, "@b@61ggiorno %s", (const char *)data);
           set_row(n, "@b@93g%r",         &_tot_dare_giornaliero);
           set_row(n++, "@b@111g%r",      &_tot_avere_giornaliero);
           _tot_avere_giornaliero = 0;
           _tot_dare_giornaliero  = 0;
         }
         else if (((_scelta_stampa == 0)&&(_controllo_mov_errati != 1)&&(_decidi == 1)&&(FINITO)) || ((_scelta_stampa == 1)&&(_decidi == 1)&&(FINITO)))
         {
           TString sep;     
           sep = "";
           set_row (n,(const char*)sep);   
           set_row(++n, "@b@60gTotale generale");
           set_row(n, "@b@93g%r",        &_tot_dare_generale);
           set_row(n++, "@b@111g%r",     &_tot_avere_generale);
         }  
        } 
      
      if (n == 1)
      {
        force_setpage();
        return NEXT_PAGE;
      }
      else
      { 
        _no_preprocess_page = TRUE;
        force_setpage(FALSE);
        return REPEAT_PAGE;
      }
    }
    break;
    
  case fatture:
    if (file == LF_MOV)
    {
      _totdocumenti += _totdoc;
      TRecnotype pos, items;
      bool FINITO = FALSE;
      TCursor*        cur = current_cursor();
  //    TLocalisamfile & mov = cur->file(LF_MOV);       

      pos   = current_cursor()->pos();
      items = current_cursor()->items();
      
      FINITO = (pos == items-1);

      if (!FINITO)
      {
        cur->save_status();
        ++(*cur);
        // long numrsucc  = cur->file(LF_MOV).get_long(MOV_NUMREG);
        _tipoelsucc    = cur->file(LF_MOV).get(MOV_TIPO);
        _codclifosucc  = cur->file(LF_MOV).get_long(MOV_CODCF);
        --(*cur);
        cur->restore_status();
      }

      if (FINITO || (_tipo_elenco != _tipoelsucc)||(_codcf != _codclifosucc))
      {
        reset_print();
        TString blank = "";
        set_row(1,(const char*)blank);
        if ((_tipo_elenco == "C")||(_tipo_elenco == "c"))
          set_row(2, "@bTotali Cliente@18gDocumenti Totale documenti@45gAllegati:@56gImponibile@75gImposta@94gop. esenti@112gop. non imp.");
        else
          set_row(2, "@bTotali Fornitore@18gDocumenti Totale documenti@47gAllegati:@56gImponibile@75gImposta@94gop. esenti@112gop. non imp.");
        set_row(3, "@b@18g%9d", _documenti);
        set_row(3, "@b@28g%r", &_totdocumenti);
        set_row(3, "@b@56g%r", &_totimponibile);
        set_row(3, "@b@75g%r", &_totimposta);
        set_row(3, "@b@94g%r", &_op_esenti);
        set_row(3, "@b@112g%r", &_op_non_imp);          
        _totimposta    = 0;
        _totimponibile = 0;
        _op_esenti     = 0;
        _op_non_imp    = 0;
        _documenti     = 0;
        _totdocumenti  = 0;
        return REPEAT_PAGE;
      }
    }
    break;

  case movimenti_sezionale:
    break;

  default:
    break;  
  }
  
  return NEXT_PAGE;
}

/************
int CG3100_application::my_next(TLocalisamfile & mov)
{
  int     esito;
  TString cod_reg, causale;
  int     tipo_reg;
  int     ann_reg;

  esito = mov.next(); 

  switch (_scelta_stampa)
  {
  case 0:
    return esito;
  case 1:
    while (!mov.eof())
    {
      cod_reg  = mov.get     (MOV_REG);
      ann_reg  = mov.get_int (MOV_ANNOIVA);
      causale  = mov.get     (MOV_CODCAUS);

      if (  ( _annoes != 0l) 
          || ( (causale < (const char*)_causale_ini) || (causale > (const char*)_causale_fin)) )
      {
        esito = mov.next();
        continue;
      }
      tipo_reg = CodiceRegistro (cod_reg, ann_reg);
      if ( (tipo_reg != 1) && (tipo_reg != 2) )
        return esito;

      esito=mov.next();
    }
    break;
    
  default:
    break;
  }
  return esito;
}
********/

print_action CG3100_application::postprocess_print(int file,int count)
{
  if (count)
  {
    reset_print();
    return NEXT_PAGE;
  }

  switch (_tipo_lista)
  {
  case movimenti:
    /*
    if (file == LF_RMOV)
    {
      TRecnotype pos, items;
      bool FINITO = FALSE;
      
      reset_print();
      int n = 1;
      if ((_scelta_stampa == 0)&&(_controllo_mov_errati != 3)&&(_tot_dare != _tot_avere))
        set_row(n++, "@11g%s", ERR_77); 
      
      TLocalisamfile* mov;
      mov=current_cursor()->file(LF_MOV);
      // nrec = mov->recno();
      
      pos   = current_cursor()->pos();
      items = current_cursor()->items();
      
      FINITO = (pos == items-1);

      _datareg = current_cursor()->file(LF_MOV)->get_date(MOV_DATAREG);
      _numreg  = current_cursor()->file(LF_MOV)->get_long(MOV_NUMREG); 

      TDate datarec (_datareg);
      if (!FINITO)
      {
        TCursor * cur = current_cursor();
        cur->save_status();
        ++(*cur);
        datarec     = cur->file(LF_MOV)->get_date(MOV_DATAREG);
        --(*cur);
        cur->restore_status();
      }
      // esito = my_next(mov);
      // if (esito == NOERR)
      // {
      //   long numrec = mov->get_long(MOV_NUMREG);
      //   datarec     = mov->get_date(MOV_DATAREG);
      // }
      // mov->readat(nrec);
       
      _tot_avere_giornaliero += _tot_avere;
      _tot_dare_giornaliero  += _tot_dare;                    

      //stampa i totali giornalieri
      if ( FINITO ||
          (_datareg != datarec)||(_numreg == _numreg_fin)) 
      {
        if ((  (_scelta_stampa == 0) && (_controllo_mov_errati != 1) && (_decidi == 2)) || ((_scelta_stampa == 1)&&(_decidi == 2))) 
        {
          TString data = _datareg.string();
          set_row(n, "@b@50gTotali del");
          set_row(n, "@b@61ggiorno %s", (const char *)data);
          set_row(n, "@b@93g%r",         &_tot_dare_giornaliero);
          set_row(n++, "@b@111g%r",      &_tot_avere_giornaliero);
          _tot_avere_giornaliero = 0;
          _tot_dare_giornaliero  = 0;
          
        }
        else if (((_scelta_stampa == 0)&&(_controllo_mov_errati != 1)&&(_decidi == 1)&&(FINITO)) || ((_scelta_stampa == 1)&&(_decidi == 1)&&(FINITO)))
        {
          TString sep;     
          sep = "";
          set_row (n,(const char*)sep);   
          set_row(++n, "@b@60gTotale generale");
          set_row(n, "@b@93g%r",        &_tot_dare_generale);
          set_row(n++, "@b@111g%r",     &_tot_avere_generale);
        }  
      } 
      
      if (n == 1)
      {
        force_setpage();
        return NEXT_PAGE;
      }
      else
      { 
        _no_preprocess_page = TRUE;
        force_setpage(FALSE);
        return REPEAT_PAGE;
      }
    }
    */
    break;
    
  case fatture:
    break;
    
  case movimenti_sezionale:
    break;
    
  default:
    break;
  }
  return NEXT_PAGE;
} 

bool CG3100_application::segnala_errori_primariga()
{
  int  tiporeg;
  tiporeg = CodiceRegistro (_registro, _anno);
  
  if ((_tiporegistro == 1)||(_tiporegistro == 2)) //movimento iva
  {
    if ( tiporeg == 0  ||
        _caus->empty() ||
        _tipodocumento != _tipodoc ||
        (_stampa_mess_alleg_iva && !_alleg_causale) )
      return TRUE;
  }
  if ((_tiporegistro != 1)&&(_tiporegistro != 2)) //mov. di prima nota
  {
    if (_registro.not_empty())
       if (tiporeg == 0) return TRUE;
    if (_causale.not_empty())
       if ( _caus->empty() ||
          (_reg_causale != _registro && _registro.not_empty()) )
          return TRUE;      
  }
  return FALSE;
} 


bool CG3100_application::segnala_errori_ogniriga()
{
  bool trovato = FALSE;   
  TString dep1;
  _err = _err1 = _err2 = _err3 = "";
  
  if ((_tiporegistro != 1)&&(_tiporegistro != 2))
  {
    int gruppo = current_cursor()->curr(LF_RMOV).get_int(RMV_GRUPPO);
    int conto  = current_cursor()->curr(LF_RMOV).get_int(RMV_CONTO);
    long sottoconto = current_cursor()->curr(LF_RMOV).get_long(RMV_SOTTOCONTO);
    if (gruppo == 0 || conto == 0 || sottoconto == 0L)
    {
       _err = ERR_64;
       trovato = TRUE;
    }
    TString tipoc = current_cursor()->curr(LF_RMOV).get(RMV_TIPOC);
    _descr = DescrConto(gruppo, conto, sottoconto, tipoc);
    if (_descr.empty())
    {
      _err1 = ERR_66;
      trovato = TRUE;
    }
    _alleg = AllegClifo(gruppo, conto, sottoconto);
    _importo = current_cursor()->file(LF_RMOV).get_real(RMV_IMPORTO);
    _appoggio = current_cursor()->curr(LF_RMOV).get(RMV_SEZIONE);
    if (_appoggio != "D" && _appoggio != "A") 
    {
      _err2 = ERR_75;
      trovato = TRUE;
    }
  } 
  
  if ((_tiporegistro == 1)||(_tiporegistro == 2)) //movimento iva
  { 
    long record, numreg;
    TLocalisamfile& rmoviva = current_cursor()->file(LF_RMOVIVA);
    _numreg = current_cursor()->file(LF_MOV).get_long(MOV_NUMREG);

    if (current_cursor()->is_first_match(LF_RMOVIVA))
    {
      record = rmoviva.recno(); 
      rmoviva.zero();
      rmoviva.put(RMI_NUMREG, _numreg);
      for (rmoviva.read(); !rmoviva.eof() ;rmoviva.next())
      {
        _cod    = rmoviva.get(RMI_CODIVA);         
        _tipod  = rmoviva.get_int(RMI_TIPODET);
        _impo   = rmoviva.get_real(RMI_IMPONIBILE);
        _impos  = rmoviva.get_real(RMI_IMPOSTA);
        _tipocr = rmoviva.get_int(RMI_TIPOCR);
        numreg  = rmoviva.get_long(RMI_NUMREG);
        if (numreg != _numreg)
          break;
        else
        {
          if (_tiporegistro == 1)
            switch (_tipocr)
            {
              case 2 : case 3: case 5: case 8: case 9: _err1 = ERR_09;
                                                       trovato = TRUE;
                                                       break;
              default: break;   
            }
          else
            if (_tiporegistro == 2)
            {
              switch (_tipocr)
              { 
                case 4: case 9: _err1 = ERR_09;
                              trovato = TRUE;
                              break;
                default: break;
              }
              if ( _tipod!=0 && _tipod!=1 && _tipod!=3 && _tipod!=9 )
              {
                 _err3 = ERR_4;
                 trovato = TRUE; 
              }   
            }  
          if (_tipodoc != "AN")
          {
            _tabiva->setkey(1);
            _tabiva->zero();
            dep1.format("%-4s",(const char*) _cod);
            _tabiva->put("CODTAB", (const char*)dep1);
            _tabiva->read();
            if (_tabiva->good())
            {
              TString colonnac = _tabiva->get("S7");
              TString colonnaf = _tabiva->get("S8");
              bool sospeso  = _tabiva->get_bool("B2");
              if (sospeso)
              {
                _err = ERR_2;
                trovato = TRUE;
              }
              else if ((_stampa_mess_alleg_iva)&&((colonnac==" ")
                                               ||(colonnaf==" ")))          
              {
                _msg  = MSG_54;
                trovato = TRUE;
              }
              // break; 
            }
            else
            {
              _err2 = ERR_1;
              trovato = TRUE;
            }  
          }
        }
      } //for
      rmoviva.readat (record);   
    }
  } 
  return trovato;
}       

void CG3100_application::incrementa_totali()
{
  TString dep1;
  real imponibile, imposta;

  imponibile = current_cursor()->file(LF_RMOVIVA).get_real(RMI_IMPONIBILE);
  imposta = current_cursor()->file(LF_RMOVIVA).get_real(RMI_IMPOSTA);
  TString codiva = current_cursor()->file(LF_RMOVIVA).get(RMI_CODIVA);
  _tabiva->zero();
  dep1.format("%-4s",(const char*) codiva);
  _tabiva->put("CODTAB", (const char*)dep1);
  _tabiva->read();
  if (_tabiva->bad())
    _tabiva->zero();
  if ((_tipo_elenco == "C")||(_tipo_elenco == "c"))
  {
    TString colonna = _tabiva->get("S7");
    if ((colonna == "1")||(colonna == "3"))
      _totimposta += imposta;
    if (colonna == "1")
      _totimponibile += imponibile;
    else
      if (colonna == "3")
        _op_esenti += imponibile;  
  }
  else
  {
    TString colonna = _tabiva->get("S8");
    if ((colonna == "1")||(colonna == "3")||(colonna == "4"))
      _totimposta += imposta;
    if (colonna == "1")
      _totimponibile += imponibile;
    else
      if (colonna == "3")
        _op_esenti += imponibile;
      else 
        if (colonna == "4")
          _op_non_imp += imponibile;
  }       
}

bool CG3100_application::set_print(int m)
{
  _masc = "";
  switch(m)
  {
  case 1: 
    _masc = "cg3100a";
    _tipo_lista = movimenti;
    break;
  case 2:
    _masc = "cg3100b";
    _tipo_lista = fatture;
    break;
  case 3:
    _masc = "cg3100c";
    _tipo_lista = movimenti_sezionale;
    break;
  default:
    break;
  }

  TMask msk(_masc);
  
  msk.set_handler(F_ANNO, annoes);
  msk.set_handler(F_DATAINI, data_inizio);
  msk.set_handler(F_DATAFIN, data_fine);
  
  if (msk.run() != K_ENTER) return FALSE;

  reset_files();
  TLocalisamfile* fl;
  //_curr1->set_filterfunction (0);
  _curr1->set_filterfunction (filter_func);
  _curr2->set_filterfunction (filter_func);
  _curr3->set_filterfunction (filter_func_fatture);
  switch (_tipo_lista)
  {
   case movimenti:
   {
    _scelta_stampa = atoi(msk.get(F_MOVIMENTI));
    _annoes = msk.get_int (F_ANNO);
    _decidi = msk.get_int(F_DECIDI);
    _causale_ini = msk.get(F_CAUSALEINI);
    _causale_fin = msk.get(F_CAUSALEFIN);
    if (_scelta_stampa == 0)
    {
      _registro_ini = msk.get(F_REGISTROINI);
      _registro_fin = msk.get(F_REGISTROFIN);
    }
    _numreg_ini = atol(msk.get(F_NUMEROINI));
    _data_ini = msk.get(F_DATAINI);
    _data_fin = msk.get(F_DATAFIN);
    _numreg_fin = atoi(msk.get(F_NUMEROFIN));
    bool provvis = msk.get_bool(F_STAMPAMOVP);
    if (_decidi == 1)
    {
      select_cursor(_cur1);
      if (!provvis)
        _curr1->setfilter("(PROVVIS=\"\")"); 
      else _curr1->setfilter("");
      fl = &(current_cursor()->file(LF_MOV));
      TRectype da (fl->curr());
      TRectype a (fl->curr());
      da.zero();
      a.zero();
      da.put(MOV_NUMREG, _numreg_ini);
      a.put(MOV_NUMREG, _numreg_fin);
      current_cursor()->setregion(da,a);
      add_file(LF_MOV);
      add_file(LF_RMOV,LF_MOV);
      add_file(LF_RMOVIVA,LF_MOV);
    }
    else
    {
      select_cursor(_cur2);
      if (!provvis)
        _curr2->setfilter("(PROVVIS=\"\")");                                         
      else 
        _curr2->setfilter(""); 
      fl = &(current_cursor()->file(LF_MOV));
      TRectype da (fl->curr());
      TRectype a (fl->curr());
      da.zero();
      a.zero();
      if (_data_ini.ok())  
         da.put(MOV_DATAREG, _data_ini);
      if (_data_fin.ok())
         a.put(MOV_DATAREG, _data_fin);
      current_cursor()->setregion(da,a);
      add_file(LF_MOV);
      add_file(LF_RMOV,LF_MOV);
      add_file(LF_RMOVIVA,LF_MOV);
    }
  }
  break;

 case fatture:
{
  fl = &(current_cursor()->file(LF_MOV));
  TString tipo = msk.get(F_TIPOELENCO);
  bool movprov = msk.get_bool(F_STAMPAMOVP); 
  _data_ini = msk.get(F_DATAINI);
  _data_fin = msk.get(F_DATAFIN);
  _annoes   = msk.get_int(F_ANNO);
  if (tipo=="C" || tipo=="F")
  {
    _codice_ini = atol(msk.get(F_CODICEINI));
    _codice_fin = atol(msk.get(F_CODICEFIN));
  }
  else
  {
    _codice_ini = atol(msk.get(F_CODICEINI1));
    _codice_fin = atol(msk.get(F_CODICEFIN1));
  }

  //   _relmov->add(LF_MOV, "NUMREG=NUMREG",1, LF_RMOVIVA,100); //creo un alias per il file LF_MOV
  if (tipo == "E")
  {
    _tipo_ini = "C";
    _tipo_fin = "F";
  }
  else
  {
    _tipo_ini = tipo;
    _tipo_fin = tipo;
  }
  select_cursor(_cur3);
  if (!movprov)
    _curr3->setfilter("(PROVVIS=\"\")");
  else _curr3->setfilter("");
  TRectype da (fl->curr());
  TRectype a (fl->curr());
  da.zero();
  a.zero();
  if (_codice_ini != 0)
    da.put(MOV_CODCF, _codice_ini);
  a.put(MOV_TIPO, _tipo_fin);
  if (_codice_fin != 0)
    a.put(MOV_CODCF, _codice_fin);
  /*
  if (_data_ini.ok())
     da.put(MOV_DATAREG, _data_ini);
  if (_data_fin.ok())
     a.put(MOV_DATAREG, _data_fin);
  */   
  da.put(MOV_TIPO, _tipo_ini);
  current_cursor()->setregion(da,a);
  add_file(LF_MOV);
  add_file(LF_RMOVIVA,LF_MOV);

}

break;

 case movimenti_sezionale:
 break;

 default:
 break;
}

init_print(msk);

return TRUE;
}


void CG3100_application::user_create()
{
  _relmov1 = new TRelation (LF_MOV);
  _relmov2 = new TRelation (LF_MOV);
  _relmov3 = new TRelation (LF_MOV);
  
  _relmov1->add(LF_RMOV,    "NUMREG=NUMREG",1);
  _relmov1->add(LF_RMOVIVA, "NUMREG=NUMREG",1);

  _relmov2->add(LF_RMOV,    "NUMREG=NUMREG",1); 
  _relmov2->add(LF_RMOVIVA, "NUMREG=NUMREG",1);  

  _relmov3->add(LF_RMOVIVA, "NUMREG==NUMREG",1);   
  _relmov3->add(LF_RMOV,    "NUMREG==NUMREG",1); 
  
  _curr1 = new TCursor (_relmov1, "", 1);
  _curr2 = new TCursor (_relmov2, "", 2);
  _curr3 = new TCursor (_relmov3, "", 3);
  
  _cur1 = add_cursor (_curr1);
  _cur2 = add_cursor (_curr2);   
  _cur3 = add_cursor (_curr3);

  //_curr1->set_filterfunction (filter_func);
  //_curr2->set_filterfunction (filter_func);
  //_curr3->set_filterfunction (filter_func_fatture);
  
  _caus    = new TLocalisamfile(LF_CAUSALI);
  _clifo   = new TLocalisamfile(LF_CLIFO);
  _comuni  = new TLocalisamfile(LF_COMUNI);
  _attiv   = new TLocalisamfile(LF_ATTIV);
  _pcon    = new TLocalisamfile(LF_PCON);
  _rmoviva = new TLocalisamfile(LF_RMOVIVA);
  _nditte  = new TLocalisamfile(LF_NDITTE);
  _tabiva  = new TTable(TAB_IVA);
  _tabtpd  = new TTable(TAB_TPD);
  _tabreg  = new TTable("REG");
  _tabes   = new TTable("ESC");
}

void CG3100_application::user_destroy() // releasev e arrmask
{ 
  //delete _msk;
  delete _relmov;
  delete _clifo;
  delete _caus;
  delete _pcon;
  delete _attiv;
  delete _comuni;
  delete _tabiva;
  delete _tabreg;
  delete _tabtpd;
  delete _rmoviva;
}

void CG3100_application::init_print(const TMask& msk)
{
  set_real_picture("###.###.###.###");

  TDate data (msk.get(F_DATASTAMPA));
  printer().setdate(data);

  switch (_tipo_lista)
  {
  case movimenti:
  {
    reset_print();
    _flags = 0;
    _tot_dare_giornaliero  = 0;
    _tot_avere_giornaliero = 0;
    _tot_dare_generale     = 0;
    _tot_avere_generale    = 0;
    if (_scelta_stampa == 0)
    {
      _annoes = msk.get_int(F_ANNO);
      _stampa_parte_iva = (bool)(msk.get(F_STAMPA)=="X");
      if (_stampa_parte_iva)
        _flags |= ST_DATI_IVA;
      _stampa_mess_alleg_iva = (bool)(msk.get(F_ALLEGATO)=="X");
      if (_stampa_mess_alleg_iva)
        _flags |= ST_MESS_ALLEG;
      _stampa_anno_comp = (bool)(msk.get(F_ANNOC)=="X");
      if (_stampa_anno_comp)
         _flags |= ST_ANNO_COMP;   
      _controllo_mov_errati = atoi(msk.get(F_CONTROLLO));
      if (_controllo_mov_errati == 1)
        _flags |= ST_SOLO_MOVERR;
      else if (_controllo_mov_errati == 2)
        _flags |= ST_CONTROLLO;
      else _flags |= ST_SENZA_CONTR;
      if ((_numreg_ini != 0)&&(_decidi == 1))
        _flags |= ST_NUMERO;
      if ((_data_ini.ok())&&(_decidi == 2))
        _flags |= ST_DATA;
      _causale_ini = msk.get(F_CAUSALEINI);
      if (_causale_ini != "")
        _flags |= ST_CAUSALE;
      _registro_ini = msk.get(F_REGISTROINI);
      if (_registro_ini != "")
        _flags |= ST_REGISTRO;
      if ((_data_fin.ok())&&(_decidi == 2))
        _flags |= ST_DATA;
      if ((_numreg_fin != 0)&&(_decidi == 2))
        _flags |= ST_NUMERO;
      _causale_fin = msk.get(F_CAUSALEFIN);
      if (_causale_fin != "")
        _flags |= ST_CAUSALE;
      _registro_fin = msk.get(F_REGISTROFIN);
      if (_registro_fin != "")
        _flags |= ST_REGISTRO;
    }
    else //_scelta_stampa == 1
    {
      _annoes = msk.get_int(F_ANNO);
      if (_numreg_ini != 0)
        _flags |= ST_NUMERO;
      if (_data_ini.ok())
        _flags |= ST_DATA;
      _causale_ini = msk.get(F_CAUSALEINI);
      if (_causale_ini != "")
        _flags |= ST_CAUSALE;
      if (_data_fin.ok())
        _flags |= ST_DATA;
      if (_numreg_fin != 0)
        _flags |= ST_NUMERO;
      _causale_fin = msk.get(F_CAUSALEFIN);
      if (_causale_fin != "")
        _flags |= ST_CAUSALE;
    }
  }
  break;


 case fatture:
{
  _flags = 0;
{
  reset_print();
  _settata_prima_riga = FALSE;
  _tipo_clifo_prec = "";
  _codcf_prec = 0l;
  _numeroregp = 0;
  _documenti = 0;
  _totdocumenti = 0;
  _totimponibile = 0;
  _totimposta = 0;
  _op_esenti = 0;
  _op_non_imp = 0;
  _annoes = msk.get_int(F_ANNO);
  _salto_pagina = (bool)(msk.get(F_CAMBIO)=="X");
  _data_ini = msk.get(F_DATAINI);
  if (_data_ini.ok())
    _flags |= ST_DATA;
  _data_fin = msk.get(F_DATAFIN);
  if (_data_fin.ok())
    _flags |= ST_DATA;
  TString tipo = msk.get(F_TIPOELENCO);
  if ((tipo=="C")||(tipo=="F"))
  {
    _codice_ini = atol(msk.get(F_CODICEINI));
    _codice_fin = atol(msk.get(F_CODICEFIN));
  }
  else
  {
    _codice_ini = atol(msk.get(F_CODICEINI1));
    _codice_fin = atol(msk.get(F_CODICEFIN1));
  }
  if (_codice_ini != 0)
    _flags |= ST_CODICE;
  if (_codice_fin != 0)
    _flags |= ST_CODICE;
  if (tipo == "E")
  {
    _tipo_ini = "C";
    _tipo_fin = "F";
  }
  else
  {
    _tipo_ini = tipo;
    _tipo_fin = tipo;
  }
}
}
break;


 case movimenti_sezionale:
 break;

default:
break;
}
}  

void CG3100_application::preprocess_header()
{
  int soh;       // riga d'inizio dell'intestazione
  TString sep(132);
  TLocalisamfile nditte(LF_NDITTE); 

  nditte.zero();
  nditte.put(NDT_CODDITTA, get_firm());   
  if (nditte.read() == NOERR) 
    _ragsoc = nditte.get(NDT_RAGSOC);
  
  reset_header();
  soh=1;
  sep << "Ditta  " << get_firm();
  sep << " " << _ragsoc;
  sep.left_just(132);
  
  set_header (soh++, (const char*) sep);
  
  sep = "Studio     ";
  sep << "Data @<  Pag. @#";
  
  sep.right_just(127);
  
  switch (_tipo_lista)
  {
  case movimenti:
    if (_scelta_stampa == 0)
    {
      sep.overwrite ("Lista movimenti");
      set_header (soh++, (const char*)sep);
      if (_decidi == 2)
      {
        if (_annoes != 0)
        {
           set_header (soh, "Anno %d", _annoes);
           if (_flags & ST_DATA)
           {
             set_header (soh, "@10gda@13g%s",_data_ini.string()); 
             set_header (soh, "@24ga@26g%s",_data_fin.string());
           }
        }
        else
           if (_flags & ST_DATA)
           {
             set_header (soh, "Dalla data@12g%s",_data_ini.string()); 
             set_header (soh, "@24galla data@34g%s",_data_fin.string());
           }   
           else 
             set_header (soh, "Completa in ordine di data");
      }
      else
        if (_flags & ST_NUMERO)
        {
          set_header (soh, "dal numero@12g%d", _numreg_ini);
          set_header (soh, "@20gal numero@30g%d", _numreg_fin);
        } 
        else
          set_header (soh, "Completa in ordine di numero");
      if (_flags & ST_CAUSALE)
      {
        set_header (soh, "@46gdalla causale@60g%s",(const char*)_causale_ini);
        set_header (soh++, "@64galla causale@77g%s",(const char*)_causale_fin);
      }
      else
        set_header (soh++, "     tutte le causali");
      if (_flags & ST_REGISTRO)
      {
        set_header (soh, "dal registro@14g%s",(const char*)_registro_ini);
        set_header (soh, "@18gal registro@30g%s",(const char*)_registro_fin);
      }
      else
        set_header (soh, "tutti i registri");
      if (_flags & ST_DATI_IVA)
        set_header (soh, "@34gstampa dati iva");
      if (_flags & ST_CONTROLLO)
        set_header (soh, "@50g(controllo movimenti)");
      else if (_flags & ST_SOLO_MOVERR)
        set_header (soh, "@50g(solo movimenti errati)");
      else set_header (soh, "@50g(senza controllo movimenti)");
      if ((_flags & (ST_ANNO_COMP|ST_MESS_ALLEG)) == 1)
        set_header (soh, "@78gcon messaggi: anno di competenza, allegato iva");
      else if (_flags & ST_ANNO_COMP)
        set_header (soh, "@78gcon messaggio: anno di competenza");
      else if (_flags & ST_MESS_ALLEG)
        set_header (soh, "@78gcon messaggio: allegato iva");
      sep.fill('-');
      set_header (++soh, (const char *) sep);
      set_header (++soh, "Rg  Cod Causale@30gDescrizione@56gCodice conto@72gDescrizione conto@98gDare@116gAvere@130gSB");
    }
    else
    {
      sep.overwrite ("Lista movimenti di sola prima nota");
      set_header (soh++, (const char*)sep);
      if (_decidi == 2)
      {
       if (_annoes != 0)
       {
         set_header (soh, "Anno %d", (const char*)_annoes);
         if (_flags & ST_DATA)
         {
           set_header (soh, "@10gda@13g%s",_data_ini.string()); 
           set_header (soh, "@24ga@26g%s",_data_fin.string());
         }
       }
       else
         if (_flags & ST_DATA)
         {
           set_header (soh, "Dalla data@12g%s",_data_ini.string()); 
           set_header (soh, "@24galla data@34g%s",_data_fin.string());
         }   
         else 
           set_header (soh, "Completa in ordine di data");
      } 
      else 
        if (_flags & ST_NUMERO)
        {
         set_header (soh, "@46gdal numero@57g%d", (const char*)_numreg_ini);
         set_header (soh, "@65gal numero@75g%d",(const char*)_numreg_fin);
        }
        else
          set_header (soh, "@46gCompleta in ordine di numero");
      if (_flags & ST_CAUSALE)
      {
        set_header(soh, "@86gdalla causale@100g%3s",(const char*)_causale_ini);
        set_header(soh++,"@103galla causale@116g%3s",(const char*)_causale_fin);
      }
      else
        set_header (soh++, "@86gtutte le causali");
      sep.fill('-');
      set_header (soh++, (const char *) sep);
      set_header (soh++, "Rg  Cod Causale@30gDescrizione@56gCodice conto@72gDescrizione conto@98gDare@116gAvere@130gSB");
    }
    break;

  case fatture:
    sep.overwrite ("Lista fatture");
    set_header (soh, (const char*)sep);
    if (_annoes != 0)
    {
      set_header (soh, "@15gAnno %d", (const char*)_annoes);
      if (_flags & ST_DATA)
      { 
        set_header (soh, "@25gdalla data@36g%s",_data_ini.string()); 
        set_header (soh, "@47galla data@57g%s",_data_fin.string());
      }
    }
    else
      if (_flags & ST_DATA)
      { 
        set_header (soh, "@15gdalla data@26g%s",_data_ini.string()); 
        set_header (soh, "@37galla data@47g%s",_data_fin.string());
      }
      else 
        set_header (soh, "@15gcompleta in ordine di data");
    if (_flags & ST_CODICE)
    {
      set_header (soh, "@99gdal codice@110g%d",_codice_ini);
      set_header (soh, "@117gal codice@127g%d",_codice_fin);   
    }
    sep.fill('-');
    set_header (++soh, (const char *) sep);
    set_header (++soh, "Registrazione @17gCod Protoc.     Documento@49gCod Tp @68gTotale@101gCd  Tp  T O@129gNo");
    set_header (++soh, "Numero  Data@17gReg Numero      Data@42gNumero@49gCau Dc @56gDescrizione@68gDocumento@84gImponibile @101gIv  Det A I@113gImposta@129gAll"); 
    break;
    
  case movimenti_sezionale:
    sep.fill(' ');
    sep.overwrite ("Lista movimenti di solo sezionale");
    set_header (soh++, (const char*)sep);
    sep.fill('-');
    set_header (soh++, (const char *) sep);
    break;

  default:
    break;
  }
  set_header (++soh,(const char*)sep);
  //if (_tipo_lista != fatture)
  //{
  //  sep = "";
  //  set_header (++soh,(const char*)sep);
  //}
}

int cg3100(int argc, char* argv[])
{
  CG3100_application a;
  a.run(argc, argv, "Lista movimenti");
  return 0;
}