root/campo-sirio
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
campo-sirio/lv/lv3400.cpp
luca83 57d140b8fe Patch level : 10.0 patch 510 
Files correlati     : lv3
Ricompilazione Demo : [ ]
Commento            :
Corretta la gestione dei tasti funzione


git-svn-id: svn://10.65.10.50/trunk@19618 c028cbd2-c16b-5b4b-a496-9718f37d4682
2009-11-12 16:06:33 +00:00

924 lines
23 KiB
C++
Executable File
Raw Blame History

#include <applicat.h>
#include <automask.h>
#include <defmask.h>
#include <execp.h>
#include <reputils.h>
#include <reprint.h>
#include <toolfld.h>
#include <utility.h>
#include "lvlib.h"
#include "../mg/clifogiac.h"
#include "../ve/velib.h"
#include "clifo.h"
#include "lvcondv.h"
#include "lvrcondv.h"
#include "lvrconsplan.h"
#include "lv3400a.h"
//////////////////////////////
//// TQUANTITA_RIGA ////
//////////////////////////////
//Classe TQuantita_riga
class TQuantita_riga: public TObject
{
int _nriga;
bool _evaso;
long _qtadacon;
long _qtacon;
int _pacchi;
public:
int get_nriga() const;
bool get_evaso() const;
long get_qta_da_con() const;
long get_qta_con() const;
int get_pacchi() const;
void set_nriga(const int nriga);
void set_evaso(const bool evaso);
void set_qta_da_con(const long qta);
void set_qta_con(const long qta);
void set_pacchi(const int pacchi);
void add_qta_con(const long qta);
void add_pacchi(const int pacchi = 1);
TQuantita_riga(bool evaso = false, long qtadc = 0, long qtac = 0, int pacchi = 0);
};
//GET_NRIGA: metodo che restituisce il numero di riga
int TQuantita_riga::get_nriga() const
{
return _nriga;
}
//GET_EVASO: metodo che restituisce il booleano evaso
bool TQuantita_riga::get_evaso() const
{
return _evaso;
}
//GET_QTA_DA_CON: metodo che restituisce la quantità da consegnare
long TQuantita_riga::get_qta_da_con() const
{
return _qtadacon;
}
//GET_QTA_CON: metodo che restituisce la quantità consegnata
long TQuantita_riga::get_qta_con() const
{
return _qtacon;
}
//GET_PACCHI: metodo che restituisce il humero dei pacchi consegnati
int TQuantita_riga::get_pacchi() const
{
return _pacchi;
}
//SET_NRIGA: metodo che setta il numero di riga
void TQuantita_riga::set_nriga(const int nriga)
{
_nriga = nriga;
}
//SET_EVASO: metodo che setta il booleano evaso
void TQuantita_riga::set_evaso(const bool evaso)
{
_evaso = evaso;
}
//SET_QTA_DA_CON: metodo che settala quantità da consegnare
void TQuantita_riga::set_qta_da_con(const long qta)
{
_qtadacon = qta;
}
//SET_QTA_CON: metodo che setta la quantità consegnata
void TQuantita_riga::set_qta_con(const long qta)
{
_qtacon = qta;
}
//SET_PACCHI: metodo che setta il hnumero di pacchi consegnato
void TQuantita_riga::set_pacchi(const int pacchi)
{
_pacchi = pacchi;
}
//ADD_QTA_CON: metodo che aggiunge un quantitativo di roba alla quantità consegnata
void TQuantita_riga::add_qta_con(const long qta)
{
_qtacon += qta;
}
//ADD_PACCHI: metodo che aggiunge un certo numero di pacchi a quelli consegnati (default = 1)
void TQuantita_riga::add_pacchi(const int pacchi)
{
_pacchi += pacchi;
}
//metodo costruttore
TQuantita_riga::TQuantita_riga(bool evaso, long qtadc, long qtac, int pacchi)
{
set_evaso(evaso);
set_qta_da_con(qtadc);
set_qta_con(qtac);
set_pacchi(pacchi);
}
////////////////////////////
//// TRIGHE_ARRAY ////
////////////////////////////
//Classe TRighe_array
class TRighe_array: public TAssoc_array
{
public:
TQuantita_riga* quantita(TString& codart, TDate& data, bool create);
};
//QUANTITA: metodo che cerca nel TAssoc_array le quantità della riga interessata in base ai parametri passati
//e lo crea in automatico se il parametro create vale "true"
TQuantita_riga* TRighe_array::quantita(TString& codart, TDate& data, bool create)
{
TToken_string key;
key.add(codart);
key.add(data);
TQuantita_riga* qr = (TQuantita_riga*)objptr(key);
if(qr == NULL && create)
{
qr = new TQuantita_riga();
add(key, qr);
}
return qr;
}
//class TEvasione_ter_msk
class TEvasione_ter_msk: public TAutomask
{
int _ndoc;
int _autoselect;
TString4 _tpev;
TAssoc_array _pacchi;
TRighe_array _ra;
protected:
void campi_cliente();
void precarica_righe();
void genera_buono();
void evadi();
void registra();
void riempi_sheet();
void spezza_riga();
bool controlla();
void evadi_da_terminale();
virtual void on_idle();
virtual bool on_key(KEY key);
virtual bool on_field_event(TOperable_field& o, TField_event e, long jolly);
public:
TEvasione_ter_msk();
};
bool TEvasione_ter_msk::on_key(KEY key)
{
if (key >= K_F3 && key <= K_F7)
{
FOR_EACH_MASK_FIELD(*this, i, f)
{
if (f->is_kind_of(CLASS_BUTTON_TOOL) && f->active())
{
TButton_tool& tf = (TButton_tool&)*f;
if (tf.exit_key() == key)
{
send_key(K_SPACE, f->dlg());
return true;
}
}
}
}
return TAutomask::on_key(key);
}
//PRECARICA_RIGHE: metodo che carica in un TAssoc_array le righe documento
void TEvasione_ter_msk::precarica_righe()
{
TDoc_key kdoc(get_date(F_TDATADOC).year(), ini_get_string(CONFIG_DITTA, "lv", "NUM_PRE", NULL, 0), get_long(F_TNDOC));
TBuono_prelievo doc(kdoc);
TDate oggi(TODAY);
for(int i = 1; i <= doc.rows(); i++)
{
TRiga_documento& row = doc[i];
TBuono_prelievo_row rdoc(row);
TDate dataeva = rdoc.dataeva();
if (!dataeva.ok())
dataeva = oggi;
TString80 codart = rdoc.codart();
TQuantita_riga* qr = _ra.quantita(codart, dataeva, true);
qr->set_nriga(i);
qr->set_evaso(rdoc.evaso());
qr->set_qta_da_con(rdoc.qta_dacons());
qr->set_qta_con(rdoc.qta_consegnata());
qr->set_pacchi(rdoc.num_pacchi());
}
}
//GENERA_BUONO: metodo che genera il buono di consegna partendo dal buono di ritiro
void TEvasione_ter_msk::genera_buono()
{
//per prima cosa salva il buono di prelievo
registra();
TDoc_key kdoc(get_date(F_TDATADOC).year(), ini_get_string(CONFIG_DITTA, "lv", "NUM_PRE", NULL, 0), get_long(F_TNDOC));
TBuono_prelievo bpre(kdoc);
const long codcf = bpre.codcf();
const int codcont = bpre.codcont();
TLaundry_contract cont(codcf, codcont);
//leggo se devo scrivere il prezzo sulla bolla
//const bool prinbo = cont.get_bool(LVCONDV_STPRZBOL);
const bool prinbo = true; //sempre a true; verrà gestita a video in futuro (27/10/2009)
//dati documento da generare
TString4 codnum = ini_get_string(CONFIG_DITTA, "lv", "NUM_GEN");
TString4 tipodoc = ini_get_string(CONFIG_DITTA, "lv", "TIPODOC_GEN");
char stato = cache().get("%TIP", tipodoc, "S2").left(1)[0];
const TDate databpre = bpre.datadoc();
const TDate databolla = get_date(F_TDATADOC);
const TDate datagen(TODAY);
TDate dadata = databpre;
TDate adata = datagen;
adata.addmonth();
if(_ndoc == 0)
{
TString query2;
query2 << "USE DOC\n"
<< "FROM PROVV=\"D\" ANNO=" << datagen.year() << " CODNUM=\"" << codnum << "\"\n"
<< "TO PROVV=\"D\" ANNO=" << datagen.year() << " CODNUM=\"" << codnum << "\"";
TISAM_recordset bolle(query2);
bolle.move_last();
_ndoc = bolle.get(DOC_NDOC).as_int();
}
TString query1 = "USE LVRCONSPLAN KEY 3\n";
query1 << "FROM CODCF=" << codcf << " CODCONT=" << codcont << " DTCONS=#DADATA\n";
query1 << "TO CODCF=" << codcf << " CODCONT=" << codcont << " DTCONS=#ADATA\n";
TISAM_recordset consegne(query1);
consegne.set_var("#DADATA", ++dadata);
consegne.set_var("#ADATA", adata);
consegne.move_first();
const TDate dataprco = consegne.get(LVRCONSPLAN_DTCONS).as_date();
const int coditi = consegne.get(LVRCONSPLAN_CODITI).as_int();
//recupero il codpag
TToken_string key;
key.add('C');
key.add(codcf);
const TString4 codpag = cache().get(LF_CLIFO, key, CLI_CODPAG);
//reupero la cuasale di magazzino di testata
const TString16 causmag = cache().get("%TIP", tipodoc, "S9");
//preparo la testata del documento
TDocumento doc('D', kdoc.anno(), codnum, ++_ndoc);
doc.put(DOC_TIPODOC, tipodoc);
doc.put(DOC_STATO, stato);
doc.put(DOC_DATADOC, databolla);
doc.put(DOC_TIPOCF, 'C');
doc.put(DOC_CODCF, codcf);
doc.put(DOC_CODCONT, codcont);
doc.put(DOC_CODPAG, codpag);
doc.put(DOC_CAUSMAG, causmag);
doc.put("DATAGEN", datagen); //data generazione del documento
doc.put("DATAPRCO", dataprco); //data prevista consegna
doc.put("CODITI", coditi); //codice itinerario
for (int i = 1; i <= bpre.rows(); i++)
{
TRiga_documento& row = bpre[i];
TBuono_prelievo_row rbpre(row);
//nella bolla ci vanno solo le righe evase e non associate
if (!rbpre.evaso())
continue;
TDoc_key kbuono = rbpre.rifbcon();
if (kbuono.full())
continue;
const TString80 codart = rbpre.codart();
TString descr = rbpre.desart();
const TRectype& rcont = cont.row(codart);
//recupero i valori delle dotazione temporanea dal magazzino del cliente
TLocalisamfile magcli(LF_CLIFOGIAC);
magcli.put(CLIFOGIAC_ANNOES, datagen.year());
magcli.put(CLIFOGIAC_TIPOCF, 'C');
magcli.put(CLIFOGIAC_CODCF, codcf);
magcli.put(CLIFOGIAC_INDSPED, 0); //in realtà è da leggere dal contratto
magcli.put(CLIFOGIAC_CODART, codart);
magcli.put(CLIFOGIAC_NRIGA, 1);
//leggo il record corrispondente
magcli.read();
long dottmp = magcli.get_long(CLIFOGIAC_DOTTM);
long dotod = magcli.get_long(CLIFOGIAC_DOTOD);
//recupero l'unità di misura principale di quest'articolo
TToken_string key;
key.add(codart);
key.add(1);
const TString4 um = cache().get(LF_UMART, key, UMART_UM);
TRiga_documento& rdoc = doc.new_row("21");
rdoc.put(RDOC_CODART, codart);
rdoc.put(RDOC_CODARTMAG,codart);
rdoc.put(RDOC_CHECKED,'X');
rdoc.put(RDOC_GENERATA, true);
if(descr.len() <= 50)
rdoc.put(RDOC_DESCR, descr);
else
{
rdoc.put(RDOC_DESCR, descr.left(50));
rdoc.put(RDOC_DESCEST, descr.sub(50));
rdoc.put(RDOC_DESCLUNGA, true);
}
rdoc.put(RDOC_QTA, rbpre.qta_consegnata()); //consegnato
rdoc.put(RDOC_QTAGG1, rbpre.qta_ritirata()); //ritirato
dotod += (rbpre.qta_consegnata() - rbpre.qta_ritirata());
rdoc.put("DOTOD", dotod);
bool dtmp = false;
if (datagen >= rcont.get_date(LVRCONDV_INDTTMP) && datagen <= rcont.get_date(LVRCONDV_FIDTTMP))
dtmp = true;
if(dtmp)
{
rdoc.put("DOTMP", dottmp);
rdoc.add("DOTMP", rbpre.qta_consegnata() - rbpre.qta_ritirata());
}
rdoc.put(RDOC_CODAGG1, rbpre.causale());
const TRectype& anamag = cache().get(LF_ANAMAG, codart);
//gestione prezzo
if (prinbo)
{
real prezzo;
if (cont.get_int(LVCONDV_TIPOLIS) == 0)
prezzo = rcont.get_real(LVRCONDV_PREZZO);
else
prezzo = anamag.get_real(ANAMAG_COSTSTD);
rdoc.put(RDOC_PREZZO, prezzo);
rdoc.put(RDOC_SCONTO, rcont.get(LVRCONDV_SCONTPERC)); //sconto
}
rdoc.put(RDOC_UMQTA, um);
//scrivo il magazzino
TString8 magazzino;
TString8 magazzinoc;
magazzino << ini_get_string(CONFIG_DITTA, "lv", "CODMAG") << ini_get_string(CONFIG_DITTA, "lv", "CODMAGN");
magazzinoc << ini_get_string(CONFIG_DITTA, "lv", "CODMAG") << ini_get_string(CONFIG_DITTA, "lv", "CODMAGC");
rdoc.put(RDOC_CODMAG, magazzino);
rdoc.put(RDOC_CODMAGC, magazzinoc);
//salvo i riferimenti
TDoc_key rifbcon(datagen.year(), codnum, _ndoc);
rbpre.set_rifbcon(rifbcon);
}
//salva la bolla solo se ha almeno una riga
int err = 1;
if (doc.rows() > 0)
{
err = doc.write();
const TString4 stato = cache().get("%TIP", ini_get_string(CONFIG_DITTA, "lv", "TIPODOC_PRE", NULL, 0), "S2").mid(1,1);
bpre.put(DOC_STATO, stato);
bpre.rewrite();
}
if (err == NOERR)
{
if (yesno_box(TR("Il documento è stato generato; si desiderla stamparlo?")))
{
//stampa automatica
TString80 str;
str << "ve1 -2 " << codnum << ' ' << datagen.year() << " D " << _ndoc << " S D";
TExternal_app stampa(str);
stampa.run();
}
}
else
warning_box(TR("Non è stato possibile generare nessun documento"));
reset(F_TNDOC);
send_key(K_SPACE, F_TNDOC);
}
//EVADI: metodo che setta a evaso tutte le righe del documento
void TEvasione_ter_msk::evadi()
{
FOR_EACH_ASSOC_OBJECT(_ra, obj, key, itm)
{
TQuantita_riga* qr = (TQuantita_riga*)itm;
qr->set_evaso(true);
}
}
//REGISTRA: metodo che salva il buono di prelievo così com'è
void TEvasione_ter_msk::registra()
{
TDoc_key kdoc(get_date(F_TDATADOC).year(), ini_get_string(CONFIG_DITTA, "lv", "NUM_PRE", NULL, 0), get_long(F_TNDOC));
TBuono_prelievo doc(kdoc);
TDate oggi(TODAY);
FOR_EACH_ASSOC_OBJECT(_ra, obj, key, itm)
{
TQuantita_riga* qr = (TQuantita_riga*)itm;
int nriga = qr->get_nriga();
//se nriga > 0 vuol dire che si è aggiornata una riga già esistente;
//altrimenti significa che ho spezzato una riga
if (nriga > 0)
{
TRiga_documento& row = doc[nriga];
TBuono_prelievo_row rdoc(row);
rdoc.set_evaso(qr->get_evaso());
rdoc.set_qta_consegnata(qr->get_qta_con());
rdoc.set_qta_dacons(qr->get_qta_da_con());
rdoc.set_num_pacchi(qr->get_pacchi());
rdoc.set_dataeva(oggi);
}
else
{
//trovo la riga con quel codart
TToken_string chiave(key);
TString80 codart = chiave.get(0);
int i;
for(i = 1; i <= doc.rows(); i++)
{
TRiga_documento& row = doc[i];
if(codart == row.get(RDOC_CODART))
break;
}
//creo una copia di questa riga
TRiga_documento& row1 = doc[i];
TRiga_documento& row2 = doc.new_row("24");
row2 = row1;
TBuono_prelievo_row rdoc(row2);
//setto le quantità corrette
rdoc.set_evaso(qr->get_evaso());
rdoc.set_qta_consegnata(qr->get_qta_con());
rdoc.set_qta_dacons(qr->get_qta_da_con());
rdoc.set_num_pacchi(qr->get_pacchi());
rdoc.set_dataeva(oggi);
}
}
doc.rewrite();
//visto che sto evadendo tramite barcode quando salvo salvo anche tutti i pacchi associati
//generando i movimenti di magazzino di scarico
TLocalisamfile pacchi(LF_PACCHI);
TLocalisamfile movi(LF_MOVMAG);
//cerco l'ultimo numero di chiave in movmag
TISAM_recordset mov("USE MOVMAG");
long nummov = 0;
if(mov.move_last())
nummov += mov.get(MOVMAG_NUMREG).as_int();
const TCausale_magazzino causale((ini_get_string(CONFIG_DITTA, "lv", "CAUSCARMAG")));
TString8 magazzino;
magazzino << ini_get_string(CONFIG_DITTA, "lv", "CODMAG") << ini_get_string(CONFIG_DITTA, "lv", "CODMAGP");
TEsercizi_contabili es;
int annoes = es.date2esc(oggi);
TMov_mag movmag(++nummov);
movmag.put(MOVMAG_ANNOES, annoes);
movmag.put(MOVMAG_DATAREG, oggi);
movmag.put(MOVMAG_CODCAUS, causale.codice());
FOR_EACH_ASSOC_OBJECT(_pacchi, o, codpacco, rifdoc)
{
TDoc_key kdoc = *(TToken_string*)rifdoc;
TRiga_pacco rp(codpacco);
const TString80 codart = rp.articolo();
const long qta = rp.quantita().integer();
//recupero l'unità di misura principale di quest'articolo
TToken_string key;
key.add(codart);
key.add(1);
const TString4 um = cache().get(LF_UMART, key, UMART_UM);
rp.set_rigabolla(kdoc.anno(), kdoc.codnum(), kdoc.ndoc(), 0); //SOLUZIONE MOMENTANEA PER VEDERE SE FUNZIONA TUTTO
rp.rewrite(pacchi);
//faccio la nuova riga del movimento di magazzino
TRectype& rmovmag = movmag.new_row();
rmovmag.put(RMOVMAG_CODMAG, magazzino);
rmovmag.put(RMOVMAG_CODART, codart);
rmovmag.put(RMOVMAG_UM, um);
rmovmag.put(RMOVMAG_QUANT, qta);
}
movmag.write(movi);
}
void TEvasione_ter_msk::riempi_sheet()
{
TSheet_field& sheet = sfield(F_TRIGHE);
sheet.destroy();
FOR_EACH_ASSOC_OBJECT(_ra, obj, key, itm)
{
TToken_string chiave(key);
TQuantita_riga& qr = *(TQuantita_riga*)itm;
if(!qr.get_evaso())
{
TToken_string riga = sheet.row(-1);
riga.add("", 0);
riga.add(chiave.get(0), 1);
riga.add(qr.get_qta_da_con(), 2);
riga.add(qr.get_qta_con(), 3);
}
}
sheet.force_update();
}
void TEvasione_ter_msk::spezza_riga()
{
const TDate oggi(TODAY);
const TDate nulla(NULLDATE);
FOR_EACH_ASSOC_OBJECT(_ra, obj, key, itm)
{
TToken_string chiave(key);
TQuantita_riga& qr = *(TQuantita_riga*)itm;
if((TDate)chiave.get() == oggi && !qr.get_evaso())
{
int qtadacon = qr.get_qta_da_con();
int qtacon = qr.get_qta_con();
int pacchi = qr.get_pacchi();
qr.set_evaso(true);
qr.set_qta_da_con(qtacon);
TToken_string chiave1;
chiave1.add(chiave.get(0), 0);
chiave1.add(nulla, 1);
TQuantita_riga qr1;
qr1.set_evaso(false);
qr1.set_qta_da_con(qtadacon - qtacon);
qr1.set_qta_con(0);
qr1.set_pacchi(0);
_ra.add(chiave1, qr1);
}
}
}
bool TEvasione_ter_msk::controlla()
{
bool evaso = true;
FOR_EACH_ASSOC_OBJECT(_ra, obj, key, itm)
{
TQuantita_riga* qr = (TQuantita_riga*)itm;
if(!qr->get_evaso())
{
evaso = false;
break;
}
}
return evaso;
}
//EVADI_DA_TERMINALE: metodo che somma alla riga corretta un pacco (quello pistolato) e lo assegna a un cliente,
//sottraendolo dal magazzino del pulito
void TEvasione_ter_msk::evadi_da_terminale()
{
TString80 codpacco = get(F_TBARCODE);
const TDate oggi(TODAY);
if (codpacco.full())
{
const TRiga_pacco rp(codpacco);
const TString80 codart = rp.articolo();
const long qtapacco = rp.quantita().integer();
//se il pacco è già stato pistolettato lo tolgo dai pacchi da evadere, altrimenti cerco di sommarlo
//a una riga documento esistente
if (_pacchi.is_key(codpacco))
{
_pacchi.remove(codpacco);
TToken_string key;
key.add(codart);
key.add(oggi);
if (_ra.is_key(key))
{
TQuantita_riga& qr = *(TQuantita_riga*)_ra.objptr(key);
qr.add_pacchi(-1);
qr.add_qta_con(-1 * qtapacco);
if (qr.get_evaso())
qr.set_evaso(false);
}
}
else
{
TDoc_key kdoc(get_date(F_TDATADOC).year(), ini_get_string(CONFIG_DITTA, "lv", "NUM_PRE", NULL, 0), get_int(F_TNDOC));
TToken_string key;
key.add(codart);
key.add(oggi);
if (_ra.is_key(key))
{
TQuantita_riga& qr = *(TQuantita_riga*)_ra.objptr(key);
if (qr.get_evaso())
{
if(yesno_box(TR("Si desidera sommare il pacco a una riga già evasa?")))
{
qr.add_pacchi();
qr.add_qta_con(qtapacco);
}
}
else
{
qr.add_pacchi();
qr.add_qta_con(qtapacco);
if(qr.get_qta_con() > qr.get_qta_da_con())
{
warning_box(TR("ATTENZIONE: si sta consegnando un quantitativo maggiore al dovuto"));
qr.set_evaso(true);
}
}
_pacchi.add(codpacco, kdoc);
}
else
warning_box(TR("Non è stato possibile sommare il pacco a nessuna riga del buono"));
}
}
}
//ON_FIELD_EVENT: metodo che gestisce gli eventi sui campi della maschera
bool TEvasione_ter_msk::on_field_event(TOperable_field& f, TField_event e, long jolly)
{
//a seconda del bottone premuto esegui un metodo diverso
switch (f.dlg())
{
case DLG_SELECT:
if (e == fe_button)
{
evadi();
return false;
}
break;
case DLG_PREVIEW:
if (e == fe_button)
{
show(F_TBARCODE);
show(F_TPACCHI);
show(F_TQTAPACCO);
show(F_TQTACON);
show(F_TQTADACON);
show(F_TRIGHE);
riempi_sheet();
return false;
}
break;
case DLG_ELABORA:
if (e == fe_button)
if (controlla())
genera_buono();
else
{
if(yesno_box(TR("ATTENZIONE: non tutte le righe sono evase. Si desidera continuare ugualmente?")))
{
if(yesno_box(TR("Si desidera considerare evase tutte le righe?"
"(in caso contrario le righe evase parzialmente verranno spezzate su due righe)")))
evadi();
else
{
spezza_riga();
genera_buono();
}
}
else
send_key(K_SPACE, DLG_CANCEL);
}
return false;
break;
case DLG_CANCEL:
if (e == fe_button && jolly == 0)
{
show(F_TBARCODE);
show(F_TPACCHI);
show(F_TQTAPACCO);
show(F_TQTACON);
show(F_TQTADACON);
hide(F_TRIGHE);
_autoselect = 1;
return false;
}
break;
case DLG_SAVEREC:
if (e == fe_button)
{
registra();
return false;
}
break;
case F_TNDOC:
{
if (e == fe_modify)
if (!f.empty())
{
show(F_TCODCF);
show(F_TRAGSOC);
show(F_TBARCODE);
show(F_TPACCHI);
show(F_TQTAPACCO);
show(F_TQTACON);
show(F_TQTADACON);
hide(F_TCODNUM);
hide(F_TTPDOC);
hide(F_TANNO);
hide(F_TDATAPRCO);
precarica_righe();
}
else
{
show(F_TCODNUM);
show(F_TTPDOC);
show(F_TANNO);
show(F_TDATAPRCO);
hide(F_TCODCF);
hide(F_TRAGSOC);
hide(F_TBARCODE);
hide(F_TPACCHI);
hide(F_TQTAPACCO);
hide(F_TQTACON);
hide(F_TQTADACON);
reset(F_TDATADOC);
_ra.destroy();
}
}
break;
case F_TBARCODE:
{
if (e == fe_modify && f.get().full())
{
_autoselect = 1;
evadi_da_terminale();
if (controlla())
send_key(K_SPACE, DLG_ELABORA);
}
}
default:break;
}
return true;
}
void TEvasione_ter_msk:: on_idle()
{
TMask::on_idle();
if (_autoselect >= 0 && get(F_TBARCODE).full())
{
reset(F_TBARCODE);
field(F_TBARCODE).set_focus();
_autoselect = -1;
}
}
TEvasione_ter_msk::TEvasione_ter_msk():TAutomask("lv3400a")
{
//precarico i campi fissi
set(F_TCODNUM, ini_get_string(CONFIG_DITTA, "lv", "NUM_PRE", NULL, 0));
set(F_TTPDOC, ini_get_string(CONFIG_DITTA, "lv", "TIPODOC_PRE", NULL, 0));
const TRectype& tpdoc = cache().get("%NUM", ini_get_string(CONFIG_DITTA, "lv", "TIPODOC_PRE", NULL, 0));
set(F_TDESCR, tpdoc.get("S0"));
TDate data(TODAY);
TEsercizi_contabili es;
int annoes = es.date2esc(data);
set(F_TANNO, annoes);
hide(F_TCODCF);
hide(F_TRAGSOC);
hide(F_TBARCODE);
hide(F_TPACCHI);
hide(F_TQTAPACCO);
hide(F_TQTACON);
hide(F_TQTADACON);
hide(F_TRIGHE);
}
/////////////////////////////////
//// TEVASIONE_TER_APP ////
/////////////////////////////////
//classe TEvasione_ter_app
class TEvasione_ter_app : public TSkeleton_application
{
TEvasione_ter_msk* _msk;
protected:
virtual bool create();
virtual bool destroy();
public:
bool transfer();
virtual void main_loop();
};
//CREATE: metodo costruttore
bool TEvasione_ter_app::create()
{
_msk = new TEvasione_ter_msk();
open_files(LF_DOC, LF_RIGHEDOC);
return TSkeleton_application::create();
}
//DESTROY: metodo distruttore
bool TEvasione_ter_app::destroy()
{
delete _msk;
return TApplication::destroy();
}
//TRANSFER: metodo che scorre i campi nome e, se sono pieni, richiama il metodo
//ELABORA_FILE(), che effettivamente fa l'elaborazione
bool TEvasione_ter_app::transfer()
{
return true;
}
void TEvasione_ter_app::main_loop()
{
while (_msk->run() == K_ENTER)
transfer();
}
int lv3400(int argc, char *argv[])
{
TEvasione_ter_app a;
a.run (argc, argv, "Evasione Buoni di Prelievo");
return TRUE;
}
Reference in New Issue View Git Blame Copy Permalink