root/campo-sirio
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
campo-sirio/cg/cg3400.cpp
guy 66fe24764c Aumentate ad uno sproposito di colonne tutte le stampe relative 
alla contabilita'.

cglib01.cpp  Cambiato il campo TIPOAPERS in TIPOPER per stabilire il
             tipo di anagrafica nell'oggetto TBill


git-svn-id: svn://10.65.10.50/trunk@5400 c028cbd2-c16b-5b4b-a496-9718f37d4682
1997-10-20 14:23:01 +00:00

1960 lines
54 KiB
C++
Executable File
Raw Blame History

// cg3400 - Stampa libro giornale
#include <config.h>
#include <mask.h>
#include <tabutil.h>
#include <printapp.h>
#include <progind.h>
#include <recarray.h>
#include <utility.h>
#include <urldefid.h>
#include <mov.h>
#include <rmov.h>
#include <rmoviva.h>
#include <nditte.h>
#include <anagr.h>
#include <anafis.h>
#include <anagiu.h>
#include <causali.h>
#include <comuni.h>
#include <pconti.h>
#include <clifo.h>
#include <occas.h>
#include "cglib01.h"
#include "cglib03.h"
#include "cg2103.h"
#include "cg3400a.h"
#include "cg3400b.h"
HIDDEN const char* REAL_PICTURE = "###.###.###.###.###";
HIDDEN const int RIGHE_FOOTER = 3;
HIDDEN const int WCAUS132 = 20;
HIDDEN const int WOPER132 = 28;
HIDDEN const int WCONTO132 = 35;
HIDDEN const int POSCONTO = 74;
HIDDEN const int DARE132 = 95;
HIDDEN const int AVERE132 = 112;
HIDDEN const int DARE198 = 152;
HIDDEN const int AVERE198 = 174;
HIDDEN const int SCRITTA = 26;
HIDDEN const int TOTDARE132 = 84;
HIDDEN const int SEZA132 = 108;
HIDDEN const int TOTAVERE132 = 110;
HIDDEN enum descr { causale, conto, operazione };
class TContoOccas : public TBill
{
long _s;
char _t;
TString _occfpi;
TString _descrizione;
public:
const TContoOccas& set(int g = 0, int c = 0, long s = 0L, char t = ' ',
const char* d = NULL, int r = -1, const char* occfpi = NULL);
const TString& descrizione();
TContoOccas() : _occfpi(NULL) {};
virtual ~TContoOccas() {};
};
const TContoOccas& TContoOccas::set(int g, int c, long s, char t,const char* d, int r, const char* occfpi)
{
_s = s; _t = t;
TBill::set(g,c,s,t,d,r);
_occfpi = occfpi;
return *this;
}
const TString& TContoOccas::descrizione()
{
bool really_occas = FALSE;
if (_occfpi.not_empty())
{
TLocalisamfile clifo(LF_CLIFO);
clifo.zero();
clifo.put(CLI_CODCF, (long)_s);
clifo.put(CLI_TIPOCF, _t);
const bool clifo_ok = (clifo.read() == NOERR);
if (clifo_ok)
really_occas = clifo.get_bool(CLI_OCCAS);
}
if (really_occas)
{
TLocalisamfile occ(LF_OCCAS);
occ.zero();
occ.put(OCC_CFPI, _occfpi);
if (occ.read() != NOERR) occ.zero();
_descrizione = occ.get("RAGSOC");
}
else
_descrizione = TBill::descrizione();
return _descrizione;
}
class TStampa_giornale : public TPrintapp
{
static bool mask_a_cod_reg (TMask_field& f, KEY k);
static bool data_a_hndl (TMask_field& f, KEY k);
static bool data_da_hndl (TMask_field& f, KEY k);
static bool mask_b_ripristina(TMask_field& f, KEY k);
static bool mask_b_warning (TMask_field& f, KEY k);
static bool filter_func(const TRelation * r);
static bool filtra_reg (const TRelation * r);
int righe_rimaste() const;
private:
TRelation* _rel;
TCursor* _cur;
TRectype* _RecPartoDa, *_RecArrivoA;
int _ae; // anno esercizio di ALLA_DATA
int _ae_solare; // anno esercizio solare usato per la tabella registri
int _tipo; // tipo del registro
int _annoEsMov; // anno esercizio letto da mov
TString16 _reg;
int _anno_iva;
bool _stampa_definitiva;
bool _MovGiaStampato;
bool _totals_updated;
bool _gia_settato_ariportare;
bool _forza_ariportare;
bool _devo_riportare; // Guy: Toliere sto casino se non funziona
bool _nuovo_mese; // Finito il mese ?
long _num_rig;
real _importo;
char _sezione;
int _pagine_contate; // cnt pag. stampate.
public:
TRigaiva_array _iva_array;
TString16 _reg_cod;
TString80 _reg_descr;
TDate _data_da, _data_a, _last_data;
real _tot_dare, _tot_avere; // valori di partenza
real _tot_dare_progr, _tot_avere_progr; // progressivi anno in corso
real _tot_dare_progr_ap, _tot_avere_progr_ap; // progr. anno prec.
real _tot_dare_gg , _tot_avere_gg ; // giornalieri
real _tot_dare_gg_ap , _tot_avere_gg_ap ; // giornalieri anno precedente
real _tot_dare_generale, _tot_avere_generale; // tot. generali
long _nprog_da, _nprog_mov;
int _stampa_width, _stampa_len;
int _pagine_stampate, _pagine_numerate, _stampa_ok, _pagina_da;
TDate _data_corr, _data_succ, _ultima_data_mov;
int _mese_corr, _mese_succ;
int _last_header; // prima riga di intestazione "libera"
bool _stampa_stesso_registro;
bool _libro_giornale_iva_unico, _libro_cronologico, _stampa_intesta;
// bool _gia_settata_riga_mov; // per la stampa no iva
TString80 _ragsoc, _paiva, _comunefis, _viafis;
TString16 _provfis, _cap, _occfpi;
TString80 _cofi;
TLocalisamfile * _com, *_clifo,*_pconti,*_nditte,*_anag;
TLocalisamfile* _attiv; // da togliere in futuro (?)
TTable *_tabreg, *_tabval, *_tabes, *_tabiva;
TDecoder* _causali; // Guy: saggia aggiunta
public:
virtual void preprocess_header();
virtual void preprocess_footer();
virtual bool preprocess_page(int, int);
virtual print_action postprocess_page(int, int);
virtual print_action postprocess_print(int, int);
virtual bool preprocess_print(int, int);
virtual void postclose_print();
// virtual bool cancel_hook();
virtual bool set_print(int);
virtual bool user_create();
virtual bool user_destroy();
void set_rows (int file, int counter);
int setta_righe_indirizzo(char tipocf, long codcf, int rdesc);
int setta_righe_iva();
int setta_righe_valuta(int start_riga);
int setta_righe_descr(TParagraph_string&, enum descr);
void fill_page(int start_riga, int righe_iva);
void calcola_iva();
void init_print();
bool init_cursor();
void init_totals();
int stampa_intestazione_ditta();
int set_headers();
bool leggi_tabreg(const char * codreg, int annoes);
bool controlla_mov_aep();
bool competenza_ep() const { return _ae != _annoEsMov; }
bool competenza_ec() const { return !competenza_ep(); } // tertium non datur ?
void aggiorna_tabreg(int, int);
void aggiorna_mov();
int set_totali_giorno(const TDate& giorno, const int righeivasettate);
int set_totali_pagina(int r);
void get_dati_ditta ();
const char* get_descr_caus (const char * codcaus);
TRectype& look_com (const char * cod);
const char* get_codiva_des(const char* codiva);
void get_date_aep(int aep, TDate* in, TDate* fin);
void update_totals (char sezione, real& importo);
void set_reg_filter(TMask& m);
TStampa_giornale() : _pagine_contate(0) {};
virtual ~TStampa_giornale() {};
};
HIDDEN TStampa_giornale& app() { return (TStampa_giornale&)main_app(); }
bool TStampa_giornale::filtra_reg(const TRelation * r)
{
bool ok = TRUE;
if (app()._ae)
{
const TRectype& rec = r->lfile().curr();
const int anno = atoi(rec.get("CODTAB").left(4));
ok = anno == app()._ae;
}
return ok;
}
bool TStampa_giornale::filter_func(const TRelation * r)
{
const TRectype& recmov = r->lfile().curr();
// Scarto SEMPRE i provvisori
const TString& provvis = recmov.get(MOV_PROVVIS);
if (!provvis.blank())
return FALSE;
// In caso di NO libro con iva scarta quelli che non hanno righe contabili
if (!app()._libro_giornale_iva_unico)
{
const long numreg = recmov.get_long("NUMREG");
TRectype& recrmov = r->lfile(LF_RMOV).curr();
recrmov.zero();
recrmov.put("NUMREG", numreg);
recrmov.put("NUMRIG", 1);
// Guy: non capisco bene come possano esistere movimenti senza la prima riga!
if (r->lfile(LF_RMOV).read() != NOERR)
{
const long numreg2 = recrmov.get_long("NUMREG");
return numreg2 == numreg;
}
}
return TRUE;
}
//////////////////////////////////////////////////////////////////////////
// Funzioni legate ai parametri ditta
//////////////////////////////////////////////////////////////////////////
HIDDEN bool libro_giornale_iva_unico()
{
TConfig conf(CONFIG_DITTA);
return conf.get_bool("StLgiU");
}
HIDDEN bool libro_cronologico()
{
TConfig conf(CONFIG_DITTA);
return conf.get_bool("GsLbCn");
}
TRectype& TStampa_giornale::look_com (const char * cod)
{
_com->zero();
_com->put(COM_COM, cod);
if (_com->read() != NOERR)
_com->zero();
return _com->curr();
}
const char* TStampa_giornale::get_descr_caus (const char * codcaus)
{
return _causali->decode(codcaus);
}
void TStampa_giornale::get_dati_ditta ()
{
TString16 codanagr;
char tipoa;
_nditte->zero();
_nditte->put(NDT_CODDITTA, get_firm());
_nditte->read();
if (_nditte->bad()) _nditte->zero();
_ragsoc = _nditte->get(NDT_RAGSOC);
codanagr = _nditte->curr().get(NDT_CODANAGR);
tipoa = _nditte->curr().get_char(NDT_TIPOA);
_anag->setkey(1);
_anag->zero();
_anag->put (ANA_TIPOA, tipoa);
_anag->put (ANA_CODANAGR, codanagr);
_anag->read();
if (_anag->bad()) _anag->zero();
_cofi = _anag->get(ANA_COFI);
_paiva = _anag->get(ANA_PAIV);
_comunefis = _anag->get(ANA_COMRF);
if (_comunefis.empty())
_comunefis = _anag->get(ANF_COMRES);
TRectype dep = look_com (_comunefis);
_comunefis = dep.get(COM_DENCOM);
_provfis = dep.get(COM_PROVCOM);
_cap = dep.get(COM_CAPCOM);
if (_comunefis.empty())
{
_viafis = _anag->get(ANA_INDRF);
_viafis.rtrim();
_viafis << " " << _anag->curr().get (ANA_CIVRF);
}
else
{
_viafis = _anag->get(ANA_INDRES);
_viafis.rtrim();
_viafis << " " << _anag->get (ANA_CIVRES);
}
}
bool TStampa_giornale::user_create()
{
_ae = 0;
_ae_solare = 0;
_tabreg = new TTable ("REG");
_tabval = new TTable ("%VAL");
_tabes = new TTable ("ESC");
_tabiva = new TTable ("%IVA");
_nditte = new TLocalisamfile(LF_NDITTE);
_anag = new TLocalisamfile (LF_ANAG);
_com = new TLocalisamfile(LF_COMUNI);
_clifo = new TLocalisamfile(LF_CLIFO);
_pconti = new TLocalisamfile(LF_PCON);
_attiv = new TLocalisamfile(LF_ATTIV); // da togliere
_causali = new TDecoder(LF_CAUSALI, "DESCR");
_rel = new TRelation (LF_MOV);
_rel->add (LF_RMOV, "NUMREG=NUMREG");
_rel->add (LF_RMOVIVA, "NUMREG=NUMREG");
_cur = new TCursor (_rel, "", 2); // usa la chiave 2: DATAREG+NUMREG
_RecPartoDa = new TRectype(_cur->file(LF_MOV).curr());
_RecArrivoA = new TRectype(_cur->file(LF_MOV).curr());
add_cursor (_cur);
add_file (LF_MOV);
add_file (LF_RMOV);
add_file (LF_RMOVIVA);
return TRUE;
}
bool TStampa_giornale::user_destroy()
{
delete _rel;
delete _cur;
delete _RecPartoDa;
delete _RecArrivoA;
delete _com; delete _clifo; delete _pconti;
delete _nditte; delete _anag;
delete _tabreg; delete _tabes; delete _tabval; delete _tabiva;
delete _causali;
delete _attiv; // da togliere in futuro
delete _nditte;
delete _anag;
return TRUE;
}
void TStampa_giornale::aggiorna_mov()
{
TLocalisamfile& mov = _cur->file(LF_MOV);
long nprog = _nprog_da + 1;
const TRectype da(*_RecPartoDa);
const TRectype a(*_RecArrivoA);
_cur->setregion(da, a);
const long items = _cur->items();
TProgind prnd (items, "Aggiornamento movimenti ...", FALSE, TRUE);
for ((*_cur) = 0L; _cur->pos() < items; ++(*_cur))
{
const bool gia_stampato = _cur->file(LF_MOV).get_bool(MOV_STAMPATO);
if (!gia_stampato)
{
_cur->file(LF_MOV).put (MOV_STAMPATO, TRUE);
_cur->file(LF_MOV).put (MOV_NUMGIO, nprog);
mov.rewrite();
nprog++;
}
prnd.addstatus(1);
}
}
int TStampa_giornale::set_totali_giorno(const TDate& data, const int righeiva)
{
int r = righeiva + 1;
char dep[200];
const int SHIFT = 15;
const int STACC = 51 + SHIFT;
// r = righeiva == 0 ? 1 : righeiva + 1;
// Se e' l'unico totale lo stampo anche se e' zero
if (competenza_ec() || (_tot_avere_gg != ZERO || _tot_dare_gg != ZERO))
{
TString td(_tot_dare_gg.string (REAL_PICTURE));
TString ta(_tot_avere_gg.string(REAL_PICTURE));
sprintf(dep, "@b@%dgTotale operazioni del %s @%dg%c %s @%dg%c @%dg%s",
_stampa_width == 132 ? SCRITTA : DARE198-STACC,
data.string(),
_stampa_width == 132 ? TOTDARE132 : DARE198-2,
'D',
(const char*)td,
_stampa_width == 132 ? SEZA132 : AVERE198-2,
'A',
_stampa_width == 132 ? TOTAVERE132 : AVERE198,
(const char*)ta
);
set_row (r++, "%s", dep);
_tot_dare_gg = _tot_avere_gg = ZERO;
}
if (competenza_ep() || (_tot_avere_gg_ap != ZERO || _tot_dare_gg_ap != ZERO))
{
TString tdp(_tot_dare_gg_ap.string(REAL_PICTURE));
TString tap(_tot_avere_gg_ap.string(REAL_PICTURE));
sprintf (dep, "@b@%dgTotale operazioni del %s Anno precedente @%dg%c %s @%dg%c @%dg%s",
_stampa_width == 132 ? SCRITTA : DARE198-STACC,
data.string(),
_stampa_width == 132 ? TOTDARE132 : DARE198-2,
'D',
(const char*)tdp,
_stampa_width == 132 ? SEZA132 : AVERE198-2,
'A',
_stampa_width == 132 ? TOTAVERE132 : AVERE198,
(const char*)tap
);
set_row (r++, "%s", dep);
_tot_avere_gg_ap = _tot_dare_gg_ap = ZERO;
}
return r;
}
void TStampa_giornale::postclose_print()
{
if (_stampa_definitiva)
{
if (yesno_box("La stampa e' corretta ?"))
{
const int ultima_fatta = _pagine_contate;
aggiorna_mov();
aggiorna_tabreg (_pagina_da, ultima_fatta);
}
}
}
void TStampa_giornale::preprocess_footer()
{
TString progr_dare_ap(22), progr_avere_ap(22);
TString progr_dare(25), progr_avere(25), dts(25), ats(25);
TString256 riga;
bool ap = FALSE;
int r=1; // was 2
const int STUMB = 42;
real dt, at;
reset_footer();
if (_tot_avere_progr_ap != ZERO || _tot_dare_progr_ap != ZERO)
{
progr_dare_ap = _tot_dare_progr_ap.string(REAL_PICTURE);
progr_avere_ap = _tot_avere_progr_ap.string(REAL_PICTURE);
ap = TRUE;
}
//
// Non stampo "A riportare"
// SE :
// 1. E' gia' stato stampato
// OPPURE
// 2. Sono sull'ultima riga
//
/*
const bool riporta = _forza_ariportare ||
(!_gia_settato_ariportare && _cur->pos() < _cur->items()-1 );
*/
const bool riporta = _devo_riportare;
if (riporta)
{
dt = _tot_dare_progr + _tot_dare_progr_ap;
at = _tot_avere_progr + _tot_avere_progr_ap;
dts = dt.string(REAL_PICTURE);
ats = at.string(REAL_PICTURE);
riga.format ("@b@%dg%s@%dg%c %s @%dg%c @%dg%s",
_stampa_width == 132 ? SCRITTA : DARE198-STUMB,
// (_nuovo_mese && !_forza_ariportare) ? "Totale progressivi generali " : "A riportare ",
"A riportare ",
_stampa_width == 132 ? TOTDARE132 : DARE198,
'D',
(const char *) dts,
_stampa_width == 132 ? SEZA132 : AVERE198-2,
'A',
_stampa_width == 132 ? TOTAVERE132 : AVERE198,
(const char *) ats);
set_footer (r++, (const char*) riga);
_forza_ariportare = FALSE;
if (_devo_riportare > TRUE)
_devo_riportare = FALSE;
}
}
int TStampa_giornale::set_totali_pagina(int righe)
{
TString progr_dare_ap(22), progr_avere_ap(22);
TString progr_dare(22), progr_avere(22), dts(22), ats(22);
TString256 riga;
bool ap = FALSE;
const int SHIFT = 15;
const int STUMB = 51 + SHIFT;
real dt, at;
int r = righe == 0 ? 1 : righe;
if (_tot_avere_progr_ap != ZERO || _tot_dare_progr_ap != ZERO)
{
progr_dare_ap = _tot_dare_progr_ap.string(REAL_PICTURE);
progr_avere_ap = _tot_avere_progr_ap.string(REAL_PICTURE);
ap = TRUE;
}
if (_cur->pos() == _cur->items()-1) // se sono sull'ultimo
{
// I totali distinti tra anno precedente e corrente SOLO SE STAMPA DI PROVA
if (!_stampa_definitiva)
{
progr_dare = _tot_dare_progr.string (REAL_PICTURE);
progr_avere = _tot_avere_progr.string(REAL_PICTURE);
riga = "";
riga.format("@b@%dgTotale progressivi @%dg%c %s @%dg%c @%dg%s",
_stampa_width == 132 ? SCRITTA : DARE198-STUMB,
_stampa_width == 132 ? TOTDARE132 : DARE198-2,
'D',
(const char *) progr_dare,
_stampa_width == 132 ? SEZA132 : AVERE198-2,
'A',
_stampa_width == 132 ? TOTAVERE132 : AVERE198,
(const char *) progr_avere
);
set_row (r++, (const char*) riga);
if (ap)
{
riga.format("@b@%dgTotale progressivi anno precedente @%dg%c %s @%dg%c @%dg%s",
_stampa_width == 132 ? SCRITTA : DARE198-STUMB,
_stampa_width == 132 ? TOTDARE132 : DARE198-2,
'D',
(const char *) progr_dare_ap,
_stampa_width == 132 ? SEZA132 : AVERE198-2,
'A',
_stampa_width == 132 ? TOTAVERE132 : AVERE198,
(const char *) progr_avere_ap
);
set_row (r++, (const char*) riga);
}
} // stampa_definitiva
_tot_dare_generale = _tot_dare_progr + _tot_dare_progr_ap;
_tot_avere_generale = _tot_avere_progr + _tot_avere_progr_ap;
dts = _tot_dare_generale.string (REAL_PICTURE);
ats = _tot_avere_generale.string(REAL_PICTURE);
riga.format("@b@%dgTotale progressivi generali @%dg%c %s @%dg%c @%dg%s",
_stampa_width == 132 ? SCRITTA : DARE198-STUMB,
_stampa_width == 132 ? TOTDARE132 : DARE198-2,
'D',
(const char *) dts,
_stampa_width == 132 ? SEZA132 : AVERE198-2,
'A',
_stampa_width == 132 ? TOTAVERE132 : AVERE198,
(const char *) ats
);
set_row (r++, (const char*) riga);
}
else // Non ancora totale generale
{
// Determina se le righe settate finora stanno in questa pagina oppure no
_gia_settato_ariportare = righe_rimaste() > righe;
// La fill_page mette forza_ariportare a TRUE
// nel caso di pagine con solo i totali (v. fax VLADIMIRO) bisogna impedire
// che venga stampato di nuovo "Totale ..." nella preprocess_footer
_forza_ariportare = FALSE;
dt = _tot_dare_progr + _tot_dare_progr_ap;
at = _tot_avere_progr + _tot_avere_progr_ap;
dts = dt.string(REAL_PICTURE);
ats = at.string(REAL_PICTURE);
// "Se il mese e' finito devo scrivere Totale progressivi generali
// invece che A riportare"
riga.format ("@b@%dgTotale progressivi generali @%dg%c %s @%dg%c @%dg%s",
_stampa_width == 132 ? SCRITTA : DARE198-STUMB,
_stampa_width == 132 ? TOTDARE132 : DARE198-2,
'D',
(const char *) dts,
_stampa_width == 132 ? SEZA132 : AVERE198-2,
'A',
_stampa_width == 132 ? TOTAVERE132 : AVERE198,
(const char *) ats);
set_row (r++, (const char*) riga);
}
return r;
}
int TStampa_giornale::stampa_intestazione_ditta()
{
int r=1;
TString256 intes;
TString riga(_stampa_width);
get_dati_ditta();
riga.fill('-');
set_header(r, riga);
set_header (++r, "Ditta: %5ld %-.50s %.35s %.5s %.20s %.2s",
get_firm(),
(const char *)_ragsoc,
(const char *)_viafis, (const char *)_cap,
(const char *)_comunefis, (const char *)_provfis);
if (_stampa_definitiva)
intes.format ("Partita iva %s @24gCodice fiscale %s",
(const char*)_paiva, (const char*)_cofi,
_stampa_width == 132 ? 102 : 168
);
else
intes.format ("Partita iva %s @24gCodice fiscale %s @%dg%s @%dgData @>",
(const char*)_paiva, (const char*)_cofi,
_stampa_width == 132 ? 102 : 168,
"LIBRO DI PROVA",
_stampa_width == 132 ? 117 : 183
);
set_header (++r, "%s", (const char*)intes);
r++;
return r;
}
int TStampa_giornale::set_headers()
{
int r=1;
TString riga(_stampa_width);
TString16 data_da = _data_da.string();
TString16 data_a = _data_a.string();
if (_stampa_intesta || !_stampa_definitiva)
r = stampa_intestazione_ditta();
else
{
set_header(r++, "");
set_header(r++, "");
}
if (_stampa_definitiva)
set_header(r++, "Codice libro: %s %s ",(const char *) _reg_cod, (const char *) _reg_descr);
else
set_header(r++, "Codice libro: %s %s @%dgdalla data: %s alla data: %s @%dgEsercizio: %04d",
(const char *) _reg_cod, (const char *) _reg_descr,
_stampa_width == 132 ? 69 : 135,
(const char *) data_da, (const char *) data_a,
_stampa_width == 132 ? 117 : 183,
_ae
);
riga.fill('-');
set_header(r++, riga);
if (_libro_cronologico)
set_header(r, "@59gCodice Conto");
if (!_stampa_definitiva) {
if (_stampa_width == 132) {
set_header(r++, "@131gS");
set_header(r, "@1gN.riga");
}
else {
set_header(r++, "@197gS");
set_header(r, "@1gN.riga");
}
}
else
if (_libro_cronologico) r++; // NON LASCIARE RIGHE IN BIANCO!!
// set_header(r, "@6gCod.Causale@34gDescrizione operazione");
set_header(r, "@8gDescrizione operazione@36gCausale");
if (_libro_cronologico)
// POSCONTO = 74;
set_header(r, "@74gGeneralita' cliente/fornitore");
else
set_header(r, "@59gCodice Conto");
if (_stampa_width == 132)
set_header(r, "@120gImporto");
else
set_header(r, "@161gDare @184gAvere");
if (!_stampa_definitiva)
set_header(r, _stampa_width == 132 ? "@131gB" : "@197gB");
r++;
riga.fill('-');
set_header(r, riga);
return r;
}
void TStampa_giornale::preprocess_header()
{
int r = _last_header + 1;
int pag = printer().getcurrentpage();
TString256 riporto;
real riporto_dare, riporto_avere;
// _gia_settato_ariportare = FALSE;
if (pag > 0) // Stampa riporti
{
riporto_dare = _tot_dare_progr + _tot_dare_progr_ap;
riporto_avere = _tot_avere_progr + _tot_avere_progr_ap;
// Non stampa nulla se ZERO SOLO SE DI PROVA <<<<<---------------------
// Lascio una riga senno' vado a finire sull'intestazione
if (!_stampa_definitiva)
if (riporto_dare == ZERO && riporto_avere == ZERO)
{
set_header (r, "");
return;
}
TString dare (riporto_dare.string (REAL_PICTURE));
TString avere(riporto_avere.string(REAL_PICTURE));
riporto.format("@b@%dgRiporto: @%dg%c %17s @%dg%c@%dg%17s", // prima erano %15s
_stampa_width == 132 ? SCRITTA : DARE198-11,
_stampa_width == 132 ? TOTDARE132 : DARE198,
_stampa_width == 132 ? 'D' : ' ',
(const char *) dare,
_stampa_width == 132 ? SEZA132 : SEZA132,
_stampa_width == 132 ? 'A' : ' ',
_stampa_width == 132 ? TOTAVERE132 : AVERE198,
(const char *) avere
);
set_header (r++, "%s", (const char *) riporto);
}
}
//
// PREPROCESS_PRINT
//
// Se non ci sono items nel cursore (= se non ci sono movimenti)
// la stampa e' abortita.
//
// stampa_ok = -1 -> la stampa precedente era OK
// stampa_ok = x -> la stampa precedente non e' andata a buon fine
// ed era partita dalla pagina x.
//
// Se la stampa precedente e' andata male, setto la pagina corrente a
// quella salvata in stampa_ok, e la pagina da cui parte la stampa vera e
// propria a quella che mi dice l'utente:
//
// set_page_number (stampa_ok)
// setfrompage (pagina_da)
//
bool TStampa_giornale::preprocess_print(int file, int counter)
{
switch (file)
{
case LF_MOV:
_nuovo_mese = FALSE;
_iva_array.destroy();
_nprog_mov = _nprog_da;
*_RecPartoDa = _cur->file(LF_MOV).curr();
break;
default:
break;
}
return TRUE;
}
/***
bool TStampa_giornale::cancel_hook()
{
int ultima_fatta = printer().getcurrentpage() - 1;
// int stampate = ultima_fatta - _pagina_da + 1;
if (yesno_box ("Interrompo la stampa ?"))
{
if (_stampa_definitiva)
aggiorna_tabreg (ultima_fatta, ultima_fatta);
return TRUE;
}
else
return FALSE;
}
***/
int TStampa_giornale::righe_rimaste() const
{
const TPrinter& p = printer();
int rows_left = p.rows_left();
if (rows_left <= 0)
rows_left = p.formlen() - (p.headersize()+1) - p.footersize();
return rows_left;
}
void TStampa_giornale::fill_page(int righe_da_stampare, int righe_iva_settate)
{
const TPrinter& p = printer();
TString256 rigas;
// int rrr = start_riga + righe_iva_settate + 1;
int r = righe_da_stampare + 1;
// int rows_left = p.rows_left();
/* if (rows_left <= 0)
{
rows_left = p.formlen() - (p.headersize()+1) - p.footersize();
_forza_ariportare = TRUE;
}
*/
// int r_l = p.rows_left() - start_riga - righe_iva_settate;
int r_l = p.rows_left() - righe_da_stampare;
if (r_l < 0)
r_l += p.formlen() - (p.headersize()/*+1*/) - p.footersize();
// Se sono rimaste righe da riempire
if (r_l > 0)
{
rigas.fill('=', _stampa_width);
// rigas.cut(_stampa_width+1);
// set_row(rrr++, "%s", (const char*) rigas);
set_row(r++, "%s", (const char*) rigas);
int j=0;
// Calcola una specie di coefficiente angolare
int alfa = (_stampa_width - 6) / r_l;
r_l--;
for ( ; r_l > 0; r_l--) // Non stampare sulla riga orizzontale!
{
rigas.format("@%dg======", j);
set_row(r++, rigas);
j += alfa;
}
}
}
print_action TStampa_giornale::postprocess_print(int file, int counter)
{
if (file == LF_MOV)
_pagine_contate = printer().getcurrentpage() - 1;
return NEXT_PAGE;
}
print_action TStampa_giornale::postprocess_page(int file, int counter)
{
int righe_iva_settate=0;
bool FINITO = FALSE;
if (counter)
{
if (_nuovo_mese)
{
printer().formfeed();
_nuovo_mese = FALSE;
}
return NEXT_PAGE;
}
switch (file)
{
case LF_MOV:
{
reset_print();
righe_iva_settate = 0;
if (_libro_giornale_iva_unico)
{
righe_iva_settate = setta_righe_iva();
righe_iva_settate = setta_righe_valuta(righe_iva_settate);
}
_cur->save_status();
++(*_cur);
_data_succ = _cur->file(LF_MOV).get_date(MOV_DATAREG);
_mese_succ = _data_succ.month();
--(*_cur);
_cur->restore_status();
_devo_riportare = TRUE;
const bool last_row = _cur->pos() == _cur->items()-1;
if (_data_corr != _data_succ || last_row)
{
_nuovo_mese = (_mese_succ != _mese_corr);
int righe = set_totali_giorno(_data_corr, righe_iva_settate);
if (_nuovo_mese || last_row)
{
righe = set_totali_pagina(righe);
if (righe - 1 > (int)printer().rows_left())
_devo_riportare = 3; // Very TRUE!
else
_devo_riportare = FALSE;
// Nella stampa su bollato metto un segno su tutte le righe
if (_stampa_definitiva)
fill_page(righe - 1, righe_iva_settate);
}
return REPEAT_PAGE;
}
if (righe_iva_settate > 0)
return REPEAT_PAGE;
}
break;
case LF_RMOV:
// Sposto qui per evitare di aggiornare i progressivi con una riga della
// pagina dopo
if (!_totals_updated)
update_totals(_sezione, _importo);
_gia_settato_ariportare = FALSE;
break;
default:
break;
}
return NEXT_PAGE;
}
void TStampa_giornale::update_totals (char sezione, real& importo)
{
#ifdef DBG
TString dgap(_tot_dare_gg_ap.string());
TString dgpp(_tot_dare_progr_ap.string());
TString dgac(_tot_dare_gg.string());
TString dgpc(_tot_dare_progr.string());
TString agap(_tot_avere_gg_ap.string());
TString agpp(_tot_avere_progr_ap.string());
TString agac(_tot_avere_gg.string());
TString agpc(_tot_avere_progr.string());
#endif
if (sezione == 'D')
{
if (_annoEsMov != _ae) {
_tot_dare_gg_ap += importo; // prog. anno precedente
_tot_dare_progr_ap += importo;
}
else {
_tot_dare_gg += importo; // prog. giornalieri
_tot_dare_progr += importo; // prog. generali
}
}
else
{
if (_annoEsMov != _ae) {
_tot_avere_gg_ap += importo;
_tot_avere_progr_ap += importo;
}
else {
_tot_avere_gg += importo;
_tot_avere_progr += importo;
}
}
#ifdef DBG
dgap = _tot_dare_gg_ap.string();
dgpp = _tot_dare_progr_ap.string();
dgac = _tot_dare_gg.string();
dgpc = _tot_dare_progr.string();
agap = _tot_avere_gg_ap.string();
agpp = _tot_avere_progr_ap.string();
agac = _tot_avere_gg.string();
agpc = _tot_avere_progr.string();
#endif
}
void TStampa_giornale::set_rows (int file, int counter)
{
TString16 datadoc_str, datareg_str, numdoc, frm, caus;
TDate datadoc, datareg;
TString80 mov_descr, rmv_descr;
TParagraph_string descr_conto("", 50);
TContoOccas tc;
long numreg, protiva;
int r = 1;
int g, c;
long s;
static char cf = ' ';
static int rdes = 1;
switch (file)
{
case LF_MOV:
reset_row(1);
reset_row(2);
datareg = _cur->file(LF_MOV).get_date("DATAREG");
datadoc = _cur->file(LF_MOV).get_date("DATADOC");
datareg_str = datareg.string();
// "Fai vedere lo stesso ..-..-.... anche se non c'e' la data..."
if (datareg_str.empty())
datareg_str = " - - ";
datadoc_str = datadoc.string();
if (datadoc_str.empty())
datadoc_str = " - - ";
numdoc = _cur->file(LF_MOV).get("NUMDOC");
numreg = _cur->file(LF_MOV).get_long("NUMREG");
mov_descr = _cur->file(LF_MOV).get("DESCR");
// Usati in setta_righe_iva per determinare tipo attivita'
_reg = _cur->file(LF_MOV).get(MOV_REG);
_anno_iva = _cur->file(LF_MOV).get_int(MOV_ANNOIVA);
protiva = _cur->file(LF_MOV).get_long(MOV_PROTIVA);
caus = _cur->file(LF_MOV).get(MOV_CODCAUS);
_occfpi = _cur->file(LF_MOV).get(MOV_OCFPI);
_annoEsMov = _cur->file(LF_MOV).get_int(MOV_ANNOES);
_MovGiaStampato = _cur->file(LF_MOV).get_bool(MOV_STAMPATO);
if (_stampa_definitiva)
{
set_row(r,"Operazione n. @b%-7ld@r", _nprog_mov);
set_row(r," del @b%s@r", (const char*)datareg_str); // XX/XX/XXXX
set_row(r," doc. n. @b%-7s@r",(const char*)numdoc);
set_row(r," del @b%s@r %-50s",(const char*)datadoc_str,
(const char*)mov_descr);
}
else
{
set_row(r,"Operazione n. @b%-7ld@r", numreg);
set_row(r," del @b%s@r", (const char*) datareg_str);
set_row(r," doc. n. @b%-7s@r", (const char*) numdoc);
set_row(r," del @b%s@r %-50s", (const char*)datadoc_str,(const char*)mov_descr);
}
if (_annoEsMov != _ae)
set_row(r," Comp. %04d", _annoEsMov);
if (_MovGiaStampato && !_stampa_definitiva)
set_row(r,format("@%dg*",_stampa_width == 132 ? 131 : 197));
if (caus.not_empty())
{
const char* desc_caus = get_descr_caus(caus);
set_row(r+1, "@36gCausale %3s %-50s", (const char*) caus, desc_caus);
if (_reg.not_empty())
set_row(r+1, " (R.IVA @b%3s@r Prot. @b%ld@r) ", (const char*)_reg,protiva);
}
break;
case LF_RMOV:
_num_rig++;
reset_print();
g = _cur->file(LF_RMOV).get_int("GRUPPO");
c = _cur->file(LF_RMOV).get_int("CONTO");
s = _cur->file(LF_RMOV).get_long("SOTTOCONTO");
cf = _cur->file(LF_RMOV).get_char(RMV_TIPOC);
if (cf != 'C' && cf != 'F')
cf = ' ';
numreg = _cur->file(LF_RMOV).get_long("NUMREG");
datareg = _cur->file(LF_RMOV).get("DATAREG");
_sezione = _cur->file(LF_RMOV).get_char (RMV_SEZIONE);
_importo = _cur->file(LF_RMOV).get_real (RMV_IMPORTO);
rmv_descr = _cur->file(LF_RMOV).get(RMV_DESCR);
r=1;
// Num. progressivo di operazione. Azzerato in preprocess_page
if (!_stampa_definitiva) set_row (r, "%7ld", _num_rig);
set_row (r, "@8g%-50s", (const char*) rmv_descr);
set_row (r, "@59g%03d.", g);
if (c != 0)
set_row (r, "%03d.", c);
if (s != 0L)
set_row (r, "%06ld", s);
tc.set(g,c,s,cf,NULL,-1,_occfpi);
if (_stampa_width == 132)
descr_conto.set_width (WCONTO132);
else // se a 198 non spezzo le descrizioni
descr_conto.set_width(198);
descr_conto = tc.descrizione();
if (_stampa_width == 132)
rdes = setta_righe_descr (descr_conto, conto);
else
{
rdes = 2;
frm.format("@%dg%%-%ds", POSCONTO,50);
set_row (r, frm, (const char*) descr_conto);
}
if (cf > ' ')
if (_libro_cronologico)
rdes = setta_righe_indirizzo(cf, s, rdes);
// NB Totali aggiornati in postprocess_page (update_totals())
if (_stampa_width == 132)
{
set_row (r, "@110g%r %c", &_importo, _sezione);
}
else // stampa_width == 198
set_row (r, _sezione == 'D' ? "@152g%r" : "@174g%r", &_importo);
if (_MovGiaStampato && !_stampa_definitiva)
set_row(r,format("@%dg*",_stampa_width == 132 ? 131 : 197));
{
const int rows = rdes - 1;
const int left = printer().rows_left();
if (left > 0 && left < rows)
{
_totals_updated = TRUE;
update_totals(_sezione, _importo);
}
else
_totals_updated = FALSE;
}
break;
default:
break;
}
}
//
// PREPROCESS_PAGE
//
// Non scarto nulla qui, non si deve mai vedere una stampa vuota
//
bool TStampa_giornale::preprocess_page(int file, int counter)
{
if (counter) return TRUE;
switch (file) {
case LF_MOV:
_annoEsMov = _anno_iva = 0;
_iva_array.destroy();
*_RecArrivoA = _cur->file(LF_MOV).curr();
_nprog_mov++;
// Il numero di operazione deve ripartire da 0 per ogni movimento
_num_rig = 0;
_data_corr = _cur->file(LF_MOV).get_date(MOV_DATAREG);
// _ultima_data_mov finisce sul registro come ultima data di stampa
if (_data_corr > _ultima_data_mov)
_ultima_data_mov = _data_corr;
_mese_corr = _data_corr.month();
_devo_riportare = TRUE;
break;
case LF_RMOV:
break;
case LF_RMOVIVA:
if (_libro_giornale_iva_unico) calcola_iva ();
break;
default:
break;
}
set_rows (file, counter);
return TRUE;
}
void TStampa_giornale::calcola_iva()
{
TString codiva;
int tipocr, tipodet, tipoatt;
real impo, impos;
bool intra;
TRectype iva (_cur->file(LF_RMOVIVA).curr());
if (!iva.empty())
{
impo = iva.get_real (RMI_IMPONIBILE);
impos = iva.get_real (RMI_IMPOSTA);
tipocr = iva.get_int (RMI_TIPOCR);
tipodet = iva.get_int (RMI_TIPODET);
tipoatt = iva.get_int ("TIPOATT");
codiva = iva.get (RMI_CODIVA);
intra = iva.get_bool (RMI_INTRA);
_iva_array.add_riga(impo,impos,ZERO,ZERO,codiva,tipodet,0,intra,tipoatt);
}
}
int TStampa_giornale::setta_righe_descr(TParagraph_string& str, enum descr des)
{
int i = 1;
TString16 frm;
const char* r;
// char descr[51];
TString80 descr;
switch (des)
{
case causale: // lunga 20
if (_libro_giornale_iva_unico)
frm.format("@10g\0x25%ds", _stampa_width == 132 ? WCAUS132 : 40);
else
frm.format("@48g%%d", WCAUS132);
break;
case conto: // lunga 21
// if (_libro_giornale_iva_unico)
frm.format("@%dg%%-%ds", POSCONTO,WCONTO132);
/*
else
frm.format("@26g%%d", POSCONTO,WCONTO132); */
break;
case operazione: // lunga 28
if (_libro_giornale_iva_unico)
frm.format("@31g%%d", WOPER132);
else
frm.format("@69g%%d", WOPER132);
break;
default:
break;
}
while ((r = str.get()) != NULL)
{
descr = r;
descr.ltrim();
set_row (i++, (const char*)frm, (const char*)descr);
}
return i;
}
const char* TStampa_giornale::get_codiva_des(const char* codiva)
{
_tabiva->zero();
_tabiva->put("CODTAB", codiva);
if (_tabiva->read() == NOERR)
return _tabiva->get("S0");
else
return NULL;
}
// NB
// Questa funzione ritorna il numero di righe che ha settato.
// Se questo e' diverso da 0 viene fatta una REPEAT_PAGE
// Attenzione quindi se si modifica la variabile r
int TStampa_giornale::setta_righe_iva()
{
int r=0, j;
TString80 rig;
for (j = 0; j < _iva_array.items(); j++)
{
TRigaiva& riga = (TRigaiva&)_iva_array[j];
r = j+1;
TString impon_str(riga._imponibile.string(REAL_PICTURE));
TString impos_str(riga._imposta.string(REAL_PICTURE));
// set_row(r, " Imponibile@15g%15r", &riga._imponibile);
// set_row(r, "@31gImposta@39g%15r", &riga._imposta);
set_row(r, " Imponibile@15g%15s", (const char*)impon_str);
set_row(r, "@31gImposta@39g%15s", (const char*)impos_str);
// set_row(r, "@58gCod.Iva@68g%3s", (const char*)riga._codiva);
set_row(r, "@56gCod.Iva %3s", (const char*)riga._codiva);
const TString80 codiva_des(get_codiva_des(riga._codiva));
const int tipoatt = riga._tipoatt;
if (_stampa_width == 132)
set_row(r, "@68g%-.17s", (const char*)codiva_des);
else
set_row(r, "@68g%-.50s", (const char*)codiva_des);
const int S132 = 89;
const int S198 = 119;
rig.format("@%dg", _stampa_width == 132 ? S132 : S198);
switch (riga._tipodet)
{
case 0 :
rig << "Detraibile ";
break;
case 1 :
rig << "Indetraibile su op.es. ";
break;
case 3 :
rig << "Passaggi interni ";
break;
case 9 :
rig << "Indetraibile art.19 ";
break;
default: break;
}
set_row(r, (const char*)rig);
TRegistro reg(_reg, _anno_iva);
const bool att_mista_ev = reg.attivita_mista();
if (tipoatt != 0 && att_mista_ev)
set_row(r, " Tipo attivita' %d", tipoatt);
}
_iva_array.destroy();
return r;
}
int TStampa_giornale::setta_righe_valuta(int riga)
{
TString16 codvali;
real corrval;
int r = riga;
corrval = current_cursor()->file(LF_MOV).get_real(MOV_CORRVALUTA);
if (corrval != ZERO)
{
codvali = current_cursor()->file(LF_MOV).get(MOV_CODVALI);
TString valut(corrval.string("###.###.###.###,@@@"));
r = riga+1;
set_row(r,"@56gValuta %3s", (const char*)codvali);
if (_stampa_width == 132)
set_row(r,"@89gCorr.in valuta @109g%s", (const char*)valut);
else
set_row(r,"@119gCorr.in valuta @171g%s", (const char*)valut);
}
return r;
}
// Cerca l'indirizzo del C/F.
// Legge CLIFO o OCCAS a seconda di _occas
// Setta le righe 2 e 3 che vengono poi resettate al record successivo
int TStampa_giornale::setta_righe_indirizzo(char tipocf, long codcf,int rdes)
{
TString16 prov, comcf, capcf, civcf, statocf;
TString80 viacf, comune;
bool really_occas = FALSE;
char tipoa;
long codanagr;
char riga[256];
int r = rdes;
_clifo->zero();
_clifo->put(CLI_CODCF, codcf);
_clifo->put(CLI_TIPOCF, tipocf);
const bool clifo_ok = (_clifo->read() == NOERR);
if (clifo_ok) really_occas = _clifo->get_bool(CLI_OCCAS);
if (_occfpi.not_empty() && really_occas) // => e' un occasionale...
{
TLocalisamfile occ(LF_OCCAS);
occ.zero();
occ.put(OCC_CFPI, _occfpi);
if (occ.read() != NOERR) occ.zero();
viacf = occ.get (OCC_INDIR);
civcf = occ.get (OCC_CIV);
capcf = occ.get (OCC_CAP);
comcf = occ.get (OCC_COM);
}
else
{
// E' possibile cio' ?
if (!clifo_ok) return r;
viacf = _clifo->get(CLI_INDCF);
civcf = _clifo->get(CLI_CIVCF);
comcf = _clifo->get(CLI_COMCF);
capcf = _clifo->get(CLI_CAPCF);
statocf = _clifo->get(CLI_STATOCF);
tipoa = _clifo->get_char(CLI_TIPOAPER);
codanagr = _clifo->get_long(CLI_CODANAGPER);
}
TRectype rec = look_com (comcf);
comune = rec.get(COM_DENCOM);
prov = rec.get(COM_PROVCOM);
if (comcf.empty()) comune = _clifo->get(CLI_LOCCF);
if (viacf.not_empty())
{
sprintf (riga, "@%dg%s %s",
POSCONTO,
(const char*) viacf,
(const char*) civcf
);
set_row (r++, riga);
}
if (comune.not_empty() || prov.not_empty() || capcf.not_empty())
{
sprintf (riga, "@%dg%s %s %s",
POSCONTO,
(const char*) capcf, (const char*) comune,
(const char*) prov
);
set_row (r++, riga);
}
// Se fisica prendo anche data nascita e luogo
if (tipoa == 'F')
{
TString80 comna;
TString16 datana, codcomna, provna, capna, statona;
datana = _clifo->get("DATANASC");
if (datana.not_empty())
{
codcomna = _clifo->get("COMNASC");
TRectype dep = look_com (codcomna);
comna = dep.get(COM_DENCOM);
provna = dep.get(COM_PROVCOM);
capna = dep.get(COM_CAPCOM);
statona = dep.get("STATO");
sprintf (riga, "@%dg%s %s %s %s", POSCONTO,
(const char*)datana,
(const char*)comna,
(const char*)provna, (const char*) capna);
set_row(r++, riga);
}
}
return r;
}
//
// Lettura/aggiornamento tabella registri
//
void TStampa_giornale::aggiorna_tabreg(int partito_da, int stampate)
{
TString16 codtab;
codtab.format ("%04d%-3s", _ae_solare, (const char*) _reg_cod);
_tabreg->zero();
_tabreg->put("CODTAB", codtab);
_tabreg->read(_isequal, _lock);
if (_tabreg->good())
{
// _tabreg->put ("I8", (long)partito_da); // partito_da = -1 se stampa OK
_tabreg->put ("I1", (long)_pagine_stampate + stampate); // pagine stampate
_tabreg->put ("I6", _nprog_mov); // ultimo numero di riga
_tabreg->put ("R1", _tot_dare_generale);
_tabreg->put ("R2", _tot_avere_generale);
_tabreg->put ("D3", _ultima_data_mov); // Data piu' alta trovata
_tabreg->rewrite();
}
}
void TStampa_giornale::get_date_aep(int aep, TDate* in, TDate* fin)
{
*in = TDate(1,1,aep);
*fin = TDate(31,12,aep);
}
const int es_prec(const int es_corr)
{
return es_corr-1;
}
bool TStampa_giornale::controlla_mov_aep()
{
TWait_cursor hourglass;
const int aep = es_prec(_ae);
TDate inizio_ep, fine_ep;
if (aep == 0) // = e' il primo esercizio
return TRUE;
else
get_date_aep(aep,&inizio_ep, &fine_ep);
TRectype da (LF_MOV);
TRectype a (LF_MOV);
da.put(MOV_DATAREG, inizio_ep);
a.put (MOV_DATAREG, fine_ep);
_cur->setregion(da, a);
_cur->set_filterfunction(filter_func);
// _cur->setfilter(format("ANNOES=%04d && STAMPATO!=\"X\"", aep));
bool gia_stampati = TRUE;
for (*_cur = 0L ; _cur->ok(); ++(*_cur))
{
gia_stampati = _cur->file().get_bool("STAMPATO");
if (!gia_stampati) break; // basta trovarne uno ancora da stampare
}
if (_cur->items() > 0L && !gia_stampati)
{
_cur->setfilter("");
warning_box("Impossibile proseguire con la stampa:\n"
"Esistono movimenti nell'esercizio precedente\n"
"che non sono ancora stati stampati su bollato.");
return FALSE;
}
_cur->setfilter("");
return TRUE;
}
bool TStampa_giornale::leggi_tabreg(const char * reg_cod, int reg_anno)
{
TString16 codtab;
// _ae = reg_anno;
codtab.format ("%04d%-3s", reg_anno, reg_cod);
_tabreg->zero();
_tabreg->put("CODTAB", codtab);
const bool ok = (_tabreg->read() == NOERR);
if (!ok) _tabreg->zero();
_pagine_stampate = _tabreg->get_int("I1");
_pagine_numerate = _tabreg->get_int("I2");
// _stampa_ok = _tabreg->get_int("I8");
_nprog_da = _tabreg->get_long ("I6");
_tot_dare = _tabreg->get_real ("R1");
_tot_avere = _tabreg->get_real ("R2");
_last_data = _tabreg->get_date ("D3");
_stampa_intesta = _tabreg->get_bool ("B9");
_stampa_stesso_registro = _tabreg->get_bool ("B8");
_reg_descr = _tabreg->get ("S0");
_tipo = _tabreg->get_int("I0");
return ok;
}
void TStampa_giornale::set_reg_filter(TMask& m)
{
TEdit_field& reg = m.efield(CODREG);
reg.browse()->cursor()->set_filterfunction(filtra_reg);
}
//-----------------------------------------------------------------------
//
// MASCHERE
//
//-----------------------------------------------------------------------
// NB
// Qui viene compilato app()._ae
// L'anno di esercizio e' determinato da DATA_A
//
bool TStampa_giornale::data_a_hndl (TMask_field& f, KEY k)
{
TMask& m = f.mask();
if (f.to_check(k))
{
const TDate data_a(f.get());
if (!data_a.ok())
return TRUE;
app()._ae_solare = data_a.year();
app()._ae = app()._ae_solare;
m.set(ANNO_ESER, app()._ae_solare);
m.send_key(K_TAB, CODREG);
}
if (k == K_ENTER)
{
const bool definitiva = m.get_bool(STAMPA_DEF);
const TDate data_da(m.get(DATA_DA));
const TDate data_a(f.get());
TString16 dtda(data_da.string());
const int ae = app()._ae;
const TMask_field& fld_dtda = m.field(DATA_DA);
if (definitiva)
{
if (dtda.not_empty())
{
if (data_da.year() != data_a.year());
return f.warning_box("Le date specificate non appartengono allo stesso anno");
if (data_da > data_a)
return f.warning_box("La data di partenza non puo' essere maggiore della data finale");
}
}
} // if K_ENTER
return TRUE;
}
bool TStampa_giornale::data_da_hndl(TMask_field& f, KEY k)
{
TMask& m = f.mask();
// if (f.to_check(k))
if (k == K_TAB)
{
const TDate data_da (f.get());
const TDate data_a(m.get(DATA_A));
if (!data_da.ok() || !data_a.ok())
return TRUE;
if (data_da.year() != data_a.year())
return f.error_box("Le due date non appartengono allo stesso anno");
}
if (k == K_ENTER)
{
const bool definitiva = m.get_bool(STAMPA_DEF);
const TDate data_a(m.get(DATA_A));
const TDate data_da(f.get());
// Controlli sulle date
// se la stampa e' di prova DALLA_DATA e' obbligatoria
if (!definitiva && !data_da.ok())
return f.warning_box("Manca la data di partenza");
if (data_da.ok() && data_da > data_a)
return f.warning_box("La data di partenza non puo' essere maggiore della data finale");
}
return TRUE;
}
//
// MASK_A_COD_REG
//
// ----------->>>> SCRIVO ANCHE QUI _ae <<<<----------------
//
bool TStampa_giornale::mask_a_cod_reg (TMask_field& f, KEY k)
{
if (f.to_check(k))
{
TMask& m = f.mask();
TStampa_giornale& a = app();
const bool definitiva = m.get_bool(STAMPA_DEF);
const TString16 data_astr(m.get(DATA_A));
const TDate data_a(m.get(DATA_A));
// 25/11 controlli sul registro solo DOPO aver messo la DATA_A
if (data_astr.empty())
return TRUE;
else
{
a._ae_solare = data_a.year(); // Anno solare usato per la tabella dei registri
a._ae = a._ae_solare; // Anno esercizio
}
const TString16 reg_cod(f.get());
if (reg_cod.empty())
{
if (k == K_TAB) // Magari ci ripassa e lo inserisce
return TRUE;
else // Se e' K_ENTER mi serve davvero
return f.error_box("Manca il codice registro");
}
bool reg_ok = a.leggi_tabreg(reg_cod, a._ae_solare);
// Output da qui della descrizione del registro e dell'anno
m.set(REG_DESC, a._reg_descr);
m.set(ANNO_ESER, a._ae_solare);
/*
// CHECKTYPE NORMAL abolito! (nella maschera non ho l'anno...
if (!reg_ok)
return f.warning_box("Registro inesistente");
if (app()._tipo != 5)
return f.warning_box("Il registro %s per l'anno %d non e' di tipo libro giornale",
(const char *) reg_cod, a._ae);
*/
}
return TRUE;
}
//
// mask_b_ripristina
//
// Se premo il bottone <Ripristina> rimetto i valori precedenti
// dentro ai campi (per ripetere la stampa)
//
bool TStampa_giornale::mask_b_ripristina (TMask_field& f, KEY k)
{
if (k == K_SPACE)
{
TMask& m = f.mask();
TStampa_giornale& a = (TStampa_giornale&)main_app();
m.set(PROGR_DARE, a._tot_dare.string());
m.set(ULTIMA_DATA, a._last_data.string());
m.set(N_RIGA_STAMPATO, a._nprog_da);
m.set(PAGINA_DA, a._pagine_stampate);
}
return TRUE;
}
bool TStampa_giornale::mask_b_warning (TMask_field& f, KEY k)
{
static bool gia_detto = FALSE;
if (k == K_TAB && !f.mask().is_running())
gia_detto = FALSE;
if (!gia_detto)
{
if (k == K_SPACE)
{
f.warning_box("Le modifiche a questi progressivi saranno scritte nel registro");
gia_detto = TRUE;
return TRUE;
}
}
return TRUE;
}
void TStampa_giornale::init_print()
{
// 17.5.95 Leggo parametri di stampa del registro
TString16 config;
config.format("REG%05ld%03s", get_firm(), (const char*)_reg_cod);
printer().read_configuration(config);
if (_stampa_len != 0)
printer().formlen(_stampa_len);
printer().footerlen(RIGHE_FOOTER);
reset_print();
reset_header();
reset_footer();
set_background();
for (int i=1; i<RIGHE_FOOTER; i++) set_footer(i, "%s", " ");
set_real_picture (REAL_PICTURE);
set_print_zero(TRUE);
if (_stampa_width == 1)
_stampa_width = 132;
else
_stampa_width = 198;
/* Guy: sarebbe interessante ma non funziona mai!
// Solo se _pagina_da diversa da 0
if (_pagina_da)
printer().set_from_page(_pagina_da - _pagine_stampate);
*/
// la stampa precedente era andata male
// if (_stampa_ok != -1) set_page_number (_stampa_ok);
_last_header = set_headers();
}
void TStampa_giornale::init_totals()
{
_tot_dare_gg_ap = ZERO;
_tot_avere_gg_ap = ZERO;
_tot_dare_progr_ap = ZERO;
_tot_avere_progr_ap = ZERO;
_tot_dare_gg = ZERO;
_tot_avere_gg = ZERO;
_tot_dare_generale = ZERO;
_tot_avere_generale = ZERO;
if (_stampa_definitiva)
{
_tot_dare_progr = _tot_dare;
_tot_avere_progr = _tot_avere;
}
else
{
_tot_dare_progr = ZERO;
_tot_avere_progr = ZERO;
}
}
bool TStampa_giornale::init_cursor()
{
bool gia_stampati = FALSE;
TRectype da (LF_MOV);
TRectype a (LF_MOV);
da.put(MOV_DATAREG, _data_da);
a.put (MOV_DATAREG, _data_a);
_cur->setregion(da, a);
_cur->set_filterfunction(filter_func);
_cur->setfilter(_stampa_definitiva ? "STAMPATO!=\"X\"" : "");
(*_cur) = 0L;
if (_cur->items() == 0L)
{
_cur->setfilter("");
return warning_box ("Non ci sono movimenti da stampare nel periodo selezionato.\nLa stampa e' annullata");
}
return TRUE;
}
bool TStampa_giornale::set_print(int)
{
TMask ma ("cg3400a");
KEY tasto;
ma.set_handler (CODREG, mask_a_cod_reg);
ma.set_handler (DATA_A, data_a_hndl);
ma.set_handler (DATA_DA,data_da_hndl);
// set_reg_filter(ma);
_pagina_da = 0; // Parto dall'inizio
_forza_ariportare = FALSE;
while ((tasto = ma.run()) != K_QUIT)
{
_libro_giornale_iva_unico = libro_giornale_iva_unico();
_libro_cronologico = libro_cronologico();
_reg_cod = ma.get(CODREG);
_stampa_definitiva = ma.get_bool(STAMPA_DEF);
_data_da = ma.get(DATA_DA);
_data_a = ma.get(DATA_A);
_stampa_width = ma.get_int(STAMPA_WIDTH);
_stampa_len = ma.get_int(STAMPA_LEN);
// Se stampa definitiva DALLA_DATA e' la data di inizio esercizio
// e si scartano i movimenti gia' stampati su bollato
if (_stampa_definitiva)
{
_data_da = TDate(1,1,_ae);
// Controlla che non siano rimasti movimenti ancora da stampare dell'es.prec.
if (_stampa_stesso_registro)
if (!controlla_mov_aep())
continue;
}
if (!init_cursor()) continue;
if (_stampa_definitiva)
{
TMask mb("cg3400b");
mb.set_handler (DLG_RIPRISTINA, mask_b_ripristina);
mb.set_handler (PROGR_DARE, mask_b_warning);
mb.set_handler (N_RIGA_STAMPATO,mask_b_warning);
mb.set_handler (ULTIMA_DATA, mask_b_warning);
mb.set (PROGR_DARE, _tot_dare.string());
mb.set (N_RIGA_STAMPATO, _nprog_da);
mb.set (ULTIMA_DATA, _last_data.string());
mb.set (PAGINA_DA, _pagine_stampate);
tasto = mb.run();
if (tasto == K_ENTER)
{
_nprog_da = mb.get_long(N_RIGA_STAMPATO);
_last_data = mb.get(ULTIMA_DATA);
real dare2(mb.get(PROGR_DARE));
_pagina_da = mb.get_int(PAGINA_DA);
// "Se l'utente cambia il progressivo dare, esso viene uguagliato all'avere"
if (dare2 != _tot_dare)
{
_tot_dare = dare2;
_tot_avere = dare2;
}
}
else
continue;
}
init_print();
init_totals();
return TRUE;
}
return FALSE;
}
int cg3400 (int argc, char * argv[])
{
TStampa_giornale app;
app.run(argc, argv, "Stampa libro giornale");
return TRUE;
}
Reference in New Issue View Git Blame Copy Permalink