root/campo-sirio
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
campo-sirio/cg/cg3400.cpp
alex 649a9819c8 Patch level : xx.282 
Files correlati     :
Ricompilazione Demo : [ ]
Commento            : Riportata la versione 01.05 patch 282


git-svn-id: svn://10.65.10.50/trunk@8058 c028cbd2-c16b-5b4b-a496-9718f37d4682
1999-04-16 12:02:04 +00:00

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

// cg3400 - Stampa libro giornale
#include <config.h>
#include <currency.h>
#include <mask.h>
#include <tabutil.h>
#include <printapp.h>
#include <progind.h>
#include <recarray.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 };
HIDDEN enum tipo_sospensione { nessuna, normale, vol_affari, liquidazione };
class TContoOccas : public TBill
{
TString16 _occfpi;
TDecoder _clifoccas;
TDecoder _occas;
TAssoc_array _desc;
public:
const TContoOccas& set(int g = 0, int c = 0, long s = 0L, char t = ' ',
const char* occfpi = NULL);
const TString& descrizione();
TContoOccas();
virtual ~TContoOccas() {}
};
TContoOccas::TContoOccas()
: _occfpi(NULL), _clifoccas(LF_CLIFO, CLI_OCCAS),
_occas(LF_OCCAS, "RAGSOC")
{ }
const TContoOccas& TContoOccas::set(int g, int c, long s, char t, const char* occfpi)
{
TBill::set(g,c,s,t);
_occfpi = occfpi;
return *this;
}
const TString& TContoOccas::descrizione()
{
if (_occfpi.not_empty())
{
TString16 code; code << tipo() << '|' << sottoconto();
bool really_occas = _clifoccas.decode(code).not_empty();
if (really_occas)
return _occas.decode(_occfpi);
}
TString16 code; code.format("%c%03d%03d%06ld",
tipo(), gruppo(), conto(), sottoconto());
TString* d = (TString*)_desc.objptr(code);
if (d == NULL)
{
d = new TString(TBill::descrizione());
_desc.add(code, d);
}
return *d;
}
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;
int _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.
TContoOccas _tc;
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;
TRecord_cache *_com;
TLocalisamfile *_clifo,*_pconti,*_nditte,*_anag;
TLocalisamfile* _attiv; // da togliere in futuro (?)
TTable *_tabreg;
TDecoder *_causali, *_tabiva; // 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 void on_firm_change();
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);
const TRectype& look_com (const char* cod, const char* stato = "");
const TString& 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_solare)
{
const TRectype& rec = r->lfile().curr();
const int anno = atoi(rec.get("CODTAB").left(4));
ok = anno == app()._ae_solare;
}
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;
// Scarto i movimenti che hanno il registro ai soli fini della liquidazione
const tipo_sospensione ts = r->lfile("REG").get_bool("B1") ? (tipo_sospensione) r->lfile("REG").get_int("I9") : nessuna;
if (ts == liquidazione)
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
//////////////////////////////////////////////////////////////////////////
const TRectype& TStampa_giornale::look_com (const char* cod, const char* stato)
{
TString16 codice;
codice << stato << '|' << cod;
return _com->get(codice);
}
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);
const 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);
}
}
void TStampa_giornale::on_firm_change()
{
TConfig conf(CONFIG_DITTA);
_libro_giornale_iva_unico = conf.get_bool("StLgiU");
_libro_cronologico = conf.get_bool("GsLbCn");
}
bool TStampa_giornale::user_create()
{
_ae = 0;
_ae_solare = 0;
_tabreg = new TTable ("REG");
_tabiva = new TDecoder("%IVA");
_nditte = new TLocalisamfile(LF_NDITTE);
_anag = new TLocalisamfile (LF_ANAG);
_com = new TRecord_cache(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");
_rel->add ("REG", "CODTAB[1,4]=ANNOIVA|CODTAB[5,7]=REG");
_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 _RecPartoDa;
delete _RecArrivoA;
delete _com;
delete _clifo; delete _pconti;
delete _nditte; delete _anag;
delete _tabreg;
delete _tabiva;
delete _causali;
delete _attiv; // da togliere in futuro
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))
{
TString80 td; real2currency(td, _tot_dare_gg);
TString80 ta; real2currency(ta, _tot_avere_gg);
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))
{
TString80 tdp; real2currency(tdp, _tot_dare_gg_ap);
TString80 tap; real2currency(tap, _tot_avere_gg_ap);
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 && 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)
{
real2currency(progr_dare_ap, _tot_dare_progr_ap);
real2currency(progr_avere_ap, _tot_avere_progr_ap);
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 int riporta = _devo_riportare;
if (riporta)
{
dt = _tot_dare_progr + _tot_dare_progr_ap;
at = _tot_avere_progr + _tot_avere_progr_ap;
real2currency(dts, dt);
real2currency(ats, at);
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)
{
real2currency(progr_dare_ap, _tot_dare_progr_ap);
real2currency(progr_avere_ap, _tot_avere_progr_ap);
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)
{
real2currency(progr_dare, _tot_dare_progr);
real2currency(progr_avere, _tot_avere_progr);
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;
real2currency(dts, _tot_dare_generale);
real2currency(ats, _tot_avere_generale);
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;
real2currency(dts, dt);
real2currency(ats, at);
// "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;
}
TString80 dare; real2currency(dare, riporto_dare);
TString80 avere; real2currency(avere, riporto_avere);
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-2,
_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;
long numreg, protiva;
int r = 1;
int g, c;
long s;
static char cf = ' ';
static int rdes = 1;
switch (file)
{
case LF_MOV:
{
const TRectype& mov = _cur->curr(LF_MOV);
reset_row(1);
reset_row(2);
datareg = mov.get_date("DATAREG");
datadoc = 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 = mov.get("NUMDOC");
numreg = mov.get_long("NUMREG");
mov_descr = mov.get("DESCR");
// Usati in setta_righe_iva per determinare tipo attivita'
_reg = mov.get(MOV_REG);
_anno_iva = mov.get_int(MOV_ANNOIVA);
protiva = mov.get_long(MOV_PROTIVA);
caus = mov.get(MOV_CODCAUS);
_occfpi = mov.get(MOV_OCFPI);
_annoEsMov = mov.get_int(MOV_ANNOES);
_MovGiaStampato = 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)
{
TString16 fmt;
fmt.format("@%dg*", _stampa_width == 132 ? 131 : 197);
set_row(r,fmt);
}
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:
{
const TRectype& rmov = _cur->curr(LF_RMOV);
_num_rig++;
reset_print();
g = rmov.get_int("GRUPPO");
c = rmov.get_int("CONTO");
s = rmov.get_long("SOTTOCONTO");
cf = rmov.get_char(RMV_TIPOC);
if (cf != 'C' && cf != 'F')
cf = ' ';
numreg = rmov.get_long("NUMREG");
datareg = rmov.get("DATAREG");
_sezione = rmov.get_char (RMV_SEZIONE);
_importo = rmov.get_real (RMV_IMPORTO);
rmv_descr = 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,_occfpi);
TParagraph_string descr_conto("", 198);
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)
{
TString16 fmt;
fmt.format("@%dg*", _stampa_width == 132 ? 131 : 197);
set_row(r,fmt);
}
{
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()
{
TString16 codiva;
int tipocr, tipodet, tipoatt;
real impo, impos;
bool intra;
const 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 TString& TStampa_giornale::get_codiva_des(const char* codiva)
{
return _tabiva->decode(codiva);
}
// 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++)
{
const TRigaiva& riga = (TRigaiva&)_iva_array[j];
r = j+1;
TString80 impon_str; real2currency(impon_str, riga._imponibile);
TString80 impos_str; real2currency(impos_str, riga._imposta);
// 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, "@35gImposta@43g%15s", (const char*)impos_str);
// set_row(r, "@58gCod.Iva@68g%3s", (const char*)riga._codiva);
set_row(r, "@64gCod.Iva %3s", (const char*)riga._codiva);
const TString& codiva_des = get_codiva_des(riga._codiva);
const int tipoatt = riga._tipoatt;
if (_stampa_width == 132)
set_row(r, "@76g%-.17s", (const char*)codiva_des);
else
set_row(r, "@76g%-.50s", (const char*)codiva_des);
const int S132 = 97;
const int S198 = 127;
rig.format("@%dg", _stampa_width == 132 ? S132 : S198);
switch (riga._tipodet)
{
case 0 :
rig << "Detraibile ";
break;
case 1 :
rig << "Indetraib. 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);
const int meseliq = _cur->file(LF_MOV).get_int(MOV_MESELIQ);
if (meseliq > 0)
set_row(r, " Mese liq. %2d", meseliq);
if (tipoatt != 0)
{
TRegistro reg(_reg, _anno_iva);
const bool att_mista_ev = reg.attivita_mista();
if (att_mista_ev)
set_row(r, " Tipo attivita' %d", tipoatt);
}
}
_iva_array.destroy();
return r;
}
int TStampa_giornale::setta_righe_valuta(int r)
{
const real corrval = current_cursor()->file(LF_MOV).get_real(MOV_CORRVALUTA);
if (corrval != ZERO)
{
const TString16 codvali = current_cursor()->file(LF_MOV).get(MOV_CODVALI);
const TCurrency cur(corrval, codvali);
set_row(++r,"@56gValuta %3s", (const char*)codvali);
if (_stampa_width == 132)
set_row(r,"@89gCorr.in valuta @109g%20v", &cur);
else
set_row(r,"@119gCorr.in valuta @171g%20v", &cur);
}
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);
}
const TRectype& rec = look_com (comcf, statocf);
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");
statona = _clifo->get("STATONASC");
const TRectype& dep = look_com (codcomna, statona);
comna = dep.get(COM_DENCOM);
provna = dep.get(COM_PROVCOM);
capna = dep.get(COM_CAPCOM);
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, TRUE);
// _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;
TEsercizi_contabili esc;
app()._ae_solare = data_a.year();
app()._ae = esc.date2esc(data_a);//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());
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
{
TEsercizi_contabili esc;
a._ae_solare = data_a.year(); // Anno solare usato per la tabella dei registri
a._ae = esc.date2esc(data_a); //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, TRUE);
_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");
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;
KEY tasto;
while ((tasto = ma.run()) != K_QUIT)
{
_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);
set_magic_currency(TRUE);
set_curr_codval(ma.get(F_CODVAL));
// Se stampa definitiva DALLA_DATA e' la data di inizio esercizio
// e si scartano i movimenti gia' stampati su bollato
if (_stampa_definitiva)
{
TEsercizi_contabili esc;
_data_da = esc.esercizio(_ae).inizio();//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