ec3e3658a5
Files correlati : ve0 Ricompilazione Demo : [ ] Commento : Aggiunta libreria per gestire stampa di documenti tramite report git-svn-id: svn://10.65.10.50/trunk@13176 c028cbd2-c16b-5b4b-a496-9718f37d4682
825 lines
21 KiB
C++
Executable File
825 lines
21 KiB
C++
Executable File
#include <tabutil.h>
|
|
|
|
#include "velib.h"
|
|
#include "vepriv.h"
|
|
#include "verig.h"
|
|
|
|
#include "../mg/mglib.h"
|
|
|
|
///////////////// //////////////////////////////////////////
|
|
// Tipo documento
|
|
///////////////////////////////////////////////////////////
|
|
|
|
TAssoc_array TTipo_documento::_formule_documento;
|
|
|
|
TTipo_documento::TTipo_documento(const char* tipodoc)
|
|
: TRectype(LF_TABCOM), _tipocf('\0')
|
|
{
|
|
settab("TIP");
|
|
if (tipodoc && *tipodoc)
|
|
read(tipodoc);
|
|
}
|
|
|
|
TTipo_documento::TTipo_documento(const TRectype& rec)
|
|
: TRectype(rec), _tipocf('\0')
|
|
{
|
|
read_formule();
|
|
}
|
|
|
|
TTipo_documento::~TTipo_documento()
|
|
{
|
|
}
|
|
|
|
int TTipo_documento::read(const char* tipodoc)
|
|
{
|
|
*this = cache().get("%TIP", tipodoc);
|
|
int err = empty() ? _iskeynotfound : NOERR;
|
|
|
|
_formule.cut(0);
|
|
|
|
if (err == NOERR)
|
|
read_formule();
|
|
else
|
|
yesnofatal_box("Tipo documento errato: %s", tipodoc);
|
|
return err;
|
|
}
|
|
|
|
const TFilename& TTipo_documento::profile_name(TFilename& profile) const
|
|
{
|
|
profile = get("S4");
|
|
profile.ext("ini");
|
|
return profile;
|
|
}
|
|
|
|
const char TTipo_documento::tipocf() const
|
|
{
|
|
if (_tipocf == '\0')
|
|
{
|
|
TFilename pn; profile_name(pn);
|
|
TConfig prof(pn);
|
|
(char&)_tipocf = prof.get_char("TIPOCF", "MAIN");
|
|
}
|
|
return _tipocf;
|
|
}
|
|
|
|
const TString& TTipo_documento::riferimento(const TDocumento & doc, TString& rif) const
|
|
{
|
|
rif = get("S1");
|
|
int p = rif.find('{');
|
|
|
|
while (p >= 0)
|
|
{
|
|
const int last = rif.find('}');
|
|
const TString16 field_name(rif.sub(p + 1, last));
|
|
const TFieldref field(field_name, LF_DOC);
|
|
if (last < 0)
|
|
rif.cut(p);
|
|
else
|
|
{
|
|
const int len = rif.len() - last;
|
|
for (int i = 0; i <= len; i++)
|
|
rif[p + i] = rif[last + i + 1];
|
|
}
|
|
|
|
if (field.file() == LF_DOC)
|
|
rif.insert(field.read(doc), p);
|
|
else
|
|
{
|
|
TString16 key(doc.get(DOC_TIPOCF));
|
|
key << "|" << doc.get(DOC_CODCF);
|
|
|
|
const TRectype& rec = cache().get(field.file(), key);
|
|
rif.insert(field.read(rec), p);
|
|
}
|
|
|
|
p = rif.find('{');
|
|
}
|
|
return rif;
|
|
}
|
|
|
|
const TString_array& TTipo_documento::keys_descrs()
|
|
{
|
|
if (_keys_descrs.empty())
|
|
{
|
|
TString16 var, tiporiga;
|
|
TFilename pn; profile_name(pn);
|
|
TConfig prof(pn);
|
|
TTipo_riga_documento tr;
|
|
|
|
_keys_descrs.add("");
|
|
_keys_descrs.add("");
|
|
TToken_string& k = (TToken_string&)_keys_descrs[0];
|
|
TToken_string& d = (TToken_string&)_keys_descrs[1];
|
|
int i;
|
|
|
|
for (i = 0; ; i++)
|
|
{
|
|
const TString16 tiporiga(prof.get("Tipo", "RIGHE", i));
|
|
|
|
if (tiporiga.empty())
|
|
break;
|
|
|
|
tr.read(tiporiga);
|
|
k.add(tr.codice());
|
|
d.add(tr.descrizione());
|
|
}
|
|
|
|
if (i == 0)
|
|
{
|
|
TTable tri("%TRI");
|
|
|
|
for (int err = tri.first(); err == NOERR; err = tri.next())
|
|
{
|
|
k.add(tri.get("CODTAB"));
|
|
d.add(tri.get("S0"));
|
|
}
|
|
}
|
|
}
|
|
|
|
return _keys_descrs;
|
|
}
|
|
|
|
const TString_array& TTipo_documento::sheet_columns() const
|
|
{
|
|
if (_sheet_columns.empty())
|
|
{
|
|
TFilename pn; profile_name(pn);
|
|
TConfig prof(pn, "SHEET");
|
|
for (int i = 0; i < MAX_COLUMNS; i++)
|
|
{
|
|
const TString& id = prof.get("Col", NULL, i);
|
|
if (atoi(id) <= 0)
|
|
break;
|
|
((TString_array&)_sheet_columns).add(id);
|
|
}
|
|
}
|
|
|
|
return _sheet_columns;
|
|
}
|
|
|
|
const TString_array& TTipo_documento::handlers() const
|
|
{
|
|
if (_handlers.empty())
|
|
{
|
|
TString16 chiave;
|
|
TFilename pn; profile_name(pn);
|
|
TConfig prof(pn, "HANDLERS");
|
|
|
|
for (int i = 0; ; i++)
|
|
{
|
|
const TString & h = prof.get("Handler", NULL, i);
|
|
if (h.empty())
|
|
break;
|
|
((TString_array &)_handlers).add(h);
|
|
}
|
|
}
|
|
return _handlers;
|
|
}
|
|
|
|
void TTipo_documento::set_defaults(TMask& m) const
|
|
{
|
|
if (_defaults.empty()) // Carica lo string_array con i defaults
|
|
{
|
|
TFilename pn; profile_name(pn);
|
|
TConfig prof(pn, "DEFAULT");
|
|
|
|
for(int i = 0; ; i++)
|
|
{
|
|
TToken_string s(prof.get("Default", NULL, i));
|
|
if (s.empty())
|
|
break;
|
|
const int field = s.get_int();
|
|
((TTipo_documento*)this)->_defaults.add(s.get(), field);
|
|
}
|
|
}
|
|
// Setta i campi della maschera
|
|
FOR_EACH_ARRAY_ROW(_defaults, i, tt)
|
|
{
|
|
m.set(i, *tt, TRUE);
|
|
}
|
|
}
|
|
|
|
void TTipo_documento::add_formula_if_needed(TConfig& profile, TString& variable,
|
|
const char* varname, const char* formula)
|
|
{
|
|
variable = profile.get(varname, "MAIN");
|
|
if (variable.empty())
|
|
variable = varname;
|
|
const TRectype& trr = cache().get("%FRD", variable);
|
|
if (trr.empty() || trr.get("S1").empty())
|
|
_formule_documento.add(variable, new TFormula_documento(_documento, variable, formula), TRUE);
|
|
if (_formule.find(variable) < 0)
|
|
_formule.add(variable);
|
|
}
|
|
|
|
void TTipo_documento::read_formule()
|
|
{
|
|
TFilename profile; profile_name(profile);
|
|
TConfig prof(profile, "MAIN");
|
|
prof.write_protect(); // Altrimenti non si distrugge!!!
|
|
|
|
_formule = prof.get("CAMPICALC");
|
|
const TString& calcoli = prof.get("CALCOLI");
|
|
if (calcoli == "*")
|
|
{
|
|
TTable frd("%FRD");
|
|
for (int err = frd.first(); err == NOERR; err = frd.next())
|
|
{
|
|
const TString & formula = frd.get("CODTAB");
|
|
if (_formule.find(formula) < 0)
|
|
_formule.add(formula);
|
|
}
|
|
}
|
|
else
|
|
_formule.add(calcoli);
|
|
|
|
add_formula_if_needed(prof, _totale, "TOTALE", "IMPONIBILI()+IMPOSTE()");
|
|
|
|
if (_totale == "TOTALE")
|
|
_totale = "TOTDOC";
|
|
|
|
_totale_netto = "_"; _totale_netto << _totale;
|
|
|
|
add_formula_if_needed(prof, _basesconto, "BASESCONTO", "SOMMA(\"IMPONIBILE()\", \"(TIPO()!='S') && (TIPO()!='C')\")");
|
|
add_formula_if_needed(prof, _spese, "SPESE", "SOMMA(\"IMPONIBILE()\", \"TIPO() == 'S'\")");
|
|
add_formula_if_needed(prof, _totvalres, "TOTVALRES", "VALDOC(0)");
|
|
add_formula_if_needed(prof, _totvalore, "TOTVALORE", "VALDOC(1)");
|
|
|
|
if (provvigioni())
|
|
{
|
|
TString80 campo(prof.get("TOTPROVV"));
|
|
if (campo.empty())
|
|
campo = "TOTPROVV";
|
|
const TRectype& frd = cache().get("%FRD", campo);
|
|
|
|
_totprovv = "_";
|
|
_totprovv << campo;
|
|
|
|
TString80 expr(frd.get("S1"));
|
|
if (expr.empty())
|
|
expr = "SOMMA(\"PROVV()\")";
|
|
_formule_documento.add(_totprovv, new TFormula_documento(_documento, _totprovv, expr, TRUE));
|
|
if (_formule.find(campo) < 0)
|
|
_formule.add(campo);
|
|
_formule.add(_totprovv);
|
|
_formule_documento.add(campo, new TFormula_documento(_documento, campo, "TOTPROVV()"), TRUE);
|
|
}
|
|
|
|
_totale_cont = prof.get("TOTALECONT");
|
|
_cnt_prezzi = prof.get_bool("CONTROLLO_PREZZI");
|
|
_field_prezzo = prof.get(RDOC_PREZZO);
|
|
_field_qta = prof.get(RDOC_QTA, NULL, -1, RDOC_QTA);
|
|
_field_qtaevasa = prof.get(RDOC_QTAEVASA, NULL, -1, RDOC_QTAEVASA);
|
|
_check_qta = prof.get_char("CHECK_QTA", "MAIN");
|
|
|
|
_str_desc_doc = prof.get("DESCRIZIONE_DOC");
|
|
_str_desc_rdoc = prof.get("DESCRIZIONE_RDOC");
|
|
_show_evaded_lines = !prof.get_bool("NASCONDI_RIGHE_EVASE"); // Normalmente mostra anche evase
|
|
|
|
}
|
|
|
|
bool TTipo_documento::stato_with_mov_mag(const char stato) const
|
|
{
|
|
if (!mov_mag())
|
|
return FALSE;
|
|
const char stato_finale(stato_mov_finale());
|
|
if (stato_finale > ' ' && stato > stato_finale)
|
|
return FALSE;
|
|
const char stato_iniziale(stato_mov_iniziale());
|
|
return stato >= stato_iniziale;
|
|
}
|
|
|
|
TFormula_documento* TTipo_documento::succ_formula(bool restart)
|
|
{
|
|
if (restart)
|
|
_formule.restart();
|
|
|
|
TString formula = _formule.get();
|
|
while (formula.not_empty())
|
|
{
|
|
if (formula.blank())
|
|
formula = _formule.get();
|
|
else
|
|
break;
|
|
}
|
|
|
|
if (formula.not_empty())
|
|
{
|
|
char *expr = NULL;
|
|
const int p = formula.find('=');
|
|
if (p > 0)
|
|
{
|
|
expr = (char *) (const char *) formula + p;
|
|
*expr = '\0'; expr++;
|
|
}
|
|
TFormula_documento* o = (TFormula_documento*)_formule_documento.objptr(formula);
|
|
if (o == NULL)
|
|
{
|
|
o = new TFormula_documento(_documento, formula, expr);
|
|
_formule_documento.add(formula, o);
|
|
}
|
|
return o;
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
bool TTipo_documento::scarica_residuo() const
|
|
{
|
|
if (is_ordine() && !riporta_ordinato())
|
|
return TRUE;
|
|
return get_bool("B4");
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////
|
|
// Espressione documento
|
|
///////////////////////////////////////////////////////////
|
|
|
|
TExpr_documento::TExpr_documento(const char* expression, TTypeexp type,
|
|
TDocumento * doc, TRiga_documento * row)
|
|
: TExpression(type), _doc(doc), _row(row)
|
|
{
|
|
if (!set(expression, type))
|
|
error_box("Wrong expression : '%s'", expression);
|
|
}
|
|
|
|
int TExpr_documento::parse_user_func(const char * name, int nparms) const
|
|
{
|
|
if (strcmp(name, "SOMMA") == 0)
|
|
return nparms > 0 || nparms < 3 ? _somma : -1;
|
|
if (strcmp(name, "BOLLI") == 0)
|
|
return nparms > 0 || nparms < 4 ? _bolli : -1;
|
|
if (strcmp(name, "_BOLLI") == 0)
|
|
return nparms > 0 || nparms < 3 ? _bolli_int : -1;
|
|
if (strcmp(name, "SPESEINC") == 0)
|
|
return nparms > 0 || nparms < 4 ? _spinc : -1;
|
|
if (strcmp(name, "PREZZO") == 0)
|
|
return nparms < 4 ? _prezzo : -1;
|
|
if (strcmp(name, "IMPORTO") == 0)
|
|
return nparms < 4 ? _importo : -1;
|
|
if (strcmp(name, "SCONTO") == 0)
|
|
return nparms < 2 ? _sconto : -1;
|
|
if (strcmp(name, "IMPONIBILE") == 0)
|
|
return nparms == 0 ? _imponibile : -1;
|
|
if (strcmp(name, "IVA") == 0)
|
|
return nparms == 0 ? _iva : -1;
|
|
if (strcmp(name, "PROVV") == 0)
|
|
return nparms < 2 ? _provv : -1;
|
|
if (strcmp(name, "QUANT") == 0)
|
|
return nparms < 2 ? _quant : -1;
|
|
if (strcmp(name, "QUANTEVASA") == 0)
|
|
return nparms < 2 ? _quantevasa : -1;
|
|
if (strcmp(name, "QTARES") == 0)
|
|
return nparms < 2 ? _qtares : -1;
|
|
if (strcmp(name, "VALDOC") == 0)
|
|
return nparms < 3 ? _valdoc : -1;
|
|
if (strcmp(name, "TIPO") == 0)
|
|
return nparms == 0 ? _tipo : -1;
|
|
if (strcmp(name, "IMPONIBILI") == 0)
|
|
return nparms < 3 ? _imponibili : -1;
|
|
if (strcmp(name, "IMPOSTE") == 0)
|
|
return nparms < 3 ? _imposte : -1;
|
|
if (strcmp(name, "TOTPROVV") == 0)
|
|
return nparms < 3 ? _totprovv : -1;
|
|
if (strcmp(name, "PSCONTOT") == 0)
|
|
return nparms < 1 ? _pscontot : -1;
|
|
if (strcmp(name, "RITENUTA") == 0)
|
|
return nparms < 3 ? _ritenuta : -1;
|
|
if (strcmp(name, "TIPORIT") == 0)
|
|
return nparms < 1 ? _tipo_ritenuta : -1;
|
|
return -1;
|
|
}
|
|
|
|
void TExpr_documento::evaluate_user_func(int index, int nparms, TEval_stack & stack, TTypeexp type) const
|
|
{
|
|
switch (index)
|
|
{
|
|
case _somma:
|
|
{
|
|
const TString cond(nparms == 2 ? stack.pop_string() : "STR(1)");
|
|
const TString & field = stack.pop_string();
|
|
real somma;
|
|
|
|
if (_doc != NULL)
|
|
{
|
|
TExpr_documento cond_expr(cond, _strexpr, _doc);
|
|
const int cond_nvars = cond_expr.numvar();
|
|
TExpr_documento expr(field, _numexpr, _doc);
|
|
const int nvars = expr.numvar();
|
|
const int nrows = _doc->rows();
|
|
|
|
for (int i = nrows; i > 0; i--)
|
|
{
|
|
TRiga_documento & riga = (TRiga_documento &) (*_doc)[i];
|
|
int j;
|
|
|
|
for (j = cond_nvars - 1; j >= 0; j--)
|
|
{
|
|
const char* s = cond_expr.varname(j);
|
|
TFieldref f(s,0);
|
|
cond_expr.setvar(j, f.read(riga));
|
|
}
|
|
cond_expr.set_row(&riga);
|
|
if ((bool)cond_expr)
|
|
{
|
|
for (j = nvars - 1; j >= 0; j--)
|
|
{
|
|
const char* s = expr.varname(j);
|
|
TFieldref f(s,0);
|
|
expr.setvar(j, f.read(riga));
|
|
}
|
|
expr.set_row(&riga);
|
|
somma += expr.as_real();
|
|
}
|
|
}
|
|
}
|
|
stack.push(somma);
|
|
}
|
|
break;
|
|
case _spinc:
|
|
{
|
|
int ndec = AUTO_DECIMALS;
|
|
bool netto = FALSE;
|
|
|
|
if (nparms > 2)
|
|
ndec = (int) stack.pop_real().integer();
|
|
if (nparms > 1)
|
|
netto = !stack.pop_real().is_zero();
|
|
|
|
real & r = stack.peek_real();
|
|
|
|
if (_doc)
|
|
r = _doc->spese_incasso(ndec, netto ? _netto : _lordo);
|
|
else
|
|
r = ZERO;
|
|
}
|
|
break;
|
|
case _bolli:
|
|
{
|
|
int ndec = AUTO_DECIMALS;
|
|
bool netto = FALSE;
|
|
|
|
if (nparms > 2)
|
|
ndec = (int) stack.pop_real().integer();
|
|
if (nparms > 1)
|
|
netto = !stack.pop_real().is_zero();
|
|
|
|
real & r = stack.peek_real();
|
|
|
|
if (_doc)
|
|
{
|
|
r += _doc->spese_incasso(ndec);
|
|
r = _doc->bolli(real(r - _doc->ritenute()), ndec, netto ? _netto : _lordo);
|
|
}
|
|
else
|
|
r = ZERO;
|
|
}
|
|
break;
|
|
case _bolli_int:
|
|
{
|
|
int ndec = AUTO_DECIMALS;
|
|
|
|
if (nparms > 2)
|
|
ndec = (int) stack.pop_real().integer();
|
|
|
|
real & r = stack.peek_real();
|
|
|
|
if (_doc)
|
|
{
|
|
real r1 = _doc->spese_incasso(ndec);
|
|
r += r1;
|
|
r1 += _doc->bolli(real(r - _doc->ritenute()), ndec);
|
|
r = r1;
|
|
}
|
|
else
|
|
r = ZERO;
|
|
}
|
|
break;
|
|
case _prezzo:
|
|
{
|
|
int ndec = AUTO_DECIMALS;
|
|
bool lordo = FALSE;
|
|
bool scontato = FALSE;
|
|
|
|
if (nparms > 2)
|
|
ndec = (int) stack.pop_real().integer();
|
|
if (nparms > 1)
|
|
lordo = !stack.pop_real().is_zero();
|
|
if (nparms > 0)
|
|
scontato = !stack.peek_real().is_zero();
|
|
else
|
|
stack.push(ZERO);
|
|
|
|
real & val = stack.peek_real();
|
|
if (_row)
|
|
val = _row->prezzo(scontato, lordo, ndec);
|
|
else
|
|
val = ZERO;
|
|
|
|
}
|
|
break;
|
|
case _importo:
|
|
{
|
|
int ndec = AUTO_DECIMALS;
|
|
bool lordo = FALSE;
|
|
bool scontato = FALSE;
|
|
|
|
if (nparms > 2)
|
|
ndec = (int) stack.pop_real().integer();
|
|
if (nparms > 1)
|
|
lordo = !stack.pop_real().is_zero();
|
|
if (nparms > 0)
|
|
scontato = !stack.peek_real().is_zero();
|
|
else
|
|
stack.push(ZERO);
|
|
|
|
real & val = stack.peek_real();
|
|
if (_row)
|
|
val = _row->importo(scontato, lordo, ndec);
|
|
else
|
|
val = ZERO;
|
|
}
|
|
break;
|
|
case _imponibile:
|
|
{
|
|
real r;
|
|
|
|
if (_row)
|
|
r = _row->imponibile();
|
|
stack.push(r);
|
|
}
|
|
break;
|
|
case _sconto:
|
|
{
|
|
int ndec = AUTO_DECIMALS;
|
|
|
|
if (nparms > 0)
|
|
ndec = (int) stack.peek_real().integer();
|
|
else
|
|
stack.push(ZERO);
|
|
|
|
real & val = stack.peek_real();
|
|
if (_row)
|
|
{
|
|
if (_row->is_sconto())
|
|
val = -_row->importo(FALSE, FALSE, ndec);
|
|
else
|
|
val = _row->importo(FALSE, FALSE, ndec) - _row->importo(TRUE, FALSE, ndec);
|
|
}
|
|
else
|
|
val = ZERO;
|
|
}
|
|
break;
|
|
case _iva:
|
|
{
|
|
real r;
|
|
|
|
if (_row)
|
|
r = _row->imposta();
|
|
stack.push(r);
|
|
}
|
|
break;
|
|
case _provv:
|
|
{
|
|
int ndec = AUTO_DECIMALS;
|
|
|
|
if (nparms > 0)
|
|
ndec = (int) stack.peek_real().integer();
|
|
else
|
|
stack.push(ZERO);
|
|
|
|
real & val = stack.peek_real();
|
|
|
|
if (_row)
|
|
val = _row->provvigione(ndec);
|
|
else
|
|
val = ZERO;
|
|
}
|
|
break;
|
|
case _quant:
|
|
{
|
|
int ndec = AUTO_DECIMALS;
|
|
if (nparms > 0)
|
|
ndec = (int)stack.peek_real().integer();
|
|
else
|
|
stack.push(ZERO);
|
|
real& val = stack.peek_real();
|
|
if (_row)
|
|
val = _row->quantita();
|
|
else
|
|
val = ZERO;
|
|
}
|
|
break;
|
|
case _quantevasa:
|
|
{
|
|
int ndec = AUTO_DECIMALS;
|
|
if (nparms > 0)
|
|
ndec = (int)stack.peek_real().integer();
|
|
else
|
|
stack.push(ZERO);
|
|
real& val = stack.peek_real();
|
|
if (_row)
|
|
val = _row->qtaevasa();
|
|
else
|
|
val = ZERO;
|
|
}
|
|
break;
|
|
case _qtares:
|
|
{
|
|
int ndec = AUTO_DECIMALS;
|
|
if (nparms > 0)
|
|
ndec = (int) stack.peek_real().integer();
|
|
else
|
|
stack.push(ZERO);
|
|
real & val = stack.peek_real();
|
|
|
|
if (_row)
|
|
val = _row->qtaresidua();
|
|
else
|
|
val = ZERO;
|
|
}
|
|
break;
|
|
case _valdoc:
|
|
{
|
|
int ndec = AUTO_DECIMALS;
|
|
bool totale = TRUE; // Totale o residuo per documento
|
|
|
|
if (nparms > 1)
|
|
ndec = (int)stack.pop_real().integer();
|
|
if (nparms > 0)
|
|
totale = !stack.peek_real().is_zero();
|
|
else
|
|
stack.push(ZERO);
|
|
|
|
real & r = stack.peek_real();
|
|
|
|
if (_doc)
|
|
r = _doc->valore(totale, ndec);
|
|
else
|
|
r = ZERO;
|
|
}
|
|
break;
|
|
case _tipo:
|
|
{
|
|
TString s;
|
|
if (_row)
|
|
s << _row->tipo().tipo();
|
|
stack.push(s);
|
|
}
|
|
break;
|
|
case _imponibili:
|
|
{
|
|
int ndec = AUTO_DECIMALS;
|
|
bool spese = FALSE;
|
|
|
|
if (nparms > 1)
|
|
ndec = (int) stack.pop_real().integer();
|
|
if (nparms > 0)
|
|
spese = !stack.peek_real().is_zero();
|
|
else
|
|
stack.push(ZERO);
|
|
real & val = stack.peek_real();
|
|
val = _doc->imponibile(spese, ndec);
|
|
}
|
|
break;
|
|
case _imposte:
|
|
{
|
|
int ndec = AUTO_DECIMALS;
|
|
bool spese = FALSE;
|
|
|
|
if (nparms > 1)
|
|
ndec = (int) stack.pop_real().integer();
|
|
if (nparms > 0)
|
|
spese = !stack.peek_real().is_zero();
|
|
else
|
|
stack.push(ZERO);
|
|
real & val = stack.peek_real();
|
|
val = _doc->imposta(spese, ndec);
|
|
}
|
|
break;
|
|
case _totprovv:
|
|
{
|
|
int ndec = AUTO_DECIMALS;
|
|
|
|
if (nparms > 0)
|
|
ndec = (int) stack.peek_real().integer();
|
|
else
|
|
stack.push(ZERO);
|
|
real & val = stack.peek_real();
|
|
|
|
val = _doc->provvigione(ndec);
|
|
}
|
|
break;
|
|
case _pscontot:
|
|
{
|
|
real val;
|
|
TString80 s;
|
|
|
|
if (_doc && scontoexpr2perc(_doc->get(DOC_SCONTOPERC), FALSE, s, val) && val != ZERO)
|
|
val = 1 - val;
|
|
stack.push(val);
|
|
}
|
|
break;
|
|
case _ritenuta:
|
|
{
|
|
int ndec = AUTO_DECIMALS;
|
|
bool lordo = FALSE;
|
|
|
|
if (nparms > 1)
|
|
ndec = (int) stack.pop_real().integer();
|
|
if (nparms > 0)
|
|
lordo = !stack.peek_real().is_zero();
|
|
else
|
|
stack.push(ZERO);
|
|
real & val = stack.peek_real();
|
|
|
|
const char tipo = _row->spesa().tipo_ritenuta();
|
|
|
|
val = _row->ritenuta(tipo, lordo, ndec);
|
|
}
|
|
break;
|
|
case _tipo_ritenuta:
|
|
{
|
|
TString s;
|
|
if (_row && _row->tipo().tipo() == 'S')
|
|
s << _row->spesa().tipo_ritenuta();
|
|
stack.push(s);
|
|
}
|
|
break;
|
|
default:
|
|
TExpression::evaluate_user_func(index, nparms, stack, type);
|
|
break;
|
|
}
|
|
}
|
|
|
|
TObject* TExpr_documento::dup() const
|
|
{
|
|
TExpr_documento* o = new TExpr_documento(*this);
|
|
return o;
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////
|
|
// Formula documento
|
|
///////////////////////////////////////////////////////////
|
|
|
|
TFormula_documento::TFormula_documento(TTipo_formula tipo, const char* codice, const char * expr, bool numexpr)
|
|
: TRectype(LF_TABCOM), _expr(NULL)
|
|
{
|
|
_tab = tipo == _documento ? "FRD" : "FRR";
|
|
settab(_tab);
|
|
_tab.insert("%");
|
|
if (codice && *codice)
|
|
read(codice, expr, numexpr);
|
|
}
|
|
|
|
TFormula_documento::TFormula_documento(const TRectype& rec)
|
|
: TRectype(rec), _expr(NULL)
|
|
{
|
|
_tab = "%";
|
|
_tab << rec.get("COD");
|
|
const TTypeexp et = expr_type();
|
|
_expr = new TExpr_documento(expr_string(), et);
|
|
}
|
|
|
|
TFormula_documento::~TFormula_documento()
|
|
{
|
|
if (_expr) delete _expr;
|
|
}
|
|
|
|
int TFormula_documento::read(const char* codice, const char * expr, bool numexpr)
|
|
{
|
|
if (_expr != NULL)
|
|
{
|
|
delete _expr;
|
|
_expr = NULL;
|
|
}
|
|
|
|
put("CODTAB", codice);
|
|
|
|
int err = NOERR;
|
|
|
|
if (expr && *expr)
|
|
{
|
|
put("S1", expr);
|
|
put("B0", numexpr ? "X" : "");
|
|
}
|
|
else
|
|
{
|
|
TTable t(_tab);
|
|
err = TRectype::read(t);
|
|
}
|
|
|
|
if (err == NOERR)
|
|
{
|
|
const TTypeexp et = expr_type();
|
|
const TString e = expr_string(); // Copio espressione proveniente da record
|
|
_expr = new TExpr_documento(e, et);
|
|
}
|
|
else
|
|
{
|
|
zero();
|
|
put("CODTAB", codice);
|
|
}
|
|
return err;
|
|
}
|