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 "../ve/clifor.h"
#endif
              
#ifndef __RELAPP_H
#include <relapp.h>
#endif
                    
#ifndef __CGLIB01_H
#include "../cg/cglib01.h"
#endif
										
#ifndef __CGPAGAME_H
#include "../cg/cgpagame.h"
#endif

#ifndef __PRLIB_H
class TProvvigioni_agente;
#endif

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

#ifndef __COLMASK_H
class TSelect_color_mask;
#endif

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

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

#ifndef __CG2101_H
#include "../cg/cg2101.h"
#endif

#define RIGA_MERCE 'M'
#define RIGA_SPESEDOC 'S'
#define RIGA_PRESTAZIONI 'P'
#define RIGA_RISORSE 'R'
#define RIGA_ATTREZZATURE 'A'
#define RIGA_SCONTI 'C'
#define RIGA_OMAGGI 'O'
#define RIGA_DESCRIZIONI 'D'
#define RIGA_RETTIFICHE 'T'

#define MAX_IVA_SLICES 5

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


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:
	virtual 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
{
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"); }  // Solo spese
  const TString& revenue() const { return get("S5"); }     // Solo atrezzature
	const TString & um() const { return get("S7"); }
  const TString& cod_iva() const; // S3
	real prezzo() const; // R10 o 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;
	const TString & conto_analitico_vendite() const { return get("S1").left(20); }
	const TString & conto_analitico_acquisti() const { return get("S2"); }
	const TString & cdc() const { return get("S1").mid(20, 20); }
	const TString & cms() const { return get("S1").mid(40, 20); }
	const TString & fase() const { return get("S1").mid(60); }
	const int caus_770() const { return get_int("I6"); }

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

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, true), _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
{
	TString4 _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); }
	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
{
	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
	TString16 _field_qta_mag, _field_qtaevasa_mag; // Veri campi Quantit<69> e Quantit<69> Evasa per magazzino
	TString16 _raee_cod, _raee_fld;
	TString _str_desc_doc, _str_desc_rdoc;
	TString4 _module;

	char _tipocf;
	char _tipocr;
	char _check_qta;
	bool _cnt_prezzi, _show_evaded_lines, _load_cont, _non_evadere;

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:
  enum { _altro, _bolla, _fattura, _ordine, _scontrino};
  
	TObject* dup() const { return new TTipo_documento(codice()); }
	const TFilename& profile_name(TFilename& name) const;
	
	// Funzioni che effettuano la cache di importanti valori contenuti nel profilo
	const char	tipocf() const;
	void	set_defaults(TMask& m) const;
	const TString_array& keys_descrs();
	const TString_array& sheet_columns() const;
	const TString_array& handlers() const;

  const TString& mask_name() const;
	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 is_scontrino() const { return tipo() == _scontrino; }
	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; }
    const TString& field_qta_mag() const { return _field_qta_mag; }
    const TString& field_qtaevasa_mag() const { return _field_qtaevasa_mag; }
	bool check_giac() const { return _check_qta == 'G'; }
	bool check_disp() const { return _check_qta == 'D'; }
    bool load_cont() const { return _load_cont; }
    const TString& raee_cod() const { return _raee_cod; }
    const TString& raee_fld() const { return _raee_fld; }

	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 char stato_chiuso() const {return get("S2")[3]; } 
	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"); }
	bool printable() const { return get("S5").full(); }
  bool main_print_profile(TFilename& report, int filter) const;
  bool additional_print_profile(TFilename& report, int filter) const;
  bool mail_print_profile(TFilename& report) const;
	bool is_costo() const ;
	bool is_ricavo() const ;
	const TString & module() const { return _module; }

	TFormula_documento* first_formula() { return succ_formula(true); }
	TFormula_documento* succ_formula(bool restart = false);

	const int ncopie() const { return get_int("I0"); }
  const int additional_ncopie() const { return get_int("I2"); }
	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"); }
  bool allega_documenti() const { return get_bool("B10"); }
  bool auto_add() const { return get_bool("B11"); }

	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; }
	bool da_evadere() const { return !_non_evadere; }

	TTipo_documento(const char* tipodoc = NULL);
	TTipo_documento(const TRectype& rec);
	virtual ~TTipo_documento();

};

const TTipo_documento& cached_tipodoc(const char* tipodoc);

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 bool save_and_new() const { return get_bool("B4"); } 
	const bool test_eser() const { return !get_bool("B5"); }
	const bool auto_archive() const { return get_bool("B6"); }
  const bool newnumdef() const { return get_bool("B8"); }
  const TString& codnumdef() const { return get("S8"); }
  const TString& tipodocdef() const { return get("S9"); }

	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();

};

const TCodice_numerazione& cached_numerazione(const char * codnum);

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

	TString16 _imponibile, _field_imposta;
	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
    TString16 _field_qta_mag, _field_qtaevasa_mag; // Veri campi Quantit<69> e Quantit<69> Evasa per magazzino

	TToken_string _search_nums;
	int _search_years;
	int _max_rows_art;
	bool _no_desc;
	TToken_string _search_active_docs;
	TToken_string _fields_to_update;
	TToken_string _field_list;
	TToken_string _header;
	bool _select_clifo;
	TArray _genconf;
	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"); }
	bool has_formula(const char* name) { return _formule.get_pos(name) >= 0; }

	const TString& imponibile() const { return _imponibile;}	
	const TString& imposta() const { return _field_imposta;}	
	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& field_qta_mag() const { return _field_qta_mag;}  
    const TString& field_qtaevasa_mag() const { return _field_qtaevasa_mag;}  

	const int search_years() const { return _search_years;}
	const TToken_string& search_nums() const { return _search_nums;}
	const int max_rows_art() const { return _max_rows_art;}
	bool no_desc() const { return _no_desc;}
	TToken_string& search_active_docs() { return _search_active_docs;}
	TToken_string& fields_to_update() { return _fields_to_update;}
	TToken_string& field_list() { return _field_list;}
	TToken_string& header() { return _header;}
	bool select_clifo() const { return _select_clifo;} 

	const TString& provv() const { return _field_provv;}	
	const int incr_perc_prezzo() const { return _incrp;}	
	const int decr_perc_prezzo() const { return _decrp;}	
	TToken_string * genconf(int i) const { return (TToken_string *) _genconf.objptr(i);}	

	bool formfeed() const { return get_bool("B0"); }

	TFormula_documento* first_formula() { return succ_formula(true); }
	TFormula_documento* succ_formula(bool restart = FALSE);
	
	int read(const char* tiporig);
	void set_defaults(TSheet_field& s, int row) const;

	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 int _iva_calc_mode;
	static bool _rit_calc;

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 ;
		bool has_doc() const { return _doc != NULL;}


	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() == RIGA_MERCE;}
	bool is_spese() const { return tipo().tipo() == RIGA_SPESEDOC;}
	bool is_prestazione() const { return tipo().tipo() == RIGA_PRESTAZIONI;}
	bool is_risorsa() const { return tipo().tipo() == RIGA_RISORSE;}
	bool is_attrezzatura() const { return tipo().tipo() == RIGA_ATTREZZATURE;}
	bool is_sconto() const {return tipo().tipo() == RIGA_SCONTI;}
	bool is_sconto_perc() const { return is_sconto() && get(RDOC_SCONTO).not_empty();}
	bool is_omaggio() const { return tipo().tipo() == RIGA_OMAGGI;}
	bool is_descrizione() const { return tipo().tipo() == RIGA_DESCRIZIONI;}
	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 TString4 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 TRectype& orig, int depth = 0);
	void reset_original_rdoc_key();
	const TRectype* find_original_rdoc() const;
	const TRectype* find_original_doc() const;

	virtual TRiga_documento& operator =(const TRiga_documento& r) { return copy(r);}
	virtual TRectype& operator =(const TRectype & r); 
	virtual TRectype& operator =(const char * r); 

	void cost2revenue();
	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;
	real ritenuta(const char tipor = '\0', bool lordo = false, int ndec = AUTO_DECIMALS) const;

	const TString& field_qta() const;
	const TString& field_qtaevasa() const;
	real quantita() const;
	real qtaevasa() const;
	real qtaresidua() const;
	
  virtual const TString& field_qta_mag() const;
  virtual const TString& field_qtaevasa_mag() const;
  virtual real quantita_mag() const;
  virtual real qtaevasa_mag() const;
  virtual real qtaresidua_mag() const;
  real calc_conai_qta(int type) const;

	real valore(bool totale, bool lordo = false, int ndec = AUTO_DECIMALS) const;
	const TString & codice_costo() const;
	const TString & codice_commessa() const;
	const TString & fase_commessa() const;
	TArticolo & articolo() const;
	TArticolo_giacenza & articolo_giacenza() const;

	TRiga_documento(TDocumento* doc, const char* tipo = NULL);
	TRiga_documento(const TRiga_documento & row);
  /* Maialata inguardabile: guai a chi la riporta!
  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_orig;
	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_orig() { return _imp_orig;};
	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;};
	const real & iva_sconto() const { return _iva_sconto;};
	real & sconto_perc() { return _sconto_perc; }
	const real& sconto_perc() const { return _sconto_perc; }
	real & sconto_imp () { return _sconto_imp; }
	const real & sconto_imp () const { 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 long _firm;
	static TString4 _codiva_spese;
	static TString4 _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 ;
	
	virtual bool key_complete() { return numero() > 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(bool solo_imponibili);
	void dirty_tabella_iva() { _tabella_iva.destroy();}
	static void test_firm();

	void init();
	void check_modules();
	virtual void set_variables(TExpression * e) const ;
    void update_raee();
	
public:
 	int set_row_ids();
	long renum_ndoc(long numdoc = 0);
  virtual bool renum() { return renum_ndoc() > 0;}
	const TString& codiva_spese() const ;
	const TString& codiva_bolli() const ;

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

  TAssoc_array & tabella_iva(bool solo_imponibili = false) { update_tabella_iva(solo_imponibili); 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();

	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(); }
	const TTipo_documento& tipo() const;
	int tipo_riclassificato() const;
	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_costo() const { return get(DOC_CODCOSTO);}
	const TString & codice_commessa() const { return get(DOC_CODCMS);}
	const TString & commessa_principale() const;
	const TString & fase_commessa() const { return get(DOC_FASCMS);}
	bool modificabile() const;
	bool cancellabile() const;
	bool stampabile() const;
	bool bloccato() const;
	bool chiuso() const;
	bool sospeso() const { return !chiuso();}

	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, bool copy_header = true);

	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 ritenute(const char tipo = '\0', bool lordo = false, int ndec = AUTO_DECIMALS) const;
	real provvigione(int ndec = AUTO_DECIMALS) const;
	real valore(bool totale, bool lordo = false, 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;

	const TString & codesiva() const;
	void get_protocolli_esenzione(TString & esenzione, TString & data_esenzione,
																TString & registrazione, TString & data_registrazione) 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 TStati : public TObject
{
	char _iniziale;
	char _finale;
public:

	char iniziale() const { return _iniziale;}
	char finale() const { return _finale;}

	TStati(char iniziale, char finale) { _iniziale = iniziale; _finale = finale;}
  virtual ~TStati() { }
};

class TRow_colors : public TObject
{
	COLOR _back;
	COLOR _fore;
	
protected:

	virtual TObject* dup() const { return new TRow_colors(*this); }
	virtual TRow_colors & copy(const TRow_colors & c) { set(c.back(), c.fore()); return *this; }

public:
	void set(COLOR back, COLOR fore) { _back = back; _fore = fore;}
	COLOR back() const { return _back; }
	COLOR fore() const { return _fore; }
	
	TRow_colors(COLOR back, COLOR fore) { set(back, fore);}
	~TRow_colors() {}
};

class TDocumento_mask : public TVariable_mask	// velib06
{
	int _progs_page;										// pagina in cui cominciano i progressivi
	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
	TPointer_array _handlers;
	TBit_array _calculated_pages;

	bool _ges_mag, _ges_dep, _ges_ca;
	TString _std_mag, _std_dep;
	TSmart_card * _smartcard;
	static TAssoc_array _father_rows;
	static TAssoc_array _auto_reopen_nums;
	static TAssoc_array _tipidoc_rels;
	short _cdc_start;
	short _cdc_end;
	short _cms_start;
	short _cms_end;
	short _cdc_start_sh;
	short _cdc_end_sh;
	short _cms_start_sh;
	short _cms_end_sh;
	TString _codcms;
	TString _codcms_sh;
	TArray _colors;
	TArray _def_colors;
	TArray _color_rules;
	TString_array _color_rule_names;

protected:
	virtual void next_page(int p);
	virtual void start_run();
	void sconto_testa2mask();
	void spese2mask();

  void configura_sheet(TSheet_field& sheet);
  static TMask* ss_getmask(int numriga, TMask& fullmask);
  
	int insert_anal_fields(TMask& m, int page, int lf, int& y, short& dlg, short& dlgd, bool required);
	void insert_anal_page();

public:
	virtual bool is_omaggio_enabled() { return true;}
  void update_progs(bool stop_run = false);
	TAssoc_array & maskrighe() {return _maskriga;}
  virtual bool on_key(KEY key);
  virtual bool stop_run(KEY key);

	void set_field_handler(short fieldid, CONTROL_HANDLER handler);
	bool call_handler( TMask_field& f, KEY key);

	static bool universal_handler( TMask_field& f, KEY key);
	static bool occas_handler( TMask_field& f, KEY key );
	static bool occas_code_handler( TMask_field& f, KEY key );
    static bool occas_cfpi_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 datacambio_handler( TMask_field& f, KEY key );
	static bool codval_handler( TMask_field& f, KEY key );
	static bool confirm_handler( TMask_field& f, KEY key );
	static bool ss_notify(TSheet_field& ss, int r, KEY key);
	static bool ss_handler(TMask_field& f, KEY key);
	virtual void user_set_handler( short fieldid, int index);
  virtual void user_set_row_handler(TMask& rm, short field, int index);

	void reset_masks(const TString& tipo_doc);
	TVariable_mask* riga_mask(int numriga);

	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();

	static TAssoc_array & auto_reopen_nums() { return _auto_reopen_nums;}
	static TAssoc_array & tipidoc_rels() { return _tipidoc_rels;}
	const TAssoc_array & father_rows() const { return _father_rows;}
	void reset_father_rows() {_father_rows.destroy();}
	void update_father_rows(bool add = true);
	void save_father_rows();

	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 numdocrif_search_handler( TMask_field& f, KEY key );
	static bool ragsoc_search_handler( TMask_field& f, KEY key );
	static bool datadocrif_handler(TMask_field& f, KEY key);

	void highlight_row(int row, bool dirty = true, bool update = true);
	void highlight();

	bool is_calculated_page(int p) const { return _calculated_pages[p]; }
	TSmart_card* smartcard() const { return _smartcard;}

	short cdc_start() const { return _cdc_start;}
	short cdc_end() const { return _cdc_end;}
	short cms_start() const { return _cms_start;}
	short cms_end() const { return _cms_end;}
	short cdc_start_sh() const { return _cdc_start_sh;}
	short cdc_end_sh() const { return _cdc_end_sh;}
	short cms_start_sh() const { return _cms_start_sh;}
	short cms_end_sh() const { return _cms_end_sh;}
	TString & codcms() { return _codcms;}
	const TString & codcms() const { return _codcms;}
	TString & codcms_sh() { return _codcms_sh;}
	const TString & codcms_sh() const { return _codcms_sh;}

	TArray & colors() { return _colors; }
	TArray & color_rules() { return _color_rules; }
	TString_array & color_rule_names() { return _color_rule_names; }
	void sel_color();


	TDocumento_mask(const char* tipodoc);
	virtual ~TDocumento_mask();
};

#endif