campo-sirio/ve/velib.h

#ifndef __VELIB_H 
#define __VELIB_H

#ifndef __VARMASK_H
#include <varmask.h>
#endif

#ifndef __MULTIREC_H
#include <multirec.h>
#endif

#ifndef __VISWIN_H
class TViswin;
#endif

#ifndef __CLIFOR_H
#include "clifor.h"
#endif

#ifndef __CURRENCY_H
#include <currency.h>
#endif
                    
#ifndef __CGLIB01_H
#include "../cg/cglib01.h"
#endif
                    
#ifndef __CGPAGAME_H
#include "../cg/cgpagame.h"
#endif

#ifndef __PRLIB_H
#include "../pr/prlib.h"
#endif

#ifndef __MGLIB_H
#include "../mg/mglib.h"
#endif

#ifndef __COLMASK_H
#include <colmask.h>
#endif

#ifndef __DOC_H
#include <doc.h>
#endif

#ifndef __RDOC_H
#include <rdoc.h>
#endif

#include "../cg/cg2101.h"

#define RIGA_MERCE 'M'
#define RIGA_SPESEDOC 'S'
#define RIGA_PRESTAZIONI 'P'
#define RIGA_SCONTI 'C'
#define RIGA_OMAGGI 'O'
#define RIGA_DESCRIZIONI 'D'

#define MAX_TIPI_DOC 10

#define MAX_IVA_SLICES 5

class TDocumento;
class TRiga_documento;
class TCond_vendita;
class TIVA_array;
class TArticolo_giacenza; 
class TCache_articoli; 


bool scontoexpr2perc(const char * exp, bool signal , TString & goodexp, real & val_perc );
real prezzo_scontato(const real& prezzo, const char * sconto);

bool ora_hndl(TMask_field& field, KEY key);
bool totdoc_hndl(TMask_field& field, KEY key);
bool codcli_hndl(TMask_field& field, KEY key);
bool dummy_hndl(TMask_field& field, KEY key);
bool condpag_hndl(TMask_field& field, KEY key);
bool note_hndl(TMask_field& field, KEY key);
bool data_hndl(TMask_field& field, KEY key);
void set_curr_um(const TString& um);


class TDocumento_variable_field : public TVariable_field
{                                           
  bool _dirty;

  public:
  TObject* dup() const { return new TDocumento_variable_field(*this); }
// @cmember segnala che il campo deve essere ricalcolato
  virtual bool dirty() const { return _dirty;}
// @cmember assegna lo stato di campo da ricalcolare
  virtual void set_dirty(bool on = TRUE) { _dirty = on;}

// @ cmember Costruttore con una espressione di calcolo  
  TDocumento_variable_field(const char * name, const char * expr = "", TTypeexp type = _strexpr)
                          : TVariable_field(name, expr, type), _dirty(TRUE) {}
// @ cmember Costruttore con una funzione
  TDocumento_variable_field(const char * name, VIRTUAL_GET_FUNCTION getfunc)
                          : TVariable_field(name, getfunc), _dirty(TRUE) {}
// @ cmember Costruttore con una espressione di calcolo  
  TDocumento_variable_field(const char * name, const TExpression & expr, TTypeexp type = _strexpr)
                          : TVariable_field(name, expr, type), _dirty(TRUE) {}
// @ cmember Costruttore con un variable_field 
  TDocumento_variable_field(const TVariable_field & f) : TVariable_field(f), _dirty(TRUE) {}
// @ cmember Distruttore  
  virtual ~TDocumento_variable_field() {}
};
            
class TSpesa_prest : public TRectype  // velib01
{                    

protected:

public:
  TObject* dup() const { return new TSpesa_prest(codice()); }

public:       
  int read(const char* codice);

  const TString& codice() const { return get("CODTAB");}  
  const TString& descrizione() const { return get("S0"); } 
  const TString& field_perc() const { return get("S5"); }  
  const TString & um() const { return get("S7"); }
  const TString& cod_iva() const { return get("S3"); }
  real prezzo() const { return get_real("R0"); }
  real qta() const { return get_real("R1"); }
  real perc() const { return get_real("R2"); }
  char tipo() const { return get_char("S6"); }
  char tipo_ritenuta() const { return get_char("S9"); }
  const TString & tipo_riga() const { return get("S8"); }
  char genere() const { return get("COD") == "SPP" ? 'S' : 'P'; }

  TSpesa_prest(const char* codice = NULL, char tipo = 'S');
  TSpesa_prest(const TRectype& rec);
  virtual ~TSpesa_prest() {}
};

/*class TIVA : public TRectype  // velib01
{                    

protected:
  int read(const char* codice);

public:
  TObject* dup() const { return new TIVA(codice()); }

public:       
  const TString& codice() const { return get("CODTAB");}  
  const TString& descrizione() const { return get("S0"); } 
  const real aliquota() const { return get_real("R0"); } 
  const TString& tipo() const { return get("S1"); } 

  TIVA(const char* codice = NULL);
  TIVA(const TRectype& rec);
  virtual ~TIVA() {}
};*/

class TExpr_documento : public TExpression  // velib01
{     
  TDocumento * _doc; 
  TRiga_documento * _row;
  
protected:                       
  virtual void evaluate_user_func(int index, int nparms, TEval_stack & stack, TTypeexp type) const;
  virtual int parse_user_func(const char * name, int nparms) const;

public:            
 // @cmember Duplica l'espressione
  virtual TObject* dup() const;
  
  // @cmember Assegna il documento corrente
  void set_doc(TDocumento* doc) { _doc = doc; }
  // @cmember Assegna il documento corrente
  void set_row(TRiga_documento* row) { _row = row; }
  // @cmember Costruttore (assegna l'estressione e il suo tipo)
  TExpr_documento(const char* expression, TTypeexp type = _numexpr,
                  TDocumento* doc = NULL, TRiga_documento * row = NULL);
  // @cmember Costruttore (assegna il tipo dell'istruzione) 
  TExpr_documento(TTypeexp type = _numexpr,
                  TDocumento* doc = NULL, TRiga_documento* row = NULL)
                 : TExpression(type), _doc(doc), _row(row) {}
  // @cmember Costruttore di copia
  TExpr_documento(const TExpr_documento & expr)
                 : TExpression(expr), _doc(expr._doc), _row(expr._row) {}

  // @cmember Distruttore
  virtual ~TExpr_documento() {}
};

enum TTipo_formula { _documento, _riga };

class TFormula_documento : public TRectype  // velib01
{               
  TString16       _tab;
  TExpr_documento * _expr;
  
protected:
  int read(const char* codice, const char* expr = NULL, bool numexpr = TRUE);

public:
  TObject* dup() const { return new TFormula_documento(_tab == "%FRD" ? _documento : _riga, codice(), NULL, TRUE); }

public:       
  const TString& codice() const { return get("CODTAB");}  
  const TString& name() const { return codice();}
  TExpr_documento* expr() const { return _expr;}
  
  const TString& descrizione() const { return get("S0"); } 
  const TString& expr_string() const { return get("S1"); }
  TTypeexp expr_type() const { return get_bool("B0") ? _numexpr : _strexpr;}
  
  TFormula_documento(TTipo_formula tipo = _documento, const char* codice = NULL, const char* expr = NULL, bool numexpr = TRUE);
  TFormula_documento(const TRectype& rec);
  virtual ~TFormula_documento();
};

class TTipo_documento : public TRectype  // velib03
{              
  enum { _altro, _bolla, _fattura, _ordine};
  
  static TAssoc_array _formule_documento;
  TToken_string _formule;
  TString_array _keys_descrs;   // Tipi riga per listbox
  TString_array _defaults;      // Defaults per i campi della maschera
  TString_array _sheet_columns; // Colonne dello spreadsheet
  TString_array _handlers;      // Handlers
  TString16 _imponibile;
  TString16 _imposta;
  TString16 _totale;
  TString16 _totale_netto;
  TString16 _basesconto; 
  TString16 _spese;
  TString16 _totprovv;
  TString16 _valore;
  TString16 _totvalres;
  TString16 _totvalore;
  TString16 _totale_cont;
  TString16 _field_prezzo;
  TString16 _field_qta, _field_qtaevasa; // Veri campi Quantit<69> e Quantit<69> Evasa
  TString _str_desc_doc, _str_desc_rdoc;

  char _tipocf;  
  char _check_qta;
  bool _cnt_prezzi, _show_evaded_lines;

                
protected:     
  void add_formula_if_needed(TConfig& profile, TString& variable, const char* varname, const char* formula);
  void read_formule();
  int read(const char* tipodoc);
  
public:
  TObject* dup() const { return new TTipo_documento(codice()); }

public:       
//  const TString& profile_name() const { return get("S4"); }
  const TFilename& profile_name(TFilename& name) const;
  
  // Funzioni che effettuano la cache di importanti valori contenuti nel profilo
  const char  tipocf();
  void  set_defaults(TMask& m);
  const TString_array& keys_descrs();
  const TString_array& sheet_columns();
  const TString_array& handlers();
  
  const TString& mask_name() const { return get("S4");}
  const TString& causale() const { return get("S6"); } 
  int tipo() const { return get_int("I1"); }
  const TString& codice() const { return get("CODTAB");}  
  
  bool is_generic() const { return tipo() == _altro; }
  bool is_fattura() const { return tipo() == _fattura; }
  bool is_bolla() const { return tipo() == _bolla; }
  bool is_ordine() const { return tipo() == _ordine; } 
  bool controllo_prezzi() const { return _cnt_prezzi; }
  const char * field_prezzo() const { return _field_prezzo; }
  const TString& field_qta() const { return _field_qta; }
  const TString& field_qtaevasa() const { return _field_qtaevasa; }
  bool check_giac() const { return _check_qta == 'G'; }
  bool check_disp() const { return _check_qta == 'D'; }

  
  const TString & descrizione() const { return get("S0"); } 
  const TString & riferimento(const TDocumento& doc, TString& rif) const;
  const TString & imponibile() const { return _imponibile;}  
  const TString & imposta() const { return _imposta;}  
  const TString & totale_doc() const { return _totale;}  
  const TString & totale_netto() const { return _totale_netto; }
  const TString & totale_doc_cont() const { return _totale_cont;}  
  const TString & basesconto() const { return _basesconto;}  
  const TString & spese() const { return _spese;}  
  const TString & totprovv() const { return _totprovv;}  
  const TString & valore() const { return _valore;}  
  const TString & totvalres() const { return _totvalres;}  
  const TString & totvalore() const { return _totvalore;}  
  bool mov_mag() const { return get_bool("B1"); }
  bool statistiche() const { return get_bool("B2"); }
  bool provvigioni() const { return get_bool("B3"); }
  const char stato_mov_iniziale() const {return get_char("S7"); }
  const char stato_mov_finale() const {return get_char("S8"); }
  const char stato_provvigioni() const {return get_char("S3"); }
  const TString & caus_mov() const {return get("S9"); } 
  const TString & caus_anticipo() const {return get("S10"); } 
  const TString & tipi_iva_validi() const {return get("S11"); }
  const char stato_finale_inserimento() const {return get("S2")[0]; } 
  const char stato_finale_stampa() const {return get("S2")[1]; } 
  const char stato_bloccato() const {return get("S2")[2]; } 
  const TString & stati_iniziali_modifica() const {return get("S2").mid(9,20); } 
  const TString & stati_iniziali_cancellazione() const {return get("S2").mid(29,20); } 
  const TString & stati_iniziali_stampa() const {return get("S2").mid(49,20); } 
  bool stato_with_mov_mag(const char stato) const;
  bool scarica_residuo() const;
  bool clifo_optional() const { return get_bool("B5"); }
 
  TFormula_documento * first_formula() { return succ_formula(TRUE); }
  TFormula_documento * succ_formula(bool restart = FALSE);

  const int ncopie() const { return get_int("I0"); }
  bool spese_aut() const { return get_bool("B0"); }
  bool nota_credito() const { return get_bool("B7"); }
  bool add_conai() const { return get_bool("B6"); }
  bool calcolo_lordo() const { return get_bool("B8"); }
  bool fattura_commerciale() const { return get_bool("B9"); }
  
  const TString& stringa_descrizione_documento() const { return _str_desc_doc; }
  const TString& stringa_descrizione_riga() const { return _str_desc_rdoc; }
  bool mostra_righe_evase_in_elaborazione() const { return _show_evaded_lines; }
  
  TTipo_documento(const char* tipodoc = NULL);
  TTipo_documento(const TRectype& rec);
  virtual ~TTipo_documento();
};
          
class TCodice_numerazione : public TRectype
{
  int _status;

public:
  TObject* dup() const { return new TCodice_numerazione(*this); }

public:
  int read(const char* cod);
  const TString& codice() const { return get("CODTAB"); }
  const TString& descrizione() const { return get("S0"); }
  const TString& prefisso() const { return get("S6"); }
  const TString& postfisso() const { return get("S7"); }
  const bool num_provv() const { return get_bool("B0"); }
  const bool auto_num() const { return get_bool("B1"); }
  const bool dont_test_datadoc() const { return get_bool("B2"); }
  const bool fattura_emettere_ricevere() const { return get_bool("B3"); } 
  const TString & tipo_doc(int i) const;
  int ntipi_doc() const;
  
  void complete_num(long num, TString& codnum) const;
  bool ok() const { return !empty(); }
  TCodice_numerazione(const char* codnum = NULL);
  TCodice_numerazione(const TRectype& rec);
  virtual ~TCodice_numerazione();
};

class TTipo_riga_documento : public TRectype  // velib02
{                    
  static TAssoc_array _formule_riga;
  TToken_string _formule;

  TString16 _imponibile;
  TString16 _quant;
  TString16 _quantevasa;
  TString16 _qtares;
  TString16 _valore;
  TString16 _valres;
  
  TString16 _field_provv;
  TString16 _field_qta, _field_qtaevasa; // Veri campi Quantit<69> e Quantit<69> Evasa
  
  int _decrp, _incrp;

protected:
  void read_formule();
  void add_formula_if_needed(TConfig& profile, TString& variable,
                             const char* varname, const char* formula);

public:
  TObject* dup() const { return new TTipo_riga_documento(codice()); }

public:       
  const TFilename& profile_name(TFilename& name) const;
  const TString& mask_name(TString& name) const;
  const TString& codice() const { return get("CODTAB");}  
    
  const TString& descrizione() const { return get("S0"); } 
  char tipo() const { return get_char("S7"); }
  
  const TString& imponibile() const { return _imponibile;}  
  const TString& quant() const { return _quant;}  
  const TString& quantevasa() const { return _quantevasa;}  
  const TString& field_qta() const { return _field_qta;}  
  const TString& field_qtaevasa() const { return _field_qtaevasa;}  

  const TString& provv() const { return _field_provv;}  
  const int incr_perc_prezzo() const { return _incrp;}  
  const int decr_perc_prezzo() const { return _decrp;}  

  bool formfeed() const { return get_bool("B0"); }
  int detraibilita() const { return get_int("I0"); }
  real perc_indetraibilita() const { return get_real("R0"); }

  TFormula_documento* first_formula() { return succ_formula(TRUE); }
  TFormula_documento* succ_formula(bool restart = FALSE);
  
  int read(const char* tiporig);
  TTipo_riga_documento(const char* tiporig = NULL);
  TTipo_riga_documento(const TRectype& rec);
  virtual ~TTipo_riga_documento() { }
};


class TRiga_documento : public TAuto_variable_rectype  // velib02
{
  TDocumento* _doc; 
  static long _firm;
  static TAssoc_array _tipi;
  static TAssoc_array _spese;
  static TAssoc_array _ive;  
  static TCache_articoli * _articoli;
  static int _iva_calc_mode;

protected:  
   // @cmember Setta il contenuto del campo <p fieldname> (non tipizzata)
  virtual void put_str(const char* fieldname, const char* val);

  virtual TRiga_documento & copy(const TRiga_documento & r);
  TObject* dup() const { return new TRiga_documento(*this); }
  virtual void set_variables(TExpression * e) const ;
  
  static void test_firm();
  
public:  
  void dirty_fields(bool   dirty_document = TRUE); 
  bool doc_dependent() const;
  int numero() const { return get_int(RDOC_NRIGA); }
  void set_numero(int numero) { put(RDOC_NRIGA, numero);}
  bool is_generata() const { return get_bool(RDOC_GENERATA);}
  void generata(bool on = TRUE) { put(RDOC_GENERATA, on);}
  bool is_merce() const { return tipo().tipo() == 'M';}
  bool is_spese() const { return tipo().tipo() == 'S';}
  bool is_prestazione() const { return tipo().tipo() == 'P';}
  bool is_sconto() const {return tipo().tipo() == 'C';}
  bool is_sconto_perc() const { return get(RDOC_SCONTO).not_empty();}
  bool is_omaggio() const { return tipo().tipo() == 'O';}
  bool is_descrizione() const { return tipo().tipo() == 'D';}
  bool is_articolo() const; 
  bool is_checked() const { return get_bool(RDOC_CHECKED);}
  bool is_evadibile() const { return is_merce() || is_omaggio() || is_spese() || is_prestazione(); }
  bool is_evasa() const; // Ritorna vero se la riga <20> evasa
  void checked(bool on = TRUE) { put(RDOC_CHECKED, (bool)on); }
  void unchecked() { checked(FALSE); }
  bool linked() const { return get(RDOC_DACODNUM).not_empty();}
   // @cmember Assegna il documento corrente
  void set_doc(TDocumento * doc) { _doc = doc; }
  const TDocumento & doc() const { CHECK(_doc, "Documento nullo"); return *_doc;}

  virtual void zero(const char * fieldname);
  virtual void zero(char c = '\0');
  // row -> sheet
  void autoload( TSheet_field& f);
  // sheet -> row
  void autosave( TSheet_field& f);

  const TTipo_riga_documento & tipo() const;
  const TSpesa_prest & spesa() const;
  static const TCodiceIVA & iva(const char * codice);
  const TCodiceIVA & iva() const {const TString16 cod(get(RDOC_CODIVA)); return iva(cod);}
  
  const bool tipo_valido() const { return get(RDOC_TIPORIGA).not_empty(); }
  void set_tipo(const char * tipo) { put(RDOC_TIPORIGA, tipo);}
  bool sola_descrizione() const;
  void forza_sola_descrizione();
  
  void set_original_rdoc_key(const TRiga_documento& orig);
  void reset_original_rdoc_key();
  const TRectype* find_original_rdoc() const;
  
  virtual TRiga_documento& operator =(const TRiga_documento& r) { return copy(r);}
  virtual TRectype& operator =(const TRectype & r); 
  virtual TRectype& operator =(const char * r); 
  
  bool raggruppabile(const TRiga_documento& r, TToken_string& campi) const;
  TRiga_documento& operator +=(const TRiga_documento& r);
  
  void reset_fields(TAuto_variable_rectype& rec) { rec.remove_field(); }
  void set_fields(TAuto_variable_rectype& rec);

  real prezzo(bool scontato, bool lordo, int ndec = AUTO_DECIMALS) const ;
  real importo(bool scontato , bool lordo, int ndec = AUTO_DECIMALS) const ;   
  real sconto() const { return importo(FALSE,FALSE) - importo(TRUE,FALSE); }
  real iva(int ndec) const;
  real imponibile(bool lordo = FALSE) const; 
  real imponibile_omaggio(int iva_calc_mode = 1) const; 
  real iva_omaggio(int ndec, int iva_calc_mode = 1) const;
  real imposta(bool round = TRUE) const;
  real provvigione(int ndec = AUTO_DECIMALS) const;
  
  const TString& field_qta() const;
  const TString& field_qtaevasa() const;
  real quantita() const;
  real qtaevasa() const;
  real qtaresidua() const;
  real valore(bool totale, int ndec) const;
  const TString & codice_commessa() const;
  const TString & fase_commessa() const;
  TArticolo_giacenza * articolo() const;

  TRiga_documento(TDocumento* doc, const char* tipo = NULL);
  TRiga_documento(const TRiga_documento & row);
  TRiga_documento(const TRiga_documento& rec, TDocumento* doc,
                  const char* tipo = NULL);
  virtual ~TRiga_documento() {}
};

enum TTipo_importo { _lordo, _netto, _imposta };

class TRiepilogo_iva : public TObject
{ 
  TCodiceIVA _codiva;
  real _imp;
  real _imp_spese;
  real _imp_spese_row;
  real _iva;
  real _iva_spese;
  real _sconto_perc;
  real _sconto_imp;
  real _iva_sconto;
  byte _tipo;                               
  
protected:
  virtual TObject* dup() const { return new TRiepilogo_iva(*this); }
  virtual TRiepilogo_iva & copy(const TRiepilogo_iva & a); 
  
public:
  real imponibile(bool spese = TRUE) const { return _imp + (spese ? _imp_spese : ZERO);} // Imponibile
  real imposta(bool spese = TRUE) const { return _iva + (spese ? _iva_spese : ZERO);} // Iva
  real & imp() { return _imp;};
  real & imp_spese() { return _imp_spese;};
  real & imp_spese_row() { return _imp_spese_row;};
  real & iva() { return _iva;};
  real & iva_spese() { return _iva_spese;};
  real & iva_sconto() { return _iva_sconto;};
  real & sconto_perc() { return _sconto_perc; }
  real & sconto_imp () { return _sconto_imp; }
  const TCodiceIVA & cod_iva() const { return _codiva;}
  byte tipo(){ return _tipo;}// Tipo (Vedi opzioni per la selzione di filtro nella validate())
  TRiepilogo_iva& operator = (const TRiepilogo_iva & a) {return copy(a);}
  TRiepilogo_iva(const TCodiceIVA & codiva); 
  TRiepilogo_iva(const TRiepilogo_iva & a) {copy(a);} 
  TRiepilogo_iva() : _tipo(0) {} 
  ~TRiepilogo_iva() {};
};
             
class TAgente ;

class TDocumento : public TMultiple_rectype  // velib03
{               
  TRecfield *_tipocf;
  TRecfield *_codcf; 
  TRecfield *_cod_occas; 
  char _stato_originale;

  TCli_for _cli_for;
  TOccasionale _occas;
  TPagamento _pag;  
  TAssoc_array _tabella_iva; // tabella di imponibili ed imposte

  TProvvigioni_agente* _provv_agente;
  TString16 _old_agente;     // Agente originale
  
  TRiga_documento * _sconto; // Riga per lo sconto di testata
  TRiga_documento * _esenzione; // Riga per l' esenzione iva
  
  bool _dirty_deny;

  static TAssoc_array _tipi; 
  static TAssoc_array _numerazioni;  
  static long _firm;
  static TString16 _codiva_spese;
  static TString16 _codiva_bolli;
  static short _has_mag;
  static short _has_stat_ven;
  static short _has_provv;
  static TCodgiac_livelli *_livelli;

protected:  
  virtual TRectype * new_body_record(int logicnum = 0) 
  { return new TRiga_documento(this); }

  TRiga_documento & row(int index);
  const TRiga_documento& physical_row(int index) const;

  long get_next_key(char provv, int anno, const char* codnum) const;
  virtual void put_str(const char* fieldname, const char* val);
  virtual const TString & get_str(const char* fieldname) const ;

  long renum_ndoc(long numdoc = 0);  
  virtual bool key_complete() { return numero() > 0; }
  virtual bool renum() { return renum_ndoc() > 0;}
  void set_riga_sconto();
  int write_rewrite(TBaseisamfile & f, bool re) const;
  virtual TDocumento & copy(const TDocumento & d); 
  virtual TObject* dup() const { return new TDocumento(*this); }
  void calc_iva_fattura_commerciale();
  void update_tabella_iva();
  void dirty_tabella_iva() { _tabella_iva.destroy();}
  static void test_firm();
  
  void init();
  void check_modules();
  virtual void set_variables(TExpression * e) const ;
  int set_row_ids();
  
public:                       
  const TString& codiva_spese() const ;
  const TString& codiva_bolli() const ;

  TCodgiac_livelli & livelli() const ;
  void dirty_fields();

  TAssoc_array & tabella_iva() { update_tabella_iva(); return _tabella_iva; }
  TCli_for & clifor() const;
  TOccasionale & occas() const;                       
  const TAgente & agente() const;
  const TString & riferimento(TString& rif) const { return tipo().riferimento(*this, rif); }

  virtual TRecord_array& body(int logicnum = 0) const;
  virtual TDocumento & operator =(const TDocumento & d) {return copy(d);}
  virtual TRectype & operator =(const TRectype & r); 
  virtual TRectype & operator =(const char * r); 
  virtual void zero(const char * fieldname);
  virtual void zero(char c = '\0') { TMultiple_rectype::zero(c); }
  
  int physical_rows() const { return  body().rows(); } 
  int rows() const { return physical_rows() + ((_sconto != NULL) ? 1 : 0) + ((_esenzione != NULL) ? 1 : 0); } 
  const TRiga_documento& operator[](int index) const { return (const TRiga_documento&)((TDocumento *)this)->row(index); }
  TRiga_documento& operator[](int index) { return (TRiga_documento&)row(index); } 
  const TRiga_documento* get_row_id(long id) const;
  
  TRiga_documento& insert_row(int row, const char *tipo = NULL);
  TRiga_documento& new_row(const char *tipo = NULL);
  virtual int read(TBaseisamfile& f, word op = _isequal, word lockop = _nolock);
  virtual int write(TBaseisamfile& f) const { return write_rewrite(f, FALSE); }
  virtual int rewrite(TBaseisamfile& f) const { return write_rewrite(f, TRUE); }
  virtual int remove(TBaseisamfile& f) const;         

  int read(char provv, int anno, const char* codnum, long numdoc, word op = _isequal, word lockop = _nolock);
  int read(const TRectype& rec, word op = _isequal, word lockop = _nolock) { *this = rec; return read(op, lockop); }
  int read(word op = _isequal, word lockop = _nolock) { TLocalisamfile f(LF_DOC); return read(f, op, lockop);}
  
  int write(bool re = FALSE) const { TLocalisamfile f(LF_DOC); return write_rewrite(f, re);}
  int rewrite() const { return write(TRUE); }
  int remove() const { TLocalisamfile f(LF_DOC); return remove(f);}
  int decimals(bool price = FALSE) const;
  
  void flush_rows();
  
  TProvvigioni_agente& calc_provvigioni(const bool generata = TRUE);
  int write_provvigioni() { return calc_provvigioni().write();}

  char tipo_numerazione() const { return get_char("PROVV"); }
  int anno() const { return get_int("ANNO"); }
  const TString& numerazione() const { return get("CODNUM"); }
  long numero() const { return get_long("NDOC"); }
  TDate data() const { return get_date("DATADOC"); }
  bool in_valuta() const;
  const TString& valuta() const { return get("CODVAL"); }
  real cambio() const { return get_real("CAMBIO"); }    
  bool tipo_valido() const { return get("TIPODOC").not_empty(); }
  static const TTipo_documento& tipo(const char * tipodoc);                  
  const TTipo_documento& tipo() const;                  
  static const TCodice_numerazione& codice_numerazione(const char * numerazione);
  const TCodice_numerazione& codice_numerazione() const;
  void set_tipo(const char * tipo) { head().put("TIPODOC", tipo);}
  bool provvisorio() const { return get_char("PROVV") == 'P'; }
  char stato() const { return get_char("STATO"); }
  void stato(char s) { put("STATO", s); }
  const TString & codice_commessa() const { return get(DOC_CODCMS);}
  const TString & fase_commessa() const { return get(DOC_FASCMS);}
  bool modificabile() const;
  bool cancellabile() const;
  bool stampabile() const;
  bool bloccato() const;

  bool raggruppabile() const { return get_bool("RAGGR"); }
  bool raggruppabile(const TDocumento& doc, TToken_string& campi) const;
  
  char tipocf() const {return *(const char *) (*_tipocf);}
  long codcf() const {return (long) *_codcf;}
  const char * cod_occas() const { return (const char *) *_cod_occas; }
  
  static void set_key(TRectype& rec, char provv, int anno, const char* codnum, long numdoc);
  static void copy_data(TRectype& dst, const TRectype& src);
  static void copy_data(TRiga_documento& dst, const TRiga_documento& src);
  void copy_contents(const TDocumento & src);
  
  void set_fields(TAuto_variable_rectype & rec);
  void set_riga_esenzione();

  void iva_esente(TString & codiva_es) const;
  real spese_incasso(real & imp, int ndec, TTipo_importo netto = _lordo) const ;
  real bolli(real & imp, int ndec, TTipo_importo netto = _lordo) const ;

  real imponibile(bool spese = FALSE, int ndec = AUTO_DECIMALS) const;
  real imposta(bool spese = FALSE, int ndec = AUTO_DECIMALS) const;
  real totale_doc() const;
  real totale_netto() const;
  real basesconto() const;
  real spese() const;
  real provvigione(int ndec = AUTO_DECIMALS) const;
  real valore(bool totale, int ndec = AUTO_DECIMALS) const;
  
  TPagamento & pagamento();
  
  void update_spese_aut(TString_array & spese, bool preserve_old = FALSE, TSheet_field * sh = NULL);
  real calc_conai_qta(int type);
  void update_conai();
  
    bool is_generic() const { return tipo_valido() && tipo().is_generic(); }
  bool is_fattura() const { return tipo_valido() && tipo().is_fattura(); }
  bool is_bolla() const { return tipo_valido() && tipo().is_bolla(); }
  bool is_ordine() const { return tipo_valido() && tipo().is_ordine(); }
  bool is_evaso() const;
  bool is_nota_credito() const;

  TDocumento ();
  TDocumento (const TDocumento & d);
  TDocumento(char provv, int anno, const char* codnum, long numdoc);
  TDocumento(const TRectype& doc);
  virtual ~TDocumento();
 };

class TCurrency_documento : public TCurrency
{
protected:
  void copy(const TCurrency& cur) {TCurrency::copy(cur); }

public:
  const TCurrency_documento& operator=(const TCurrency_documento& cur) { copy(cur); return *this; }
  const TCurrency_documento& operator=(const TCurrency& cur) { copy(cur); return *this; }

  TCurrency_documento(const TCurrency& cur) { copy(cur); }
  TCurrency_documento(const TCurrency_documento& cur) { copy(cur); }
  TCurrency_documento(const real& num, const TDocumento &doc, bool price = FALSE);
  virtual ~TCurrency_documento() { }
};

class TCodgiac_livelli;

class TDocumento_mask : public TVariable_mask  // velib06
{
  int _progs_page;       // pagina in cui cominciano i progressivi
  int _last_prog;        // numero dell'ultimo progressivo
  TSheet_field* _sheet;  // Spreadsheet
  TDocumento _doc;       // documento                    
  TCodgiac_livelli * _livelli_giac;// livelli di giacenza
  
  TCond_vendita* _condv; // condizioni di vendita
  TAssoc_array _maskriga;// Maschere delle righe

  bool _ges_mag, _ges_dep;
  TString _std_mag, _std_dep;

protected:
  void update_progs();
  virtual void next_page(int p);
  virtual bool stop_run(KEY key);
  void sconto_testa2mask();
  void spese2mask();

  void configura_sheet(TSheet_field& sheet);
  static bool ss_notify(TSheet_field& ss, int r, KEY key);
  static bool ss_handler(TMask_field& f, KEY key);
  static TMask* ss_getmask(int numriga, TMask& fullmask);
  
  static bool occas_handler( TMask_field& f, KEY key );
  static bool occas_code_handler( TMask_field& f, KEY key );
  static bool clifo_handler( TMask_field& f, KEY key );
  static bool print_handler( TMask_field& f, KEY key );
  static bool elabora_handler( TMask_field& f, KEY key );
  static bool codlist_handler( TMask_field& f, KEY key );
  static bool codcont_handler( TMask_field& f, KEY key );
  static bool codcamp_handler( TMask_field& f, KEY key );
//  static bool controeuro_handler( TMask_field& f, KEY key );
  static bool datacambio_handler( TMask_field& f, KEY key );
  static bool codval_handler( TMask_field& f, KEY key );
  void user_set_handler( int fieldid, int index);

  void reset_masks(const TString& tipo_doc);

public:
  TVariable_mask* riga_mask(int numriga);
  virtual bool on_key(KEY key);

  TDocumento& doc() { return _doc; }
  const TDocumento& doc() const { return _doc; }
  TCond_vendita & condv() const;

  void occ2mask();
  void cli2mask();
  void doc2mask(bool reload_clifo = TRUE);
  void mask2doc();

  void update_giacenza();
  
  const TString& stdmag() const { return _std_mag; }
  const TString& stddep() const { return _std_dep; }


  TSheet_field& sheet() const { return *_sheet; }
  TCodgiac_livelli& livelli() const { return *_livelli_giac; }
  static bool anno_handler( TMask_field& f, KEY key);
  static bool num_handler( TMask_field& f, KEY key );
  static bool tip_handler( TMask_field& f, KEY key );
  static bool numdocrif_search_handler( TMask_field& f, KEY key );
  static bool datadocrif_handler(TMask_field& f, KEY key);

  void highlight(COLOR high_back_color, COLOR high_color);
  
  TDocumento_mask(const char* tipodoc);
  virtual ~TDocumento_mask();
};

class TLista_documenti : public TObject  // velib04
{ 
  TArray _documenti;
  
protected:  
  const TDocumento& doc(int n) const { return (const TDocumento&)_documenti[n]; }
  TDate num2date(char provv, int anno, const char* codnum, long num) const;

public:
  int read(char provv, char tipo, long clifo, int anno, 
           TToken_string& tipidoc, TToken_string& statidoc,
           const TDate& dd, const TDate& ad, 
           const char* codnum = "", long dn = 0L, long an = 0L);
  int write(bool re = FALSE) const;
  int rewrite() const { return write(TRUE); }
  
  int add(TDocumento* doc) { return _documenti.add(doc); }
  int add(const TDocumento& doc) { return _documenti.add(doc); }
  int destroy(int i, bool pack = TRUE) { return _documenti.destroy(i, pack); }
  
  const TDocumento& operator[] (int n) const { return doc(n); }
  TDocumento& operator[] (int n) { return (TDocumento&)_documenti[n]; }
  int items() const { return _documenti.items(); }

  TLista_documenti() { }
  virtual ~TLista_documenti() {};
};

class TLista_clifo : public TObject  // velib04
{                
  class TClifo : public TObject
  { 
    long _codice;
    long _agente;
    long _zona;
    
  protected:
    void zero() { _codice = _agente = _zona = 0L; }  
    void init(const TRectype& rec, const TRectype& ven); 
    bool read(char tipo, long cod);
  
  public: // TObject
    virtual bool ok() const { return _codice > 0; }
  
  public:     
    long codice() const { return _codice; }
    long agente() const { return _agente; }
    long zona() const { return _zona; }
  
    TClifo() { zero(); }
    TClifo(char tipo, long cod) { read(tipo, cod); }
    TClifo(const TRectype& rec, const TRectype& ven) { init(rec, ven); }
    TClifo(const TRectype& rec);
    virtual ~TClifo() { }
  };

  TArray _clifo;
  
protected:  
  virtual char tipo() const pure;
  const TClifo& clifo(int n) const { return (TClifo&)_clifo[n]; }
  
  static int sort_by_code(const TObject** o1, const TObject** o2);
  static int sort_by_agent(const TObject** o1, const TObject** o2);
  static int sort_by_zone(const TObject** o1, const TObject** o2);

public:
  int ordina_per_codice();
  int ordina_per_agente();
  int ordina_per_zona();
  
  int leggi(long dc, long ac, long da = 0, long aa = 0, const char * dz = "", const char * az = "");
  
  long operator[] (int n) const { return clifo(n).codice(); }
  int items() const { return _clifo.items(); }
  int find(long cod) const;
  int add(long cod);

  TLista_clifo() { }
  virtual ~TLista_clifo() { }
};

class TLista_clienti : public TLista_clifo 
{
protected:
  virtual char tipo() const { return 'C'; }
};

class TLista_fornitori : public TLista_clifo 
{
protected:
  virtual char tipo() const { return 'F'; }
};
     
enum TTipo_elaborazione {_esterna, _consegna_ordini, _fatturazione_bolle, _contabilizzazione,  _copia_documento, _generazione_effetti };

class TParametri_elaborazione : public TObject // velib04
{      
  TAssoc_array _par;

public:  
  void set(const char * name, const char * val);
  void set(const char * name, const real & val) { set(name, val.string());}
  
  const TString & get(const char * name) const ;
  const real get_real(const char * name) const { return (real) get(name);}
  
  TParametri_elaborazione & copy(const TParametri_elaborazione & p) { _par = p._par; return *this;}
  virtual TObject* dup() const { return new TParametri_elaborazione(*this); }
  TParametri_elaborazione & operator =(const TParametri_elaborazione & p) {return copy(p);}
  TParametri_elaborazione() { }
  TParametri_elaborazione(const TParametri_elaborazione & p) {copy(p);}
  virtual ~TParametri_elaborazione() { }
};

class TElaborazione : public TRectype // velib04
{ 
  TParametri_elaborazione _parms;
  
protected:
  int read(const char* cod);

public:
  enum  { _max_tipi_doc_elab = 10 };
  const TString& codice() const { return get("CODTAB"); }
  const TString& descrizione() const { return get("S0"); }
  const TTipo_elaborazione tipo() const { return (TTipo_elaborazione) get_int("I0"); } 

  bool doc_uguale(int u) const  { return get("S1")[u] == 'X'; }
  bool riga_uguale(int u) const { return get("S1")[40+u] == 'X'; }
  
  bool raggruppa_righe() const      { return get_bool("B0"); }
  bool gestione_riferimenti() const { return get_bool("B1"); }
  bool riferimenti_in_testa() const { return get_bool("B2"); }
  bool ignora_descrizioni() const   { return get_bool("B3"); }
  char tipo_numerazione() const     { return get_bool("B4") ? 'P' : 'D'; }
  bool prezzo_da_ordine() const     { return get_bool("B5"); }
  bool aggiorna_testata_se_vuoto() const { return get_bool("B6"); }
  bool ordina_per_codice() const     { return get_bool("B7"); }
  bool usa_doc_rif() const     { return get_bool("B8"); }
  
  int intestazioni_sheet() const { return get_int("I1"); }

  const TString& codice_numerazione_iniziale() const { return get("S5"); }
  const TString tipo_iniziale(int i) const { return get("S2").smid(i*4, 4).rtrim(); }
  const char stato_iniziale(int i) const { return i < 5 ? get("S7")[i] : get("S10")[i - 5]; }
  const TString& tipo_finale() const { return get("S8"); }
  const TString& stato_finale_doc_iniziale() const { return get("S4"); }
  const TString& stato_finale() const { return get("S9"); }
  
  const TString& codice_numerazione_finale() const { return get("S6"); }
  const TString& applicazione_esterna() const { return get("S3"); }
  void set_params(const TParametri_elaborazione & parms) { _parms = parms;}
  TParametri_elaborazione & params() { return _parms;}
  
  virtual bool elabora(TLista_documenti& doc_in, TLista_documenti& doc_out,
                       const TDate& data_elab, bool interattivo = FALSE) pure;

  TElaborazione(const char* cod);
  TElaborazione(const TRectype& rec) : TRectype(rec) { }
  virtual ~TElaborazione() { }
};

class TElaborazione_esterna : public TElaborazione  // velib04
{ 
public:
  virtual bool elabora(TLista_documenti& doc_in, TLista_documenti& doc_out,
                       const TDate& data_elab, bool interattivo = FALSE);

  TElaborazione_esterna(const char* cod);
  TElaborazione_esterna(const TRectype& rec) : TElaborazione(rec) { }
  virtual ~TElaborazione_esterna() { }
};

class TConsegna_ordini : public TElaborazione  // velib04d
{ 
public:
  virtual bool elabora(TLista_documenti& doc_in, TLista_documenti& doc_out,
                       const TDate& data_elab, bool interattivo = FALSE);

  TConsegna_ordini(const char* cod);
  TConsegna_ordini(const TRectype& rec) : TElaborazione(rec) { }
  virtual ~TConsegna_ordini() { }
};

class TFatturazione_bolle : public TElaborazione  // velib04a
{ 
  TToken_string _cod_desc;

public:
  virtual bool raggruppa(TDocumento& din, TDocumento& dout);
  virtual bool elabora(TLista_documenti& doc_in, TLista_documenti& doc_out,
                       const TDate& data_elab, bool interattivo = FALSE);
                       
  void tipi_validi(TToken_string& tipi) const;                     
  void stati_validi(TToken_string& stati) const;                     
  
  TFatturazione_bolle(const char* cod);
  TFatturazione_bolle(const TRectype& rec) : TElaborazione(rec) { }
  virtual ~TFatturazione_bolle() { }
};

// Tipi di errore validi solo per TContabilizzazione e TGenerazione_effetti

enum error_type {
  no_error,
  nr_es_error,
  nr_reg_error,
  nr_doc_error,
  chg_stat_error,
  clifo_error,
  ultprot_error,
  datadoc_error,
  caus_error,
  causre_error,
  cauval_error,
  ivasto_error,
  register_error,
  change_error,
  val_error,
  codpag_error,
  row_type_error,
  no_rows_error,
  conto_error,
  sconto_error,
  spinbo_error,
  movement_error,
  write_error,
  scadenze_error,
  bank_error,
  caus_ant_error,
  counter_p_ant_error,
  cau_abb_error,
  cau_spe_error,
  write_part_error,
  intra_mov_error,
  cont_seq_error,
  cau_ritintra_error,
  generic_error
};

class TBill;
class TMovimentoPN_VE;
class TSaldo_agg;


class TContabilizzazione : public TElaborazione  // velib04b
{ 
  bool                _auto_data; // Flag per data di registrazione automatica
  bool                _nump_iva;  // se TRUE prende il numero protocollo da registro iva, se no prende il numero protocollo dal numero doc.
  TDate               _data_reg;  // Data di registrazione documenti
  long                _total_docs;// Numero di documenti contabilizzati
  error_type          _error;     // Errore rilevato durante l'elaborazione
  bool                _can_write; // se TRUE e' abilitata la scrittura. Non appena rileva un errore rimane a FALSE for this instance
  TString16           _spin_cod,  // codice iva spese d'incasso
                      _spbo_cod;  // codice iva spese bolli
  TAssoc_array        _totali_lordi;// array per totalizzare i lordi per aliquota, al fine di aggiustare gli imponibili
                                    // nel caso di calcolo lordo sul documento
  TIVA_array          *_righe_iva; // array per la memorizzazione delle righe iva raggruppate in codesto modo:
                                   // CODICE_IVA+TIPOCF+GRUPPO+CONTO+SOTTOCONTO+COMMESSA+FASE+DETRAIBILITA
                                   // una volta completo, tale array viene scorso per comporre le righe IVA
                                   // del movimento
  
  // Files, tabelle, oggetti contabili ed altre amenita'...
  TLocalisamfile      *_anamag,   // file delle anagrafiche di magazzino
                      *_fcaus,
                      *_frcaus,
                      *_attiv,
                      *_part,
                      *_scad,
                      *_pags,
                      *_intra,
                      *_rintra,
                      *_occas,
                      *_saldi,
                      *_docfile,
                      *_rdocfile;

  TTable              *_cpg,      // tabella condizioni di pagamento
                      *_gmc,      // tabella gruppi/sottogruppi merceologici
                      *_rfa,      // tabella raggruppamenti fiscali
                      *_cve,      // tabella categorie di vendita
                      *_val,      // tabella valute estere
                      *_tri,      // tabella tipi di riga
                      *_prs,      // tabella prestazioni
                      *_spp,      // tabella spese
                      *_caa,      // tabella categorie acquisto articoli
                      *_cra,      // tabella categorie ricavo articoli
                      *_cco;      // tabella categorie contabili
  TRelation           *_clifo;    // relazione dei clienti e fornitori + cfven
  TViswin*  _viswin;              // Visualizzazione log di elaborazione
  TBill _conto_errato;            // Conto da visualizzare in messaggio d'errore
  bool _check_prev_cont;          // Controllare se il documento precedente e' stato contabilizzato
                                                                                                   
protected:
  // Carica i parametri dalla configurazione
  bool load_parameters();        
  // Testa il fatto che il documento sia una nota di credito/debito
  bool test_swap();
  // Ritorna l'ultimo numero di registrazione disponibile dei movimenti di prima nota
  error_type   get_next_reg_num(long &);
  // Compila la testata del movimento
  error_type   compile_head_mov(TDocumento&);
  // Compila la testata del movimento per le fatture da emettere / ricevere;
  error_type   compile_head_mov_re(TDocumento&);
  // Funzione per ricercare il conto di costo/ricavo
  error_type   search_costo_ricavo(TBill&, const TRiga_documento&);
  // Funzione per aggiungere la riga iva al TAssoc_array _righe_iva
  //  error_type   add_iva_row(const TBill&, const TRiga_documento&, const int ndec, const real p = 1.0);
  // Funzione atomica per aggiungere le righe di spese d'incasso e bolli al TAssoc_array _righe_iva
  void calculate_spese(real&, real&, int, bool, bool, const TString &, const TDocumento & );
  // Funzione per aggiungere le righe di spese d'incasso e bolli al TAssoc_array _righe_iva (chiama calculate_spese())
  error_type   add_spese_inbo(TDocumento&, const int);
  // Aggiorna le righe di sconto importo o percentuale
  error_type   adjust_sconto_rows(TDocumento&);
  // Controlla la corrispondenza tra limposta del documento e quelle generate
  error_type   adjust_iva_rows(TDocumento&);
  // Crea le righe iva sul movimento
  error_type   create_iva_rows(TDocumento&);
  // Crea la riga di totale documento
  error_type   create_total_doc_row(TDocumento&);
  // Compila le righe del movimento
  error_type   compile_rows_mov(TDocumento&);
  // Compila le righe del movimento  per le fatture  da emettere / ricevere
  error_type   compile_rows_mov_re(TDocumento&);
  // scrive le scadenze
  error_type write_scadenze(TDocumento&);
  // scrive il movimento e le scadenze
  virtual error_type write_all(TDocumento& doc, TMovimentoPN_VE & movimento);
  // scrive il movimento e le scadenze per le fatture da emettere / ricevere
  virtual error_type write_all_re(TDocumento& doc, TMovimentoPN_VE & movimento);
  // restituisce la sezione per sto cliente
  char sezione() const;
  // Cerca il conto cliente per il movimento d'anticipo
  error_type search_clifo_bill(TString &);
  // Cerca il conto di contropartita per il movimento d'anticipo
  error_type search_counter_bill(TDocumento&);
  // compila la testata del movimento di anticipo
  error_type compile_head_anticipo(TDocumento&);
  // compila le righe del movimento di anticipo
  error_type compile_rows_anticipo(TDocumento&);
  // compila e scrive il pagamento del movimento di anticipo
  error_type write_pagamento_anticipo(TDocumento&);
  // scrive il movimento di anticipo pagamento
  error_type write_anticipo(TDocumento&);
  // scrive il movimento INTRA
  error_type write_intra(TDocumento&);
  // Aggiorna i saldi
  void aggiorna_saldi(TSaldo_agg& saldo, TMovimentoPN& mv, bool save);
  // Visualizza l'ultimo errore rilevato
  void display_error(TDocumento&);
  // Verifica se non ci sono stati errori
  bool good() const { return _error == no_error;}
  // Ritorna TRUE se il saldaconto e' abilitato (verifica anche la causale del documento corrente)
  bool   sc_enabled() const ; 
  // Ritorna TRUE se il modulo INTRA  e' abilitato (verifica anche la causale del documento corrente)
  bool   in_enabled() const ; 
public:
  // Cambia lo stato del documento
  error_type   change_doc_status(TDocumento&);
  virtual bool elabora(TLista_documenti& doc_in, TLista_documenti& doc_out,
                       const TDate& data_elab, bool interattivo = FALSE);
  void set_auto(const bool a) { _auto_data = a; }
  void set_writeable(const bool b) { _can_write = b; }
  const long processed_docs() const { return _total_docs; }                        
  void inc_processed_docs() { _total_docs++; }
  
  // Ritorna il numero dell'eventuale movimento con cui il documento stato contabilizzato                                                    
  long doc_contabilized(const TDocumento& doc, bool anticipo) const;

   // Personalizzazioni
  bool call_exe(const TDocumento& doc, const TMovimentoPN& movimento) const;
                                                     
  // Ritorna TRUE se il documento precedente a doc e' gia' stato contabilizzato                                                    
  bool prev_contabilized(const TDocumento& doc) const;

  TContabilizzazione(const char* cod);
  TContabilizzazione(const TRectype& rec);
  virtual ~TContabilizzazione();
};

///////////////////////////////////////////////////////////
// TContabilizzazione
///////////////////////////////////////////////////////////

// TMovimentoPN_VE
// Classe derivata da TMovimentoPN per calcolare automaticamente le righe conabili
// una volta settate le righe iva e la riga di totale documento
// Sostanzialmente di tratta di aggiungere un metodo in piu' :
// recalc_cg_rows(), liberamente ispirato alla notify_iva() in cg2102.cpp

class TMovimentoPN_VE : public TMovimentoPN
{
  TCausale * _caus;
  bool     _valuta;
  
protected:
  // simula il K_SPACE di iva_notify
  void create_row(int i, const TString & descr_cr);
  // simula il K_ENTER di iva_notify
  void enter_row(int i, const TString & descr_cr);
  // verifica se si tratta di iva indetraibile
  bool detraibile(TRectype& rec) const ;
  // cerca la prima tra quelle di contabilita' che corrisponde al tipo indicato 
  int type2pos(char tipo);
  // Trova nelle righe contabili un conto nelle righe di tipo prescelto
  int bill2pos(const TBill& conto, const TString & codcms, const TString & fascms, char tipo);
  // trasforma un real in TImporto, in base al tipo riga
  TImporto real2imp(const real& r, char row_type);
  // setta il record delle righe di contabilita'
  int insert_cg_rec(int n, const TImporto& imp, TBill& conto, const char * codcms, const char * fascms, const char* desc, char tipo);
  // setta il record delle righe di contabilita'
  int set_cg_rec(int n, const TImporto& imp, TBill& conto, const char * codcms, const char * fascms, const char* desc, char tipo);
  // aggiunge l'importo indicato alla n-esima riga di contabilita'
  bool add_cg_rec(int n, const TImporto& imp);
  // Legge l'importo della riga n e lo ritorna col segno dovuto
  TImporto get_cg_imp(int n);
  // Setta l'importo della riga n 
  void set_cg_imp(int n, const TImporto& imp);
  // verifica se il movimento e' quadrato oppure ha qualche maledetto sbilancio
  // ritorna TRUE, ovviamente, se everything's alright.
public:
  // ricalcola le righe di contabilita' dalle righe iva presenti
  // e verifica la quadratura del movimento. Ritorna TRUE se il movimento e' scrivibile
  void set_caus(TCausale * c) { _caus = c;}
  bool movement_ok() ;
  void add_row_re(int i);
  bool add_row_cp_re(int i);
  void map_conto_re(TBill & c);
  void destroy_iva_row(int i = -1);
  int recalc_cg_rows(const TString & descr_cr, TCausale & caus);
  TMovimentoPN_VE(bool valuta) : _valuta(valuta), _caus(NULL) {};
  virtual ~TMovimentoPN_VE() {}
};

class TCopia_documento : public TElaborazione  // velib04
{ 
public:
  virtual bool elabora(TLista_documenti& doc_in, TLista_documenti& doc_out,
                       const TDate& data_elab, bool interattivo = FALSE);

  TCopia_documento(const char* cod);
  TCopia_documento(const TRectype& rec) : TElaborazione(rec) { }
  virtual ~TCopia_documento() { }
};


class TGenerazione_effetti : public TElaborazione  // velib04c
{ 
  error_type     _error;       // Errore rilevato durante l'elaborazione
  long           _total_bills; // Totale effetti generati
  bool           _can_write;   // se TRUE e' abilitata la scrittura. Non appena rileva un errore rimane a FALSE for this instance
  TBit_array     _valid_array; // array dei tipi di pagamento validi per la generazione di effetti

  TLocalisamfile *_efffile,    // file effetti
                 *_refffile,   // file righe di effetti
                 *_cessfile,
                 *_docfile,
                 *_rdocfile,
                 *_clifo,
                 *_cfven,
                 *_tab,
                 *_occas;
  TArray         _effetti_array;//Array di effetti (TEffetto) da scrivere
protected:
  // Visualizza l'ultimo errore rilevato
  void display_error(TDocumento& doc);
  // Restituisce TRUE se il tipo di pagamento passato e' valido per generare l'effetto
  bool   valid_type(int) const ;
  // Genera l'effetto
  void   generate_bill(TDocumento&);
  // Istanzia il pagamento corrente
  void   calc_pagamento(TDocumento&);
  // Scrive i record array degli effetti raggruppati
  error_type write_groups();
  // Cambia lo stato dei gruppi di documenti raggruppati in effetti
  error_type change_group_status(TDocumento&, TAssoc_array&);
  // Cambia lo stato del documento
  error_type change_doc_status(TDocumento&);
  // Verifica se non ci sono stati errori
  bool good() const { return _error == no_error;}
public:
  virtual bool elabora(TLista_documenti& doc_in, TLista_documenti& doc_out,
                       const TDate& data_elab, bool interattivo = FALSE);
                           
  // Effettua il raggruppamento vero e proprio degli effetti (solo se ci sono elementi nell'assoc_array passato)
  long   group_bills(TAssoc_array&);
  long bills() const { return _total_bills; }
//  void set_group(TAssoc_array& a) { _group_array = a; }
  void set_writeable(const bool b) { _can_write = b; }
  
  TGenerazione_effetti(const char* cod);
  TGenerazione_effetti(const TRectype& rec);
  virtual ~TGenerazione_effetti();
};

class TLista_elaborazioni : public TObject  // velib04
{    
  TAssoc_array * _elab;            
  
protected:
  void read();
    
public:                                     
  TElaborazione & operator [](const char * key) const;
  int select(TString_array & result, const char * tipo_iniziale = NULL, const char * stato_iniziale = NULL, const char * tipo_finale = NULL, const char * stato_finale = NULL);
  void update(); 
  TLista_elaborazioni() : _elab(NULL) {}
  virtual ~TLista_elaborazioni();
};

struct dec_parm {
  int qta_lit, 
      qta_val;
      // add other groups here
};

//////////////////////////////////////////////////////////////////////////////////////////////
// classe TDocumentoEsteso: oggetto che ha come finalita' il calcolo dei riepiloghi IVA
//////////////////////////////////////////////////////////////////////////////////////////////

class TDocumentoEsteso : public TDocumento
{ 
  // Parametri del documento
  dec_parm        _parm;          // Parametri per gli arrotondamenti
  
  // Totali del documento ricalcolati non appena la tabellina di riepilogo IVA e' completa
//  real _importi_netti, _imposte;

  // membri per il calcolo del riepilogo IVA
  bool            _sum_selected;  // TRUE se ha selezionato una riga del riepilogo, funge da semaforo per leggere la prossima
  int             _sum_filter;    // Filtro corrente della riga TRiepilogo_iva in corso di stampa (-1 se non ha ancora calcolato la tabella)
  TString_array   _order_array;   // Array di TToken_string contenenti i codici IVA soddisfacenti ad ogni tipo di filtro
  TAssoc_array    _summary_table; // Array associativo contenete imonibili ed imposte pronte per la stampa;
  TArray          _summary_array; // Array dove vengono memorizzate le imposte/imponibili per riga
  TRiepilogo_iva  _sum_current;   // Riga corrente del riepilogo

  // membri per il calcolo del riepilogo scadenze
  TString_array   _scadenze_array;// Array che contiene le scadenze ("<data>|<importo>")
  int             _scadenze_current;  // indice per identificare l'elementi corrente sull'array (-1 se non ha ancora calcolato)

public: 
  // Funzioni per il riepilogo IVA
  const bool summary_compiled() { return _sum_filter > -1; }
  void compile_summary(); // Aggiorna la tabella riepilogativa    
  void summary_filter(byte selector);  // filtra la tabellina secondo il filtro corrente se non e' gia' stato fatto
  void summary_reset(bool force=FALSE); // riposiziona l'array dei codici IVA (_order_array). Se il parametro e' TRUE forza il ricalcolo della tabella 
  void summary_set_next(); // seleziona il prossimo elemento del filtro
  const TRiepilogo_iva& sum_current() const { return _sum_current; } // ritorna la riga corrente del filtro corrente
  const char * summary_get(const TString& w); // ritorna l'informazione richiesta estratta dall'elemento corrente
  int  summary_items() { return tabella_iva().items();} // ritorna il numero di righe in totale della tabellina
  const TAssoc_array& summary() const { return _summary_table; }
  const TArray& summary_array() const { return _summary_array;}
  
  // Funzioni per il ricalcolo delle scadenze
  void scadenze_reset(); // riposiziona sulla prima scadenza
  void scadenze_recalc(); // resetta e ricalcola le scadenze
  void scadenze_set_next(); // seleziona il prossimo elemento dell'array delle scadenze
  const char * scadenze_get(const TString& w); // reperisce l'informazione richiesta dall'elemento corrente
  int  scadenze_items() { return _scadenze_array.items(); }  // restituisce il numero di scadenze
  TString_array& scadenze() { return _scadenze_array; }

  // restituisce tot_imponibili, tot_esenti, tot_nonsoggetti a seconda del selettore:  
  // 1 = regime normale
  // 2 = da ventilare (non usato)
  // 4 = esenti
  // 8 = non imponibili
  // 16 = non soggetti
  // pertanto i non imponibili avranno selettore 1 e gli esenti selettore 4.
  // per avere esenti + non soggetti il selettore sara' 20 e cosi' via.
  real tot_imponibili(byte selector);
  
  // Funzioni per settare i parametri
  void set_decimals(dec_parm & parm) { _parm = parm ; }
//  void set_condv(TCli_for * cli); // Cambia le condizioni di vendita
  TDocumentoEsteso (const TRectype & rec, dec_parm & parm) ;
  TDocumentoEsteso (const TRectype & rec) ;
  TDocumentoEsteso () ;
  virtual ~TDocumentoEsteso();
};

#endif