#ifndef __VELIB_H #define __VELIB_H #ifndef __VARMASK_H #include #endif #ifndef __MULTIREC_H #include #endif #ifndef __VISWIN_H class TViswin; #endif #ifndef __CLIFOR_H #include "clifor.h" #endif #ifndef __CURRENCY_H #include #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 #endif #ifndef __DOC_H #include #endif #ifndef __RDOC_H #include #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à e Quantità 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; 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à e Quantità 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

(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 è 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;}; 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 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 ("|") 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