750 lines
21 KiB
C++
750 lines
21 KiB
C++
#include "sc0300a.h"
|
|
#include "../cg/cgsalda3.h"
|
|
|
|
#include <applicat.h>
|
|
#include <automask.h>
|
|
#include <progind.h>
|
|
#include <recset.h>
|
|
#include <relation.h>
|
|
#include <treectrl.h>
|
|
#include <urldefid.h>
|
|
|
|
#include <causali.h>
|
|
#include <mov.h>
|
|
|
|
///////////////////////////////////////////////////////////
|
|
// TPareggio_tree
|
|
///////////////////////////////////////////////////////////
|
|
|
|
class TPareggio_tree : public TObject_tree
|
|
{
|
|
TPartite_array _games;
|
|
|
|
protected:
|
|
virtual TFieldtypes get_var(const TString& name, TVariant& var) const;
|
|
virtual TImage* image(bool selected) const;
|
|
|
|
public:
|
|
bool init(const TBill& bill, const TString& valuta, bool nc, int stato); // Stato: 1=aperte; 2=chiuse; 0 o 3 = tutte
|
|
TPartita& partita(const TRectype& rec) const;
|
|
bool is_lonely_pag(const TRectype& rec) const;
|
|
const TRectype* node2rec(const TString& id);
|
|
};
|
|
|
|
TPartita& TPareggio_tree::partita(const TRectype& rec) const
|
|
{
|
|
return ((TPartite_array&)_games).partita(rec);
|
|
}
|
|
|
|
// Controlla se rec è una riga di tipo nota credito non associata a nessuna scadenza in una partita a sè stante
|
|
bool TPareggio_tree::is_lonely_pag(const TRectype& rec) const
|
|
{
|
|
const tipo_movimento tm = (tipo_movimento)rec.get_int(PART_TIPOMOV);
|
|
if (tm == tm_fattura)
|
|
return false;
|
|
|
|
const TPartita& part = partita(rec);
|
|
for (int r = part.last(); r > 0; r = part.pred(r))
|
|
{
|
|
const tipo_movimento tm = part.riga(r).tipo();
|
|
if (tm <= tm_fattura || tm >= tm_insoluto)
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
const TRectype* TPareggio_tree::node2rec(const TString& id)
|
|
{
|
|
const TRectype* rec = NULL;
|
|
if (id.blank() || goto_node(id))
|
|
{
|
|
const TObject* obj = curr_node();
|
|
if (obj != NULL && obj->is_kind_of(CLASS_RECTYPE))
|
|
rec = (const TRectype*)obj;
|
|
}
|
|
return rec;
|
|
}
|
|
|
|
TFieldtypes TPareggio_tree::get_var(const TString& name, TVariant& var) const
|
|
{
|
|
TFieldtypes ft = _nullfld;
|
|
const TObject* obj = curr_node();
|
|
if (obj != NULL)
|
|
{
|
|
if (obj->is_kind_of(CLASS_RECTYPE))
|
|
{
|
|
const TRectype& rec = *(const TRectype*)obj;
|
|
ft = rec.type(name);
|
|
if (ft != _nullfld)
|
|
{
|
|
if (ft == _realfld)
|
|
{
|
|
if (name == PART_IMPORTO)
|
|
{
|
|
char sez = 'D';
|
|
if (rec.num() == LF_SCADENZE)
|
|
{
|
|
const int nriga = rec.get_int(SCAD_NRIGA);
|
|
const TPartita& game = partita(rec);
|
|
sez = game.riga(nriga).get_char(PART_SEZ);
|
|
} else
|
|
if (rec.exist(PART_SEZ))
|
|
sez = rec.get_char(PART_SEZ);
|
|
TImporto imp(sez, rec.get_real(name));
|
|
if (!imp.is_zero())
|
|
{
|
|
imp.normalize();
|
|
TString80 str;
|
|
str << imp.valore().stringa(0, 2) << ' ' << imp.sezione();
|
|
var = str;
|
|
}
|
|
}
|
|
else
|
|
var = rec.get_real(name).stringa(0, 2);
|
|
ft = _alfafld;
|
|
}
|
|
else
|
|
var = rec.get(name);
|
|
}
|
|
else
|
|
{
|
|
if (name.starts_with("PART.", true))
|
|
{
|
|
const TString& fld = name.after(".");
|
|
if (rec.num() == LF_SCADENZE)
|
|
{
|
|
const int nriga = rec.get_int(SCAD_NRIGA);
|
|
const TPartita& game = partita(rec);
|
|
var = game.riga(nriga).get(fld);
|
|
ft = _alfafld;
|
|
}
|
|
else
|
|
{
|
|
var = rec.get(fld);
|
|
ft = _alfafld;
|
|
if (var.is_empty() && name.ends_with(PART_DESCR))
|
|
{
|
|
switch (rec.get_int(PART_TIPOMOV))
|
|
{
|
|
case tm_fattura : var = TR("Fattura"); break;
|
|
case tm_nota_credito : var = TR("Nota di credito"); break;
|
|
case tm_pagamento : var = TR("Pagamento"); break;
|
|
case tm_insoluto : var = TR("Insoluto"); break;
|
|
case tm_pagamento_insoluto: var = TR("Pagamento di insoluto"); break;
|
|
default: break;
|
|
};
|
|
}
|
|
}
|
|
} else
|
|
if (name == "RESIDUO")
|
|
{
|
|
TImporto saldo;
|
|
switch (rec.num())
|
|
{
|
|
case LF_SCADENZE:
|
|
if (!rec.get_bool(SCAD_PAGATA))
|
|
{
|
|
const TPartita& game = partita(rec);
|
|
const TRiga_scadenze& s = game.rata(rec.get_int(SCAD_NRIGA), rec.get_int(SCAD_NRATA));
|
|
saldo = s.residuo(true);
|
|
}
|
|
break;
|
|
case LF_PARTITE:
|
|
if (!rec.get_bool(PART_CHIUSA))
|
|
{
|
|
const TPartita& game = partita(rec);
|
|
saldo = game.calcola_saldo(true);
|
|
}
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
if (!saldo.is_zero())
|
|
{
|
|
TString80 str;
|
|
str << saldo.valore().stringa(0, 2) << ' ' << saldo.sezione();
|
|
var = str;
|
|
}
|
|
ft = _alfafld;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (name == PART_NUMPART)
|
|
{
|
|
const real& year = *(real*)obj;
|
|
var = year.integer();
|
|
ft = _intfld;
|
|
}
|
|
}
|
|
}
|
|
return ft;
|
|
}
|
|
|
|
TImage* TPareggio_tree::image(bool selected) const
|
|
{
|
|
const TObject* obj = curr_node();
|
|
short id = 0;
|
|
if (obj != NULL)
|
|
{
|
|
if (obj->is_kind_of(CLASS_RECTYPE))
|
|
{
|
|
const TRectype& rec = *(const TRectype*)obj;
|
|
switch (rec.num())
|
|
{
|
|
case LF_PARTITE:
|
|
switch (rec.get_int(PART_TIPOMOV))
|
|
{
|
|
case tm_fattura:
|
|
id = rec.get_bool(PART_CHIUSA) ? BMP_DIRDNSEL : BMP_DIRDN;
|
|
break;
|
|
case tm_pagamento_insoluto: // Alias tm_pagamento
|
|
case tm_pagamento:
|
|
id = BMP_PAGAMENTO;
|
|
break;
|
|
default:
|
|
id = BMP_INSOLUTO;
|
|
break;
|
|
}
|
|
break;
|
|
case LF_SCADENZE:
|
|
id = rec.get_bool(SCAD_PAGATA) ? BMP_DIRDNSEL : BMP_DIRDN;
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
return id > 0 ? get_res_image(id) : TTree::image(selected);
|
|
}
|
|
|
|
bool TPareggio_tree::init(const TBill& bill, const TString& valuta, bool nc, int stato)
|
|
{
|
|
_games.destroy();
|
|
goto_root();
|
|
kill_node();
|
|
|
|
TString filter;
|
|
if (bill.tipo() > ' ')
|
|
filter << PART_TIPOCF << '=' << bill.tipo();
|
|
else
|
|
{
|
|
filter << PART_GRUPPO << '=' << bill.gruppo() << ' ';
|
|
filter << PART_CONTO << '=' << bill.conto();
|
|
}
|
|
filter << ' ' << PART_SOTTOCONTO << '=' << bill.sottoconto();
|
|
|
|
TString query;
|
|
query << "USE PART SELECT (NRIGA<9999)&&(" << (nc ? "BETWEEN(TIPOMOV,1,3)" : "TIPOMOV=1") << ')'
|
|
<< "\nFROM " << filter << "\nTO " << filter;
|
|
TISAM_recordset games(query);
|
|
const TRectype& rec = games.cursor()->curr();
|
|
|
|
int last_year = 0;
|
|
TString80 id_year, id_rec;
|
|
|
|
TProgind pi(games.items(), nc ? TR("Caricamento note di credito") : TR("Caricamento fatture"));
|
|
for (bool ok = games.move_first(); ok; ok = games.move_next())
|
|
{
|
|
if (!pi.addstatus(1))
|
|
break;
|
|
|
|
const TString& codval = rec.get(PART_CODVAL);
|
|
if (!same_values(codval, valuta))
|
|
continue;
|
|
|
|
bool add_riga = true;
|
|
if (stato == 1 || stato == 2)
|
|
{
|
|
bool chiusa = rec.get_bool(PART_CHIUSA);
|
|
if (!chiusa && partita(rec).chiusa(true))
|
|
chiusa = true; // Flag CHIUSA non affidabilissimo
|
|
|
|
if (chiusa)
|
|
add_riga = stato == 2;
|
|
else
|
|
add_riga = stato == 1;
|
|
if (!add_riga)
|
|
continue;
|
|
}
|
|
|
|
if (nc)
|
|
{
|
|
const tipo_movimento tm = (tipo_movimento)rec.get_int(PART_TIPOMOV);
|
|
// Se filtro le note di credito cerco di riconoscere le fatture negative
|
|
if (tm == tm_fattura)
|
|
{
|
|
const char sezione_positiva = bill.tipo() == 'C' ? 'D' : 'A';
|
|
TImporto importo(rec.get_char(PART_SEZ), rec.get_real(PART_IMPORTO));
|
|
importo.normalize();
|
|
add_riga = sezione_positiva != importo.sezione(); // Ignora fattura positiva
|
|
}
|
|
else
|
|
{
|
|
const int nriga = rec.get_int(PART_NRIGA);
|
|
const TPartita& game = partita(rec);
|
|
add_riga = ((TPartita&)game).unassigned().exist(nriga) && is_lonely_pag(rec);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
const char sezione_positiva = bill.tipo() == 'C' ? 'D' : 'A';
|
|
TImporto importo(rec.get_char(PART_SEZ), rec.get_real(PART_IMPORTO));
|
|
importo.normalize();
|
|
add_riga = sezione_positiva == importo.sezione(); // Ignora fattura negativa
|
|
}
|
|
|
|
if (!add_riga)
|
|
continue;
|
|
|
|
const int year = rec.get_int(PART_ANNO);
|
|
if (year != last_year)
|
|
{
|
|
goto_root();
|
|
while(goto_rbrother());
|
|
add_rbrother(real(year));
|
|
|
|
last_year = year;
|
|
curr_id(id_year);
|
|
id_rec.cut(0);
|
|
}
|
|
|
|
if (nc)
|
|
{
|
|
if (id_rec.full())
|
|
{
|
|
goto_node(id_rec);
|
|
add_rbrother(rec);
|
|
}
|
|
else
|
|
add_son(rec);
|
|
curr_id(id_rec);
|
|
}
|
|
else
|
|
{
|
|
TPartita& game = partita(rec);
|
|
const TRiga_partite& riga = game.riga(rec.get_int(PART_NRIGA));
|
|
for (int rata = 1; rata <= riga.rate(); rata++)
|
|
{
|
|
const TRiga_scadenze& s = riga.rata(rata);
|
|
bool add_rata = true;
|
|
if (stato == 1 || stato == 2)
|
|
{
|
|
const bool chiusa = s.get_bool(SCAD_PAGATA);
|
|
if (chiusa)
|
|
add_rata = stato == 2;
|
|
else
|
|
add_rata = stato == 1;
|
|
}
|
|
if (add_rata)
|
|
{
|
|
if (id_rec.full())
|
|
add_rbrother(s);
|
|
else
|
|
add_son(s);
|
|
curr_id(id_rec);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (goto_node(id_year))
|
|
expand();
|
|
|
|
return goto_root();
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////
|
|
// TScad_mask
|
|
///////////////////////////////////////////////////////////
|
|
|
|
class TScad_mask : public TAutomask
|
|
{
|
|
protected:
|
|
virtual bool on_field_event(TOperable_field& o, TField_event e, long jolly);
|
|
|
|
public:
|
|
TScad_mask() : TAutomask("sc0300b") {}
|
|
};
|
|
|
|
bool TScad_mask::on_field_event(TOperable_field& o, TField_event e, long jolly)
|
|
{
|
|
switch (o.dlg())
|
|
{
|
|
case F_TUTTE:
|
|
if (e == se_query_add || e == se_query_del)
|
|
return false;
|
|
if (e = fe_close)
|
|
{
|
|
TSheet_field& s = (TSheet_field&)o;
|
|
real tot, imp = get_real(F_IMPORTO);
|
|
FOR_EACH_SHEET_ROW(s, r, row)
|
|
tot += real(row->get(0));
|
|
if (tot > imp)
|
|
return error_box(FR("Il totale degli importi (%s) supera la cifra disponibile (%s)"),
|
|
tot.stringa(), imp.stringa());
|
|
}
|
|
break;
|
|
default: break;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////
|
|
// TPareggio_mask
|
|
///////////////////////////////////////////////////////////
|
|
|
|
class TPareggio_mask : public TAutomask
|
|
{
|
|
TPareggio_tree _nc, _ft;
|
|
long _numreg;
|
|
|
|
protected:
|
|
virtual bool on_field_event(TOperable_field& o, TField_event e, long jolly);
|
|
|
|
const TString& reg2caus(const TString& reg) const;
|
|
bool ft2nc(const TRectype& rec);
|
|
bool abbuona_rata(const real& imp, const TRectype& nota, TRiga_scadenze& scad);
|
|
bool elabora(const TRectype& nota, TPointer_array& scadenze);
|
|
void refill();
|
|
|
|
public:
|
|
TPareggio_mask();
|
|
};
|
|
|
|
// Cerca una causale di nota di credito compatibile col registro reg
|
|
const TString& TPareggio_mask::reg2caus(const TString& reg) const
|
|
{
|
|
if (reg.full())
|
|
{
|
|
const char tipocf = get(F_TIPO)[0];
|
|
const TString& codcaus = get(tipocf == 'F' ? F_CODCAUS_F : F_CODCAUS_C);
|
|
const TString& cod = cache().get(LF_CAUSALI, codcaus, CAU_REG);
|
|
if (cod == reg)
|
|
return codcaus; // Siamo fortunati: va bene la causale standard
|
|
|
|
TISAM_recordset recset("USE CAUS SELECT (REG=#CODREG)&&(TIPOMOV=2)");
|
|
recset.set_var("#CODREG", reg);
|
|
if (recset.move_first())
|
|
return recset.get(CAU_CODCAUS).as_string();
|
|
}
|
|
return EMPTY_STRING;
|
|
}
|
|
|
|
// Trasforma una fattura negativa in nota di credito
|
|
bool TPareggio_mask::ft2nc(const TRectype& rec)
|
|
{
|
|
CHECK(rec.num() == LF_PARTITE, "Solo partite, grazie!");
|
|
const long numreg = rec.get_long(PART_NREG);
|
|
const TString4 codreg = rec.get(PART_REG);
|
|
const TString4 codcau = reg2caus(codreg);
|
|
if (codcau.blank())
|
|
return error_box(FR("E' necessario creare una causale di nota di credito sul registro %s"), (const char*)codreg);
|
|
|
|
TString msg;
|
|
msg << TR("Si desidera trasformare la fattura in nota di credito con causale ")
|
|
<< codcau << '\n' << cache().get(LF_CAUSALI, codcau, CAU_DESCR);
|
|
if (!yesno_box(msg))
|
|
return false;
|
|
|
|
int err = NOERR;
|
|
if (numreg > 0)
|
|
{
|
|
TLocalisamfile mov(LF_MOV);
|
|
mov.curr().put(MOV_NUMREG, numreg);
|
|
err = mov.read(_isequal, _lock);
|
|
if (err == NOERR)
|
|
{
|
|
mov.put(MOV_CODCAUS, codcau);
|
|
mov.put(MOV_TIPOMOV, tm_nota_credito);
|
|
err = mov.rewrite();
|
|
}
|
|
if (err != NOERR)
|
|
return error_box(FR("Impossibile modificare il movimento %ld: errore %d"), numreg, err);
|
|
}
|
|
|
|
if (err == NOERR)
|
|
{
|
|
TPartita& game = _nc.partita(rec);
|
|
const int nriga = game.prima_fattura(numreg);
|
|
if (nriga > 0)
|
|
{
|
|
TRiga_partite& fatt = game.riga(nriga);
|
|
fatt.put(PART_CODCAUS, codcau);
|
|
fatt.put(PART_TIPOMOV, tm_nota_credito);
|
|
TRectype& pag = game.unassigned().row(nriga, true);
|
|
pag.put(PAGSCA_IMPORTO, fatt.get(PART_IMPORTO));
|
|
err = game.rewrite() ? NOERR : _islocked;
|
|
}
|
|
else
|
|
err = _iskeynotfound;
|
|
}
|
|
if (err != NOERR)
|
|
return error_box(FR("Impossibile modificare la partita associata al movimento %ld: errore %d"), numreg, err);
|
|
|
|
return true;
|
|
}
|
|
|
|
bool TPareggio_mask::abbuona_rata(const real& imp, const TRectype& nota, TRiga_scadenze& scad)
|
|
{
|
|
const TValuta valuta(scad.riga());
|
|
const bool in_valuta = valuta.in_valuta() ;
|
|
const char* imp_field = in_valuta ? PAGSCA_IMPORTOVAL : PAGSCA_IMPORTO;
|
|
|
|
TPartita& nc = _nc.partita(nota);
|
|
TPartita& ft = scad.partita();
|
|
|
|
TRiga_partite& new_nc = ft.new_row();
|
|
new_nc.put(PART_SEZ, scad.riga().get_char(PART_SEZ) == 'D' ? 'A' : 'D');
|
|
new_nc.put(PART_TIPOMOV, nota.get(PART_TIPOMOV));
|
|
new_nc.put(PART_NREG, nota.get(PART_NREG));
|
|
new_nc.put(PART_NUMRIG, max(nota.get_int(PART_NUMRIG),1)); // corretto 24-09-2012 !
|
|
new_nc.put(PART_CODCAUS, nota.get(PART_CODCAUS));
|
|
new_nc.put(PART_REG, nota.get(PART_REG));
|
|
new_nc.put(PART_NUMDOC, nota.get(PART_NUMDOC));
|
|
new_nc.put(PART_DATADOC, nota.get(PART_DATADOC));
|
|
|
|
TRectype new_pag = scad.new_row(new_nc.get_int(PART_NRIGA));
|
|
new_pag.put(imp_field, imp);
|
|
ft.modifica_pagamento(new_pag, valuta, true);
|
|
ft.write(true);
|
|
|
|
TRecord_array& unarray = nc.unassigned();
|
|
TRectype unass = unarray.row(nota.get_int(PART_NRIGA));
|
|
if (new_nc.get(PART_SEZ) == nota.get(PART_SEZ))
|
|
unass.add(imp_field, -imp);
|
|
else
|
|
unass.add(imp_field, imp);
|
|
nc.modifica_pagamento(unass, valuta, true);
|
|
nc.write(true);
|
|
|
|
return true;
|
|
}
|
|
|
|
bool TPareggio_mask::elabora(const TRectype& nota, TPointer_array& scadenze)
|
|
{
|
|
CHECK(nota.num() == LF_PARTITE, "Solo partite, grazie!");
|
|
const tipo_movimento tm = (tipo_movimento)nota.get_int(PART_TIPOMOV);
|
|
if (tm == tm_fattura && !ft2nc(nota)) // Trasforma eventuale fattura negativa
|
|
return false;
|
|
|
|
TScad_mask ass;
|
|
const TString& codval = get(F_CODVAL);
|
|
ass.set(F_CODVAL, codval);
|
|
const bool in_valuta = is_true_value(codval);
|
|
|
|
real residuo_nc = abs(nota.get_real(in_valuta ? PART_IMPORTOVAL : PART_IMPORTO));
|
|
ass.set(F_IMPORTO, residuo_nc);
|
|
|
|
TSheet_field& sheet = ass.sfield(F_TUTTE);
|
|
TString_array rate;
|
|
FOR_EACH_ARRAY_ITEM(scadenze, i, s)
|
|
{
|
|
const TRiga_scadenze& scad = *(TRiga_scadenze*)s;
|
|
TToken_string& row = sheet.row(-1);
|
|
const real residuo_scad = scad.residuo(true).valore();
|
|
real imp = residuo_nc;
|
|
if (imp > residuo_scad)
|
|
imp = residuo_scad;
|
|
row.add(imp.string());
|
|
residuo_nc -= imp;
|
|
row.add(scad.get(SCAD_DATASCAD));
|
|
row.add(residuo_scad.string());
|
|
row.add(scad.importo(true).valore().string());
|
|
}
|
|
|
|
if (ass.run() == K_ENTER)
|
|
{
|
|
FOR_EACH_SHEET_ROW(sheet, r, row)
|
|
{
|
|
const real imp = row->get(0);
|
|
if (imp > ZERO)
|
|
{
|
|
TRiga_scadenze& scad = (TRiga_scadenze&)scadenze[r];
|
|
abbuona_rata(imp, nota, scad);
|
|
}
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
void TPareggio_mask::refill()
|
|
{
|
|
TWait_cursor hourglass;
|
|
const short id = efield(F_FORNITORE).active() ? F_FORNITORE :
|
|
(efield(F_SOTTOCONTO).active() ? F_SOTTOCONTO : F_CLIENTE);
|
|
TBill bill; bill.get(*this, F_GRUPPO, F_CONTO, id, F_TIPO);
|
|
|
|
if (bill.sottoconto() <= 0)
|
|
return;
|
|
|
|
const int tipo = get_int(F_TUTTE);
|
|
const TString& codval = get(F_CODVAL);
|
|
_nc.init(bill, codval, true, tipo);
|
|
_ft.init(bill, codval, false, tipo);
|
|
|
|
tfield(F_NC_TREE).set_tree(&_nc);
|
|
tfield(F_FT_TREE).set_tree(&_ft);
|
|
|
|
_numreg = 0;
|
|
disable(DLG_LINK);
|
|
disable(DLG_RECALC);
|
|
}
|
|
|
|
bool TPareggio_mask::on_field_event(TOperable_field& o, TField_event e, long jolly)
|
|
{
|
|
switch (o.dlg())
|
|
{
|
|
//case F_SOTTOCONTO:
|
|
case F_CLIENTE:
|
|
case F_FORNITORE:
|
|
if (e == fe_modify && !o.empty())
|
|
refill();
|
|
break;
|
|
case F_CODVAL:
|
|
case F_TUTTE:
|
|
if (e == fe_modify)
|
|
refill();
|
|
break;
|
|
case F_CODCAUS_C:
|
|
case F_CODCAUS_F:
|
|
if (e == fe_init)
|
|
{
|
|
TEdit_field& e = (TEdit_field&)o;
|
|
TCursor& cur = *e.browse()->cursor();
|
|
cur = 0L;
|
|
e.set(cur.curr().get(CAU_CODCAUS));
|
|
}
|
|
break;
|
|
case F_NC_TREE:
|
|
case F_FT_TREE:
|
|
if (e == fe_button || e == fe_modify || e == fe_init)
|
|
{
|
|
_numreg = 0L;
|
|
|
|
TTree_field& tf = (TTree_field&)o;
|
|
if (tf.tree() != NULL)
|
|
{
|
|
TVariant var;
|
|
if (tf.tree()->get_var("PART.NREG", var))
|
|
_numreg = var.as_int();
|
|
}
|
|
enable(DLG_LINK, _numreg > 0);
|
|
|
|
bool can_conv = false;
|
|
if (_numreg > 0 && o.dlg() == F_NC_TREE)
|
|
{
|
|
TLocalisamfile mov(LF_MOV);
|
|
mov.put(MOV_NUMREG, _numreg);
|
|
can_conv = mov.read() == NOERR && mov.get_int(MOV_TIPOMOV) == tm_fattura;
|
|
}
|
|
enable(DLG_RECALC, can_conv);
|
|
|
|
const bool can_work = _nc.has_root() && _ft.has_root();
|
|
enable(DLG_ELABORA, can_work);
|
|
}
|
|
break;
|
|
case DLG_LINK:
|
|
if (_numreg > 0)
|
|
{
|
|
TRectype mov(LF_MOV);
|
|
mov.put(MOV_NUMREG, _numreg);
|
|
if (mov.edit())
|
|
refill();
|
|
}
|
|
break;
|
|
case DLG_RECALC:
|
|
if (e == fe_button)
|
|
{
|
|
const TRectype* nota = _nc.node2rec(EMPTY_STRING);
|
|
if (nota != NULL && ft2nc(*nota))
|
|
refill();
|
|
}
|
|
break;
|
|
case DLG_ELABORA:
|
|
if (e == fe_button)
|
|
{
|
|
const TRectype* nota = _nc.node2rec(EMPTY_STRING);
|
|
if (nota == NULL)
|
|
return error_box(TR("Selezionare una nota di credito nel pannello di sinistra"));
|
|
|
|
const TTree_field& ft = tfield(F_FT_TREE);
|
|
TPointer_array rate;
|
|
TString_array a;
|
|
if (ft.selection(a) > 0)
|
|
{
|
|
FOR_EACH_ARRAY_ROW(a, r, riga)
|
|
{
|
|
const TRectype* rec = _ft.node2rec(*riga);
|
|
if (rec)
|
|
rate.add((TRectype*)rec);
|
|
}
|
|
}
|
|
|
|
if (rate.items() > 0)
|
|
{
|
|
if (elabora(*nota, rate))
|
|
refill();
|
|
}
|
|
else
|
|
return error_box(TR("Selezionare almeno una rata nel pannello di destra"));
|
|
}
|
|
break;
|
|
default: break;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
TPareggio_mask::TPareggio_mask() : TAutomask("sc0300a"), _numreg(0L)
|
|
{
|
|
TTree_field& nc = tfield(F_NC_TREE);
|
|
TTree_field& ft = tfield(F_FT_TREE);
|
|
|
|
RCT rct_nc; nc.get_rect(rct_nc);
|
|
RCT rct_ft; ft.get_rect(rct_ft);
|
|
RCT rct_ms; xvt_vobj_get_client_rect(nc.parent(), &rct_ms);
|
|
const int b = rct_nc.left;
|
|
|
|
rct_nc.right = rct_ft.left-b;
|
|
rct_ft.right = rct_ms.right - b;
|
|
|
|
nc.set_rect(rct_nc);
|
|
ft.set_rect(rct_ft);
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////
|
|
// TPareggio_partite
|
|
///////////////////////////////////////////////////////////
|
|
|
|
class TPareggio_partite : public TSkeleton_application
|
|
{
|
|
protected:
|
|
virtual void main_loop();
|
|
};
|
|
|
|
void TPareggio_partite::main_loop()
|
|
{
|
|
const int anno = xvt_vobj_get_attr(NULL_WIN, ATTR_APPL_VERSION_YEAR);
|
|
if (anno >= 2121)
|
|
{
|
|
TPareggio_mask pm;
|
|
pm.run();
|
|
}
|
|
else
|
|
error_box(TR("Versione non supportata: %d"), anno);
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////
|
|
// Main
|
|
///////////////////////////////////////////////////////////
|
|
|
|
int sc0300(int argc, char* argv[])
|
|
{
|
|
TPareggio_partite pp;
|
|
pp.run(argc, argv, TR("Pareggio Partite"));
|
|
return 0;
|
|
}
|