#include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include "cglib.h" #include "cg1.h" #include "cg1600.h" extern char __tmp [MAXSTR]; static TFixed_string tmp(__tmp, MAXSTR); bool our_handler (TMask_field & f,KEY k); class Anno_es : public TObject { TDate _inizio, _fine; TToken_string *_str; public: long anno(); TDate inizio(); TDate fine() ; Anno_es(long anno, TDate& inizio, TDate& fine); ~Anno_es() { delete _str; } }; TDate Anno_es::inizio() { _inizio = _str->get(1); return _inizio; } TDate Anno_es::fine() { _fine = _str->get(2); return _fine; } long Anno_es::anno() { return _str->get_int(0); } Anno_es::Anno_es(long anno, TDate& inizio, TDate& fine) { _str = new TToken_string(35); _inizio = inizio; _fine = fine; _str->add(anno); _str->add(_inizio.string()); _str->add(_fine.string()); } class Anni_es : public TAssoc_array { TTable * _tabesc; public: void add(long anno, TDate& inizio, TDate& fine); void aggiungi_anno(long anno, TDate& inizio, TDate& fine); Anno_es * trova(long anno, TDate& inizio, TDate& fine); Anni_es(); ~Anni_es() { delete _tabesc; } }; Anni_es::Anni_es() { _tabesc = new TTable (TAB_ESC); } void Anni_es::add(long annoe, TDate& in, TDate& fin) { TString key = format("%4ld", annoe); Anno_es anno(annoe, in, fin); TAssoc_array::add(key, anno); } Anno_es * Anni_es::trova(long annoe, TDate& in, TDate& fin) { TString key = format("%4ld", annoe); Anno_es *anno = (Anno_es*) objptr ((const char*) key); if (anno == NULL) { in = ""; fin = ""; } else { in = anno->inizio(); fin = anno->fine(); } return anno; } void Anni_es::aggiungi_anno(long annoese, TDate& inizio, TDate& fine) { TString dep; TString key = format("%4ld", annoese); Anno_es * anno; if (!is_key((const char *) key)) { _tabesc->curr().zero(); dep = format ("%04d",annoese); _tabesc->curr().put("CODTAB", (const char*) dep); _tabesc->read(); if (_tabesc->bad()) _tabesc->curr().zero(); inizio = _tabesc->curr().get_date("D0"); fine = _tabesc->curr().get_date("D1"); anno = new Anno_es(annoese, inizio, fine); TAssoc_array::add(key, anno); } else anno = trova (annoese, inizio, fine); } class _riga_sez_opp : public TObject { TToken_string * _str; public: int gruppo() { return atoi(_str->get(0)); } int conto() { return atoi(_str->get(1)); } int sottoc() { return atoi(_str->get(2)); } const char * sezione () { return _str->get(3); } const char * lettera () { return _str->get(4); } const char * num_rom () { return _str->get(5); } int numero () { return atoi(_str->get(6)); } real saldo_conto (); void incrementa_saldo(real& nuovo_saldo); _riga_sez_opp(int g, int c, long s, const char * sezione, const char * lettera, const char * num_rom, int num, real& saldo); ~_riga_sez_opp(); }; real _riga_sez_opp::saldo_conto () { real r(_str->get(7)); return r; } void _riga_sez_opp::incrementa_saldo(real& sld) { real sld_prec = saldo_conto(); sld_prec += sld; _str->add(sld_prec.string(), 7); } _riga_sez_opp::_riga_sez_opp(int g, int c, long s, const char * sezione, const char * lettera, const char * num_rom, int num, real& saldo) { _str = new TToken_string(30); _str->add(format("%d",g)); _str->add(format("%d",c)); _str->add(format("%ld",s)); _str->add(sezione); _str->add(lettera); _str->add(num_rom); _str->add(format("%d",num)); _str->add(saldo.string()); } _riga_sez_opp::~_riga_sez_opp() { delete _str; } class Righe_sez_opp : public TAssoc_array { public: _riga_sez_opp* riga() { return (_riga_sez_opp*) get(); } int gruppo() { return riga()->gruppo(); } int conto() { return riga()->conto(); } int sottoc() { return riga()->sottoc(); } const char * sezione () { return riga()->sezione(); } const char * lettera () { return riga()->lettera(); } const char * num_rom () { return riga()->num_rom(); } int numero () { return riga()->numero(); } real saldo_conto () { return riga()->saldo_conto(); } void add (int g, int c, long s, const char * sezione, const char * lettera, const char * num_rom, int num, real saldo); }; void Righe_sez_opp::add(int g, int c, long s, const char * sezione, const char * lettera, const char * num_rom, int num, real saldo) { _riga_sez_opp * riga; TString key = format("%s%s%s%d",sezione,lettera,num_rom,num); if (!is_key((const char *) key)) { riga = new _riga_sez_opp (g, c, s, sezione, lettera, num_rom, num, saldo); TAssoc_array::add(key,riga); } else { riga = (_riga_sez_opp*) objptr ((const char*) key); riga->incrementa_saldo(saldo); // add(key,riga,TRUE); } } class CG1600_application : public TPrintapp { friend bool our_handler (TMask_field & f,KEY k); struct bil_ivd { char sez; char let; char numr[10]; char num[4]; char gruppo[4]; char conto[4]; char sottoc[8]; real saldo; real saldorafr; real sld_prg_dare; real sld_prg_avere; real mov_dare; real mov_avere; char tipocf; }; bil_ivd* _bil; TMask* _msk; TTable* _tabesc; TTable* _tabivd; TLocalisamfile* _nditte; TLocalisamfile* _comuni; TLocalisamfile* _unloc; TLocalisamfile* _anag; TLocalisamfile* _pconti; TLocalisamfile* _clifo; const char* _buff; TSort* _sort; Anni_es _anni_es; Righe_sez_opp _sezopps; TClifo_list* _listacf; TProgind* _prog; TDate _data_fine_ese,_data_fine_ese_prec,_data_fine_raf,_data_fine_raf_prec; TDate _datastampa,_datalimite,_databilrafr,_datai,_datairaf; TDate _dataini,_datafine,_data_ini_ese; int _annoese,_annoeserafr; bool _competenza,_intera_struttura,_stampamov,_stampacod,_stampa_modulo; bool _stampa_mov_prov; TString _classe_stampata, _classe_da_stampare,_numr_tot,_num_tot,_numr,_num; char _sez_da_stamp,_let_da_stamp,_sez_stamp,_let_stamp,_sez_tot,_let_tot,_let,_sez_saldo,_sez,_tot_sez_saldo; TString _numr_da_stamp,_num_da_stamp,_numr_stamp,_num_stamp,_descr_sez; int _tipo_bilancio, _tipo_stampa; int _cont_let,_cont_numr,_cont_num,_cont_gcs; Saldo _sld; real _sale,_salerafr,_totale_ordine,_totale_economico; real _totale_ordine_raf,_totale_economico_raf; real _totale_numero,_totale_numr,_totale_lettera,_totale_sezione; real _totale_patrimoniale,_totale_attivita,_totale_passivita; real _totale_num_raf,_totale_numr_raf,_totale_let_raf,_totale_sez_raf; real _totale_patrim_raf,_totale_attiv_raf,_totale_passiv_raf; real _totale_ordine_attivo,_totale_ordine_passivo,_totale_ordine_attivo_raf; real _totale_ordine_passivo_raf; real _mov_periodo_dare,_mov_periodo_avere,_prg_prec_dare,_prg_prec_avere,_saldo_ini_dare,_saldo_ini_avere; real _sld_prg_dare,_sld_prg_avere,_mov_dare,_mov_avere; real _tot_num_saldo,_tot_numr_saldo,_tot_let_saldo,_tot_gen_saldo; real _tot_num_prg_d,_tot_numr_prg_d,_tot_let_prg_d,_tot_gen_prg_d; real _tot_num_prg_a,_tot_numr_prg_a,_tot_let_prg_a,_tot_gen_prg_a; real _tot_num_mov_d,_tot_numr_mov_d,_tot_let_mov_d,_tot_gen_mov_d; real _tot_num_mov_a,_tot_numr_mov_a,_tot_let_mov_a,_tot_gen_mov_a; real _tot_num_saldo_d,_tot_numr_saldo_d,_tot_let_saldo_d,_tot_gen_saldo_d; real _tot_num_saldo_a,_tot_numr_saldo_a,_tot_let_saldo_a,_tot_gen_saldo_a; int _i; bool _reset_righe_stampa,_totale_attivita_gia_stampato,_totale_passivita_gia_stampato,_statopatr_no_stamp; TString _causale_ap, _causale_chi; public: bool menu (MENU_TAG m) { return TPrintapp::menu(m) ; } void user_create() ; void user_destroy(); bool set_print(int); virtual bool preprocess_page (int,int); virtual print_action postprocess_page (int,int); virtual print_action postprocess_print (int,int); virtual void preprocess_header(); virtual void set_page(int,int); bool preprocess_stampa_scalare(int); bool preprocess_stampa_verifica(int); void crea_intestazione(); void intesta_scalare(); void intesta_verifica(); void intesta_verifica_fissa(); TDate data_inferiore(); TDate data_inferiore_raf(); void init_sort(); void crea_sort_tabella(); void crea_sort_piano_conti_scalare(); void crea_sort_piano_conti_verifica(); void scrivi_record(const TString&,const TString&,const TString&,int,int,int,long,const real&,const real&,const real&,const real&,const real&,const real&,char); void scrivi_record_fittizio(const TString&,const TString&,const TString&,int); void riempi_record(const TString&,const TString&,const TString&,int,int,int,long,const real&,const real&,const real&,const real&,const real&,const real&,char); const char* descrizione_sezione(char); const char* descrizione_lettera(char, char); const char* descrizione_numeroromano(char, char, TString); const char* descrizione_numero(char, char, TString, int); const char* descrizione_sottoconto(int, int, long); const char* descr_sottoc_clifo(char,int,int,long); void setta_righe(const char*); void setta_righe_verifica(); void stampa_totali(); void stampa_totali_con_raffronto(); void stampa_totali_verifica(); bool calcola(int,int,long,const TDate&,const TDate&); bool calcola_saldo(real&, real&,int,int,long,int); bool ricerca_sottoc_clifo(int,int,char,TString&,TString&,TString&,int,int); const char* causale_apertura() { return _causale_ap;} const char* causale_chiusura() { return _causale_chi;} void stampa_saldo_132(const real&); void stampa_saldo_198(real&, real&); void set_bil_key(bil_ivd* b, char lettera, char sezione, const char* numero_romano, int numero, bool conti_ordine = TRUE, int conto = 0, int gruppo = 0, long sottoconto = 0L, char tipocf = ' '); void set_bil_val(bil_ivd* b, const real& saldo = ZERO, const real& saldorafr = ZERO, const real& sld_prg_dare = ZERO, const real& sld_prg_avere = ZERO, const real& mov_dare = ZERO, const real& mov_avere = ZERO); CG1600_application() {} }; print_action CG1600_application::postprocess_print(int file, int counter) { delete _sort; return NEXT_PAGE; } void CG1600_application::set_bil_key(bil_ivd* b, char lettera, char sezione, const char* numero_romano, int numero, bool conti_ordine, int conto, int gruppo, long sottoconto, char tipocf) { b->sez = sezione; //Se esiste solamente la sezione,significa che e' un conto d'ordine //Forzo la lettera della classe a Z, per ottenere, grazie //all'ordinamento del sort, i record dei conti d'ordine per ultimi b->let = (conti_ordine && lettera == '\0' && sezione < '3') ? 'Z' : lettera; strcpy(b->numr, numero_romano); sprintf(b->num , "%2d", numero); if (gruppo < 0) { strcpy(b->gruppo, "ZZZ"); strcpy(b->conto, "ZZZ"); strcpy(b->sottoc, "ZZZZZZ"); b->tipocf = ' '; } else if (gruppo == 0) { strcpy(b->gruppo, "AAA"); strcpy(b->conto, "AAA"); strcpy(b->sottoc, "AAAAAA"); b->tipocf = ' '; } else { sprintf(b->gruppo , "%3d", gruppo); sprintf(b->conto , "%3d", conto); sprintf(b->sottoc , "%6ld", sottoconto); b->tipocf = tipocf; } } void CG1600_application::set_bil_val(bil_ivd* b, const real& saldo, const real& saldorafr, const real& sld_prg_dare, const real& sld_prg_avere, const real& mov_dare, const real& mov_avere) { b->saldo = saldo; b->saldorafr = saldorafr; b->sld_prg_dare = sld_prg_dare; b->sld_prg_avere = sld_prg_avere; b->mov_dare = mov_dare; b->mov_avere = mov_avere; } bool our_handler(TMask_field& f, KEY key) { if (key == K_ENTER) { TMask& m = f.mask(); int tipobil,tipostampa; TDate datalim,databilrafr; TDate in="", fin="", in_prec="", fin_prec=""; CG1600_application * a = (CG1600_application*) MainApp(); tipobil = atoi(m.get(F_TIPOBIL)); tipostampa = atoi(m.get(F_TIPOSTAMPA)); long annoese = m.get_long(F_ANNOESE); long annoprec = annoese - 1; a->_anni_es.aggiungi_anno(annoese, in, fin); a->_anni_es.aggiungi_anno(annoprec, in_prec, fin_prec); a->_data_fine_ese = fin; a->_data_fine_ese_prec = fin_prec; if ((tipobil == 1) && (tipostampa == 1)) { if (f.dlg() == F_DATALIM) { datalim = m.get(F_DATALIM); if ((datalim < in_prec)||(datalim > fin)) { f.error_box("La data limite non puo' essere inferiore alla data inizio esercizio precedente, e superiore alla data fine esercizio in corso"); return FALSE; } } if (f.dlg() == F_DATABILRAF) { datalim = m.get(F_DATALIM); databilrafr = m.get(F_DATABILRAF); if (datalim <= fin_prec) if (databilrafr >= in_prec) { f.error_box("La data bilancio da raffrontare non puo' essere maggiore o uguale alla data inizio esercizio precedente"); return FALSE; } if (datalim <= fin) if (databilrafr >= in) { f.error_box("La data bilancio da raffrontare non puo' essere maggiore o uguale alla data inizio esercizio in corso"); return FALSE; } } } if ((tipobil == 1) && (tipostampa == 2)) if (f.dlg() == F_DATABILRAF) { databilrafr = m.get(F_DATABILRAF); if ((databilrafr>=in)) { f.error_box("La data bilancio da raffrontare non puo' essere superiore alla data inizio esercizio in corso"); return FALSE; } } if ((tipobil == 1) && (tipostampa == 3)) if (f.dlg() == F_DATABILRAF) { databilrafr = m.get(F_DATABILRAF); if ((databilrafr>=in_prec)) { f.error_box("La data bilancio da raffrontare non puo' essere superiore alla data inizio esercizio precedente"); return FALSE; } } if ((tipobil == 2) && (tipostampa == 1)) { if (f.dlg() == F_DATAINI) { TDate dataini(m.get(F_DATAINI)); if (dataini < in) { f.error_box("La data limite inferiore non puo' essere minore della data inizio esercizio precedente"); return FALSE; } } if (f.dlg() == F_DATAFINE) { TDate datafine(m.get(F_DATAFINE)); if (datafine > fin) { f.error_box("La data limite superiore non puo' essere maggiore della data inizio esercizio in corso"); return FALSE; } } } } return TRUE; } void CG1600_application::scrivi_record(const TString& sez, const TString& let, const TString& numerorom,int numero, int g,int c,long s,const real& saldo,const real& saldorafr, const real& sld_dare,const real& sld_avere, const real& mov_dare,const real& mov_avere,char tipocf) { //Se esiste solamente la sezione,significa che e' un conto d'ordine //Forzo la lettera della classe a Z, per ottenere, grazie //all'ordinamento del sort, i record dei conti d'ordine per ultimi set_bil_key(_bil, sez[0], let[0], numerorom, numero, TRUE, g, c, s, tipocf); set_bil_val(_bil, saldo, saldorafr, sld_dare, sld_avere, mov_dare, mov_avere); _sort->sort ((const char*) _bil); } void CG1600_application::scrivi_record_fittizio(const TString& sez, const TString& let,const TString& numerorom,int numero) { set_bil_key(_bil, sez[0], let[0], numerorom, numero, TRUE, 0); set_bil_val(_bil); _sort->sort ((const char*) _bil); } void CG1600_application::riempi_record(const TString& sez, const TString& let, const TString& numerorom,int numero, int g,int c,long s,const real& saldo,const real& saldorafr, const real& sld_dare,const real& sld_avere, const real& mov_dare,const real& mov_avere,char tipocf) { set_bil_key(_bil, sez[0], let[0], numerorom, numero, FALSE, g, c, s, tipocf); set_bil_val(_bil, saldo, saldorafr, sld_dare, sld_avere, mov_dare, mov_avere); _sort->sort ((const char*) _bil); } void CG1600_application::crea_sort_tabella() { TRecnotype recno_prec=0l, recno_curr=0l; TString codtab_prec; TTable tabivd(TAB_IVD); TRecfield codtab_curr(tabivd.curr(),"CODTAB"); TRecfield sezione (tabivd.curr(),"CODTAB",0,0); TRecfield lettera (tabivd.curr(),"CODTAB",1,1); TRecfield numerorom (tabivd.curr(),"CODTAB",2,9); TRecfield numero (tabivd.curr(),"CODTAB",10,11); int preclen; bool FINITO=FALSE; init_sort(); tabivd.first(); codtab_prec = tabivd.get("CODTAB"); // Compilo tanti record quante sono le classi IV direttiva trovate sulla // tabella %IVD, usando dei gruppi, conti e sottoconti fittizi. Successivamente // nel caso di stampa completa verranno stampati anche questi record; nel caso // di stampa non completa non verranno stampati. do { recno_prec = tabivd.recno(); tabivd.next(); if (tabivd.eof()) { tabivd.zero(); FINITO=TRUE; } recno_curr = tabivd.recno(); preclen = codtab_prec.len(); if (!strncmp(codtab_curr,codtab_prec,preclen)) codtab_prec = (const char *)codtab_curr; else { tabivd.readat(recno_prec); const char sez = *((const char*) sezione); const char let = *((const char*) lettera); set_bil_key(_bil, sez, let, numerorom, numero, FALSE); set_bil_val(_bil); _sort->sort ((const char*) _bil); tabivd.readat(recno_curr); codtab_prec = (const char *)codtab_curr; } } while (!FINITO); } // Passo al sort tutti i record presenti su piano dei conti, aventi la classe // IV direttiva CEE. void CG1600_application::crea_sort_piano_conti_scalare() { TLocalisamfile pconti(LF_PCON); TString sez,let,numerorom; TString sez_conto,let_conto,numr_conto,sez_opp,let_opp,numr_opp; int num_conto, indbil; char sezione,lettera,tmcf; int numero,g,c,num_opp; long s; bool sez_opposta = FALSE; bool no_sez_opposta = FALSE; bool classe_conto = FALSE; bool conto_dettagliato = FALSE; bool stsottbil; int gruppo_prec,conto_prec; real saldo,saldo_raf,saldo_conto,saldo_conto_raf; real saldo_conto_opp,saldo_conto_raf_opp; c = 0; num_conto = 0; tmcf = ' '; indbil = 0; saldo_conto = ZERO; saldo_conto_raf = ZERO; saldo_conto_opp = ZERO; saldo_conto_raf_opp = ZERO; gruppo_prec = -1; conto_prec = -1; for (pconti.first(); !pconti.eof(); pconti.next()) { _prog->addstatus(1); g = pconti.get_int (PCN_GRUPPO); c = pconti.get_int (PCN_CONTO); s = pconti.get_long(PCN_SOTTOCONTO); sez = pconti.get(PCN_SEZIVD); let = pconti.get(PCN_LETTIVD); sezione = sez[0]; lettera = let[0]; numerorom = pconti.get(PCN_NUMRIVD); numero = pconti.get_int (PCN_NUMIVD); saldo = ZERO; saldo_raf = ZERO; if (conto_dettagliato) { if (classe_conto) { if (c != conto_prec && conto_prec != -1) { if (no_sez_opposta) { riempi_record(sez_conto,let_conto,numr_conto,num_conto,gruppo_prec,conto_prec,0,saldo_conto,saldo_conto_raf,ZERO,ZERO,ZERO,ZERO,tmcf); saldo_conto = ZERO; saldo_conto_raf = ZERO; classe_conto = FALSE; no_sez_opposta = FALSE; } if (sez_opposta) { int items = _sezopps.items(); _sezopps.restart(); for (int i=0; isezione(); TString let_opp = lriga->lettera(); TString numr_opp = lriga->num_rom(); int num_opp = lriga->numero(); real saldo_conto_opp = lriga->saldo_conto(); riempi_record(sez_opp,let_opp,numr_opp,num_opp,gruppo_prec,conto_prec,0,saldo_conto_opp,ZERO,ZERO,ZERO,ZERO,ZERO,tmcf); } sez_opposta = FALSE; _sezopps.destroy(); } } } } //Senza questo controllo conto_prec quando viene letto un gruppo verrebbe //settato a 0 (il conto non c'e'), quindi nella eventuale lettura del conto //nel ciclo successivo, qualsiasi conto sarebbe diverso da quello precedente. if (g != gruppo_prec) conto_prec = -1; else conto_prec = c; gruppo_prec = g; // Se si tratta di un conto e contiene la classe, allora lo passo al sort. // Gli eventuali sottoconti avranno la stessa classe. if ((g != 0) && (c != 0) && (s == 0)) { stsottbil = pconti.get_bool(PCN_STSOTTBIL); tmcf = pconti.get(PCN_TMCF)[0]; long record = pconti.recno(); pconti.next(); pconti.next(); int g_app = pconti.get_int(PCN_GRUPPO); int c_app = pconti.get_int(PCN_CONTO); long s_app = pconti.get_long(PCN_SOTTOCONTO); pconti.readat(record); //Se sono nello stesso gruppo, ma ho un conto diverso da quello precedentemente //analizzato, allore devo controllare se va dettagliato //(STSOTTBIL) e in caso affermativo se ha almeno due sottoconti. if (((stsottbil)||(tmcf=='C')||(tmcf=='F'))&&((g_app!=0)&&(c_app!=0)&&(s_app!=0))) { conto_dettagliato = TRUE; indbil = pconti.get_int(PCN_INDBIL); if ((let != "")||(numerorom != "")||(numero != 0)) { // if (sez == "") // sez_conto = "9"; // else sez_conto = sez; if (let != "") let_conto = let; else if ((sez == "1")||(sez == "2")) let_conto = "Z"; else let_conto = let; numr_conto = numerorom; num_conto = numero; classe_conto = TRUE; } else classe_conto = FALSE; } else conto_dettagliato = FALSE; } // Se si tratta di un sottoconto e contiene la classe, allora lo passo al sort. if (conto_dettagliato) { if ((g != 0) && (c != 0) && (s != 0)) { // int indbil = pconti.get_int(PCN_INDBIL); if (!calcola_saldo(saldo,saldo_raf,g,c,s,indbil)) continue; // classe_conto indica se il conto precedentemente letto conteneva la classe, // ma quest' ultima non era presente a livello di gruppo. In caso affermativo // anche questo sottoconto appena letto avra' la stessa classe del conto. if (classe_conto) { sez_opp = pconti.get(PCN_SEZIVDOPP); if ((sez_opp != "")&&(((sez_conto=="1")&&(saldo < ZERO))||((sez_conto=="2")&&(saldo > ZERO)))) { let_opp = pconti.get(PCN_LETTIVDOPP); numr_opp = pconti.get(PCN_NUMRIVDOPP); num_opp = pconti.get_int(PCN_NUMIVDOPP); sez_opposta = TRUE; saldo = -saldo; _sezopps.add(g,c,s,sez_opp,let_opp,numr_opp,num_opp,saldo); riempi_record(sez_opp,let_opp,numr_opp,num_opp,g,c,s,saldo,saldo_raf,ZERO,ZERO,ZERO,ZERO,tmcf); } else { riempi_record(sez_conto,let_conto,numr_conto,num_conto,g,c,s,saldo,saldo_raf,ZERO,ZERO,ZERO,ZERO,tmcf); saldo_conto += saldo; saldo_conto_raf += saldo_raf; no_sez_opposta = TRUE; } } else { sez_opp = pconti.get(PCN_SEZIVDOPP); if ((sez_opp != "")&&(((sez=="1")&&(saldo < ZERO))||((sez=="2")&&(saldo > ZERO)))) { let_opp = pconti.get(PCN_LETTIVDOPP); numr_opp = pconti.get(PCN_NUMRIVDOPP); num_opp = pconti.get_int(PCN_NUMIVDOPP); riempi_record(sez_opp,let_opp,numr_opp,num_opp,g,c,s,saldo,saldo_raf,ZERO,ZERO,ZERO,ZERO,tmcf); } else { if ((let != "")||(numerorom != "")||(numero != 0)) { // if (sez == "") // sez = "9"; scrivi_record(sez,let,numerorom,numero,g,c,s,saldo,saldo_raf,ZERO,ZERO,ZERO,ZERO,tmcf); } } } } } } conto_prec = 0; if (conto_dettagliato) { if (classe_conto) { if (c != conto_prec && conto_prec != -1) { if (no_sez_opposta) { riempi_record(sez_conto,let_conto,numr_conto,num_conto,gruppo_prec,c,0,saldo_conto,saldo_conto_raf,ZERO,ZERO,ZERO,ZERO,tmcf); saldo_conto = ZERO; saldo_conto_raf = ZERO; classe_conto = FALSE; no_sez_opposta = FALSE; } if (sez_opposta) { int items = _sezopps.items(); _sezopps.restart(); for (int i=0; isezione(); TString let_opp = lriga->lettera(); TString numr_opp = lriga->num_rom(); int num_opp = lriga->numero(); real saldo_conto_opp = lriga->saldo_conto(); riempi_record(sez_opp,let_opp,numr_opp,num_opp,gruppo_prec,conto_prec,0,saldo_conto_opp,ZERO,ZERO,ZERO,ZERO,ZERO,tmcf); } sez_opposta = FALSE; _sezopps.destroy(); } } } } } void CG1600_application::crea_sort_piano_conti_verifica() { TLocalisamfile pconti(LF_PCON); TString sez,let,numerorom; TString sez_conto,let_conto,numr_conto; int num_conto; char sezione,lettera,tmcf; int numero,g,c; long s; bool classe_conto = FALSE; bool conto_dettagliato = FALSE; bool stamp_almeno_un_sottoc = FALSE; bool stsottbil; int gruppo_prec,conto_prec, indbil; real saldo,sld_prg_dare,sld_prg_avere,mov_dare,mov_avere; real saldo_conto,sld_prg_dare_conto,sld_prg_avere_conto,mov_dare_conto,mov_avere_conto; saldo_conto = ZERO; sld_prg_dare_conto = ZERO; sld_prg_avere_conto = ZERO; mov_dare_conto = ZERO; mov_avere_conto = ZERO; indbil = 0; gruppo_prec = -1; conto_prec = -1; c = 0; num_conto = 0; tmcf = ' '; for (pconti.first(); !pconti.eof(); pconti.next()) { _prog->addstatus(1); g = pconti.get_int (PCN_GRUPPO); c = pconti.get_int (PCN_CONTO); s = pconti.get_long(PCN_SOTTOCONTO); sez = pconti.get(PCN_SEZIVD); let = pconti.get(PCN_LETTIVD); sezione = sez[0]; lettera = let[0]; numerorom = pconti.get(PCN_NUMRIVD); numero = pconti.get_int (PCN_NUMIVD); real app; saldo = ZERO; sld_prg_dare = ZERO; sld_prg_avere = ZERO; mov_dare = ZERO; mov_avere = ZERO; app = ZERO; if (conto_dettagliato) { if (stamp_almeno_un_sottoc) { if (classe_conto) { if (c != conto_prec && conto_prec != -1) { riempi_record(sez_conto,let_conto,numr_conto,num_conto,gruppo_prec,conto_prec,0,saldo_conto,ZERO,sld_prg_dare_conto,sld_prg_avere_conto,mov_dare_conto,mov_avere_conto,tmcf); saldo_conto = ZERO; sld_prg_dare_conto = ZERO; sld_prg_avere_conto = ZERO; mov_dare_conto = ZERO; mov_avere_conto = ZERO; classe_conto = FALSE; stamp_almeno_un_sottoc = FALSE; } } } } //Senza questo controllo conto_prec quando viene letto un gruppo verrebbe //settato a 0 (il conto non c'e'), quindi nella eventuale lettura del conto //nel ciclo successivo, qualsiasi conto sarebbe diverso da quello precedente. if (g != gruppo_prec) conto_prec = -1; else conto_prec = c; gruppo_prec = g; // Se si tratta di un conto e contiene la classe, allora lo passo al sort. // Gli eventuali sottoconti avranno la stessa classe. if ((g != 0) && (c != 0) && (s == 0)) { stsottbil = pconti.get_bool(PCN_STSOTTBIL); tmcf = pconti.get(PCN_TMCF)[0]; indbil = pconti.get_int(PCN_INDBIL); if ((tmcf == 'C') || (tmcf == 'F')) if (stsottbil) { if (!ricerca_sottoc_clifo(g, c, tmcf,sez,let,numerorom,numero,indbil)) continue; } else continue; long record = pconti.recno(); pconti.next(); pconti.next(); int g_app = pconti.get_int(PCN_GRUPPO); int c_app = pconti.get_int(PCN_CONTO); int s_app = pconti.get_int(PCN_SOTTOCONTO); pconti.readat(record); //Se sono nello stesso gruppo, ma ho un conto diverso da quello precedentemente //analizzato , allora devo controllare se va dettagliato //(STSOTTBIL) e in caso affermativo se ha almeno due sottoconti. if ((stsottbil)&&(g_app!=0)&&(c_app!=0)&&(s_app!=0)) { conto_dettagliato = TRUE; if ((let != "")||(numerorom != "")||(numero != 0)) { // if (sez == "") // sez_conto = "9"; // else sez_conto = sez; if (let != "") let_conto = let; else if ((sez == "1")||(sez == "2")) let_conto = "Z"; else let_conto = let; numr_conto = numerorom; num_conto = numero; classe_conto = TRUE; } else classe_conto = FALSE; } else conto_dettagliato = FALSE; } // Se si tratta di un sottoconto e contiene la classe, allora lo passo al sort. if (conto_dettagliato) { if ((g != 0) && (c != 0) && (s != 0)) { // int indbil = pconti.get_int(PCN_INDBIL); if (_tipo_stampa == 1) { if (!calcola(g,c,s,_data_fine_ese,_data_fine_ese_prec)) continue; // classe_conto indica se il conto precedentemente letto conteneva la classe, // ma quest' ultima non era presente a livello di gruppo. In caso affermativo // anche questo sottoconto appena letto avra' la stessa classe del conto. if (_dataini == _data_ini_ese) { sld_prg_dare = _saldo_ini_dare; sld_prg_avere = _saldo_ini_avere; mov_dare = _mov_periodo_dare; mov_avere = _mov_periodo_avere; saldo = sld_prg_dare-sld_prg_avere+mov_dare-mov_avere; } else if (_dataini > _data_ini_ese) { sld_prg_dare = _prg_prec_dare; sld_prg_avere = _prg_prec_avere; mov_dare = _mov_periodo_dare; mov_avere = _mov_periodo_avere; saldo = sld_prg_dare-sld_prg_avere+mov_dare-mov_avere; } } else if (_tipo_stampa == 2) { if (!_sld.calcola(_annoese,0,g,c,s,"","",indbil,FALSE,"","","",FALSE)) continue; app = _sld.saldoini(); if (app < ZERO) { app = -app; sld_prg_dare = ZERO; sld_prg_avere = app; } else { sld_prg_dare = app; sld_prg_avere = ZERO; } mov_dare = _sld.prgdare(); mov_avere = _sld.prgavere(); saldo = sld_prg_dare-sld_prg_avere+mov_dare-mov_avere; } else if (_tipo_stampa == 3) { if (!_sld.calcola (_annoese,_annoese-1,g,c,s,"","",indbil,FALSE,"","","",FALSE)) continue; sld_prg_dare = ZERO; sld_prg_avere = ZERO; mov_dare = _sld.prgdare(); mov_avere = _sld.prgavere(); saldo = mov_dare - mov_avere; } if (classe_conto) { riempi_record(sez_conto,let_conto,numr_conto,num_conto,g,c,s,saldo,ZERO,sld_prg_dare,sld_prg_avere,mov_dare,mov_avere,tmcf); saldo_conto += saldo; sld_prg_dare_conto += sld_prg_dare; sld_prg_avere_conto += sld_prg_avere; mov_dare_conto += mov_dare; mov_avere_conto += mov_avere; stamp_almeno_un_sottoc = TRUE; } else { if ((let != "")||(numerorom != "")||(numero != 0)) { // if (sez == "") // sez = "9"; scrivi_record(sez,let,numerorom,numero,g,c,s,saldo,ZERO,sld_prg_dare,sld_prg_avere,mov_dare,mov_avere,tmcf); stamp_almeno_un_sottoc = TRUE; } } } } } conto_prec = 0; if (conto_dettagliato) { if (stamp_almeno_un_sottoc) { if (classe_conto) { if (c != conto_prec && conto_prec != -1) { riempi_record(sez_conto,let_conto,numr_conto,num_conto,gruppo_prec,c,0,saldo_conto,ZERO,sld_prg_dare_conto,sld_prg_avere_conto,mov_dare_conto,mov_avere_conto,tmcf); saldo_conto = ZERO; sld_prg_dare_conto = ZERO; sld_prg_avere_conto = ZERO; mov_dare_conto = ZERO; mov_avere_conto = ZERO; classe_conto = FALSE; stamp_almeno_un_sottoc = FALSE; } } } } } bool CG1600_application::ricerca_sottoc_clifo(int g,int c,char tipocf,TString& sez,TString& let,TString& numerorom,int numero,int indbil) { long s; _listacf = new TClifo_list (g,c,tipocf); real saldo,sld_prg_dare,sld_prg_avere,mov_dare,mov_avere; real saldo_conto,sld_prg_dare_conto,sld_prg_avere_conto,mov_dare_conto,mov_avere_conto; real app; TString sez_conto,let_conto,numr_conto; int num_conto; saldo_conto = ZERO; sld_prg_dare_conto = ZERO; sld_prg_avere_conto = ZERO; mov_dare_conto = ZERO; mov_avere_conto = ZERO; int items = _listacf->items(); if (items >= 2) { sez_conto = sez; if (let != "") let_conto = let; else if ((sez == "1")||(sez == "2")) let_conto = "Z"; else let_conto = let; numr_conto = numerorom; num_conto = numero; for (int i=0 ; i < _listacf->items(); i++) { const TRectype& r=_listacf->clifo(i); s = r.get_long(CLI_CODCF); saldo = ZERO; sld_prg_dare = ZERO; sld_prg_avere = ZERO; mov_dare = ZERO; mov_avere = ZERO; app = ZERO; if (_tipo_stampa == 1) { if (!calcola(g,c,s,_data_fine_ese,_data_fine_ese_prec)) continue; if (_dataini == _data_ini_ese) { sld_prg_dare = _saldo_ini_dare; sld_prg_avere = _saldo_ini_avere; mov_dare = _mov_periodo_dare; mov_avere = _mov_periodo_avere; saldo = sld_prg_dare-sld_prg_avere+mov_dare-mov_avere; } else if (_dataini > _data_ini_ese) { sld_prg_dare = _prg_prec_dare; sld_prg_avere = _prg_prec_avere; mov_dare = _mov_periodo_dare; mov_avere = _mov_periodo_avere; saldo = sld_prg_dare-sld_prg_avere+mov_dare-mov_avere; } } else if (_tipo_stampa == 2) { if (!_sld.calcola (_annoese,0,g,c,s,"","",indbil,FALSE,"","","",FALSE)) continue; app = _sld.saldoini(); if (app < ZERO) { app = -app; sld_prg_dare = ZERO; sld_prg_avere = app; } else { sld_prg_dare = app; sld_prg_avere = ZERO; } mov_dare = _sld.prgdare(); mov_avere = _sld.prgavere(); saldo = sld_prg_dare-sld_prg_avere+mov_dare-mov_avere; } else if (_tipo_stampa == 3) { if (!_sld.calcola (_annoese,_annoese-1,g,c,s,"","",indbil,FALSE,"","","",FALSE)) continue; sld_prg_dare = ZERO; sld_prg_avere = ZERO; mov_dare = _sld.prgdare(); mov_avere = _sld.prgavere(); saldo = mov_dare - mov_avere; } riempi_record(sez_conto,let_conto,numr_conto,num_conto,g,c,s,saldo,ZERO,sld_prg_dare,sld_prg_avere,mov_dare,mov_avere,tipocf); saldo_conto += saldo; sld_prg_dare_conto += sld_prg_dare; sld_prg_avere_conto += sld_prg_avere; mov_dare_conto += mov_dare; mov_avere_conto += mov_avere; } riempi_record(sez_conto,let_conto,numr_conto,num_conto,g,c,0,saldo_conto,ZERO,sld_prg_dare_conto,sld_prg_avere_conto,mov_dare_conto,mov_avere_conto,tipocf); saldo_conto = ZERO; sld_prg_dare_conto = ZERO; sld_prg_avere_conto = ZERO; mov_dare_conto = ZERO; mov_avere_conto = ZERO; delete _listacf; return TRUE; } else return FALSE; } //La funzione calcola_saldo calcola il saldo dell'esercizio in corso e di //quello da raffrontare. Inoltre ritorna vero se il sottoconto e' movimentato //e falso se non e' movimentato, e quindi non deve essere stampato. bool CG1600_application::calcola_saldo(real& saldo, real& saldo_raf,int g,int c,long s,int indbil) { bool no_movimentato = TRUE; bool no_movimentato_raf = TRUE; if (_tipo_bilancio == 1) { if (_tipo_stampa == 1) //bilancio per data limite { if (!_sld.calcola (_annoese,0,g,c,s,_datai,_datalimite,indbil,_competenza,_data_ini_ese,_data_fine_ese,_data_fine_ese_prec,_stampa_mov_prov)) no_movimentato = TRUE; else no_movimentato = FALSE; } else if (_tipo_stampa == 2) { if (!_sld.calcola (_annoese,0,g,c,s,"","",indbil,FALSE,"","","",FALSE)) no_movimentato = TRUE; else no_movimentato = FALSE; } else if (_tipo_stampa == 3) { if (!_sld.calcola (_annoese,_annoese-1,g,c,s,"","",indbil,FALSE,"","","",FALSE)) no_movimentato = TRUE; else no_movimentato = FALSE; } saldo = _sld.saldo(); if (_annoeserafr != 0) { if (_tipo_stampa == 1) //bilancio per data limite { if (!_sld.calcola (_annoeserafr,0,g,c,s,_datairaf,_databilrafr,indbil,_competenza,_data_fine_raf,_data_fine_raf_prec,"",_stampa_mov_prov)) no_movimentato_raf = TRUE; else no_movimentato_raf = FALSE; } else if (_tipo_stampa == 2) { if (!_sld.calcola (_annoeserafr,0,g,c,s,"","",indbil,FALSE,"","","",FALSE)) no_movimentato_raf = TRUE; else no_movimentato_raf = FALSE; } else if (_tipo_stampa == 3) { if (!_sld.calcola (_annoeserafr,_annoeserafr-1,g,c,s,"","",indbil,FALSE,"","","",FALSE)) no_movimentato_raf = TRUE; else no_movimentato_raf = FALSE; } saldo_raf = _sld.saldo(); } } if ((no_movimentato) && (no_movimentato_raf)) return FALSE; else return TRUE; } bool CG1600_application::calcola(int g, int c, long s, const TDate& fine_es, const TDate& fine_es_prec) { TString sezione; real importo; int annoe; long num_reg; TDate data_rmv; bool conto_mov = FALSE; TLocalisamfile rmov(LF_RMOV); TLocalisamfile mov(LF_MOV); _mov_periodo_dare = ZERO; _mov_periodo_avere = ZERO; _prg_prec_dare = ZERO; _prg_prec_avere = ZERO; _saldo_ini_dare = ZERO; _saldo_ini_avere = ZERO; rmov.setkey(2); rmov.zero(); rmov.put(RMV_GRUPPO,g); if (c != 0) rmov.put(RMV_CONTO,c); if (s != 0) rmov.put(RMV_SOTTOCONTO,s); TRectype rec(rmov.curr()); rmov.read(_isgteq); for ( ; !rmov.eof(); rmov.next()) { if (rmov.curr() != rec) break; annoe = rmov.get_int(RMV_ANNOES); data_rmv = rmov.get_date(RMV_DATAREG); num_reg = rmov.get_long(RMV_NUMREG); sezione = rmov.get(RMV_SEZIONE); importo = rmov.get_real(RMV_IMPORTO); if ((annoe != _annoese && annoe != _annoese - 1) || (importo == ZERO)) continue; mov.setkey(1); mov.zero(); mov.put(MOV_NUMREG, num_reg); mov.read(); if (mov.bad()) mov.zero(); const bool movprovv = mov.get(MOV_PROVVIS).not_empty(); if (!_stampa_mov_prov && movprovv) //se non richiesto continue; //stampa mov provv. //li scarto const TString codcaus(mov.get(MOV_CODCAUS)); if (codcaus == causale_chiusura()) //la causale e' uguale a quella di chiusura break; if (_competenza) if (annoe == _annoese -1) if (_datafine == fine_es) if ( ((data_rmv > fine_es) || (data_rmv > fine_es_prec)) && (data_rmv <= fine_es) ) //viene stampato tra i mov del periodo { if (sezione == "D") _mov_periodo_dare += importo; else _mov_periodo_avere += importo; } //calcolo i movimenti del periodo if ( (data_rmv >= _dataini) && (data_rmv <= _datafine) ) if ((codcaus == causale_apertura() && _data_ini_ese != _dataini) || (codcaus != causale_apertura())) { conto_mov = TRUE; if (sezione == "D") _mov_periodo_dare += importo; else _mov_periodo_avere += importo; } //il saldo inizio es. e' dato dall'importo dare - importo avere di quei movimenti che hanno causale == apertura e data reg >= data inizio es. e <= data limite sup. if (_dataini == _data_ini_ese) //calcolo il saldo iniziale { if (codcaus == causale_apertura()) { if (sezione == "D") _saldo_ini_dare += importo; else _saldo_ini_avere += importo; conto_mov = TRUE; } } else if (_dataini > _data_ini_ese) //calcolo i progressivi precedenti if ( (data_rmv >= _data_ini_ese) && (data_rmv < _dataini) ) { if (sezione == "D") _prg_prec_dare += importo; else _prg_prec_avere += importo; conto_mov = TRUE; } } return conto_mov; } bool CG1600_application::set_print(int) { KEY tasto; // if (_sort) delete _sort; // if (_bil) delete _bil; { TConfig conf(CONFIG_DITTA); _causale_ap = conf.get("CoCaCh"); _causale_chi = conf.get("CoCaCh"); } _msk->set_handler(F_DATALIM, our_handler); _msk->set_handler(F_DATABILRAF, our_handler); _msk->set_handler(F_DATAINI, our_handler); _msk->set_handler(F_DATAFINE, our_handler); tasto = _msk->run(); if (tasto == K_ENTER) { _datastampa = (_msk->get(F_DATASTAMPA)); _competenza = (bool)(_msk->get(F_COMPETENZA) == "X"); _annoese = _msk->get_int(F_ANNOESE); _annoeserafr = _msk->get_int(F_ANNORAFFR); _intera_struttura = (bool)(_msk->get(F_STAMPAINT) == "X"); _stampamov = (bool)(_msk->get(F_STAMPAMOV) == "X"); _stampacod = (bool)(_msk->get(F_STAMPACOD) == "X"); _stampa_modulo = (bool)(_msk->get(F_STAMPAMODULO) == "X"); _tipo_bilancio = atoi(_msk->get(F_TIPOBIL)); _stampa_mov_prov = (bool)(_msk->get(F_STAMPAMOVPROV) == "X"); if (_tipo_bilancio == 1) { _tipo_stampa = atoi(_msk->get(F_TIPOSTAMPA)); _prog = new TProgind(_pconti->items(),"Elaborazione in corso... prego attendere",FALSE); } else if (_tipo_bilancio == 2) { _tipo_stampa = atoi(_msk->get(F_TIPOSTAMPA1)); _prog = new TProgind(_pconti->items(),"Elaborazione in corso... prego attendere",FALSE); } _datalimite = _msk->get(F_DATALIM); _databilrafr = _msk->get(F_DATABILRAF); _dataini = _msk->get(F_DATAINI); _datafine = _msk->get(F_DATAFINE); _cont_let = 0; _cont_numr = 0; _cont_num = 0; _cont_gcs = 0; _reset_righe_stampa = TRUE; set_real_picture("###.###.###.###"); set_print_zero(); _totale_attivita_gia_stampato = FALSE; _totale_passivita_gia_stampato = FALSE; _statopatr_no_stamp = TRUE; _sez_stamp = ' '; _let_stamp = ' '; _numr_stamp = ""; _num_stamp = ""; _sez_tot = ' '; _let_tot = ' '; _numr_tot = ""; _num_tot = ""; _datai = data_inferiore(); _datairaf = data_inferiore_raf(); crea_sort_tabella(); if (_tipo_bilancio == 1) crea_sort_piano_conti_scalare(); else if (_tipo_bilancio == 2) crea_sort_piano_conti_verifica(); _sort->endsort(); crea_intestazione(); delete _bil; delete _prog; return TRUE; } return FALSE; } void CG1600_application::stampa_totali() { bool gia_stampato_conto_ord = FALSE; _num = _num_tot; _numr = _numr_tot; _let = _let_tot; if (_buff == NULL) { _num_tot = ""; _numr_tot = ""; _let_tot = ' '; _sez_tot = ' '; } if (_num_da_stamp!=_num_tot) { if (_let_stamp != 'Z') { if (_sez_stamp != '5') if (_cont_gcs >= 2) { //Fai il totale del numero arabo e stampalo set_row (_i,"@18gTotale@25g%s@27g)",(const char*) _num); set_row (_i++,"@86g%r", &_totale_numero); } } _cont_gcs = 0; _totale_numero = 0; } if (_numr_da_stamp!=_numr_tot) { if (_let_stamp != 'Z') { if (_sez_stamp != '5') { if (_cont_gcs >= 2) { //Fai il totale del numero arabo e stampalo set_row (_i,"@18gTotale@25g%s@27g)",(const char*) _num); set_row (_i++,"@86g%r", &_totale_numero); } if (_cont_num >= 2) { //Fai il totale del numero romano e stampalo int numeror = atoi(_numr); TString numrom = itor(numeror); set_row (_i,"@14gTotale@21g%s", (const char*) numrom); set_row (_i++,"@86g%r", &_totale_numr); } } } _cont_gcs = 0; _cont_num = 0; _totale_numero = 0; _totale_numr = 0; } if (_let_da_stamp!=_let_tot) { if (_let_stamp != 'Z') { if (_sez_stamp != '5') { if (_cont_gcs >= 2) { //Fai il totale del numero arabo e stampalo set_row (_i,"@18gTotale@25g%s@27g)",(const char*) _num); set_row (_i++,"@86g%r", &_totale_numero); } if (_cont_num >= 2) { //Fai il totale del numero romano e stampalo int numeror = atoi(_numr); TString numrom = itor(numeror); set_row (_i,"@14gTotale@21g%s", (const char*) numrom); set_row (_i++,"@86g%r", &_totale_numr); } if (_cont_numr >= 2) { //Fai il totale della lettera e stampalo set_row (_i,"@3gTotale@10g%c@12g)", _let); set_row (_i++,"@86g%r", &_totale_lettera); } } } if ((_sez_stamp == '1')&&(_let_da_stamp == 'Z')) { char app = ' '; set_row (_i++,"@0g%c", app); set_row (_i,"@0gTOTALE ATTIVITA'"); set_row (_i++,"@86g%r", &_totale_sezione); _totale_attivita = _totale_sezione; _totale_sezione = 0; _totale_attivita_gia_stampato = TRUE; } if ((_sez_stamp == '2')&&(_let_da_stamp == 'Z')) { char app = ' '; set_row (_i++,"@0g%c", app); set_row (_i,"@0gTOTALE PASSIVITA'"); set_row (_i++,"@86g%r", &_totale_sezione); _totale_passivita = _totale_sezione; _totale_sezione = 0; _totale_passivita_gia_stampato = TRUE; } if ((_sez_stamp == '1')&&(_let_stamp == 'Z')) { char app = ' '; set_row (_i++,"@0g%c", app); set_row (_i,"@0gTOTALE CONTI D' ORDINE ATTIVI"); set_row (_i++,"@86g%r", &_totale_ordine_attivo); _totale_ordine_attivo = 0; gia_stampato_conto_ord = TRUE; } if ((_sez_stamp == '2')&&(_let_stamp == 'Z')) { char app = ' '; set_row (_i++,"@0g%c", app); set_row (_i,"@0gTOTALE CONTI D' ORDINE PASSIVI"); set_row (_i++,"@86g%r", &_totale_ordine_passivo); _totale_ordine_passivo = 0; gia_stampato_conto_ord = TRUE; } _cont_gcs = 0; _cont_num = 0; _cont_numr = 0; _totale_numero = 0; _totale_numr = 0; _totale_lettera = 0; } if (_sez_da_stamp != _sez_tot) { if (_let_stamp != 'Z') { if (_sez_stamp != '5') { if (_cont_gcs >= 2) { //Fai il totale del numero arabo e stampalo set_row (_i,"@18gTotale@25g%s@27g)",(const char*) _num); set_row (_i++,"@86g%r", &_totale_numero); } if (_cont_num >= 2) { //Fai il totale del numero romano e stampalo int numeror = atoi(_numr); TString numrom = itor(numeror); set_row (_i,"@14gTotale@21g%s", (const char*) numrom); set_row (_i++,"@86g%r", &_totale_numr); } if (_cont_numr >= 2) { //Fai il totale della lettera e stampalo set_row (_i,"@3gTotale@10g%c@12g)", _let); set_row (_i++,"@86g%r", &_totale_lettera); } } } if (!_totale_attivita_gia_stampato) if ((_sez_stamp == '1') && (_let_stamp != 'Z')) { char app = ' '; set_row (_i++,"@0g%c", app); set_row (_i,"@0gTOTALE ATTIVITA'"); set_row (_i++,"@86g%r", &_totale_sezione); _totale_attivita = _totale_sezione; _totale_sezione = 0; } if (!_totale_passivita_gia_stampato) if ((_sez_stamp == '2') && (_let_stamp != 'Z')) { char app = ' '; set_row (_i++,"@0g%c", app); set_row (_i,"@0gTOTALE PASSIVITA'"); set_row (_i++,"@86g%r", &_totale_sezione); _totale_passivita = _totale_sezione; _totale_sezione = 0; } if (!gia_stampato_conto_ord) { if ((_sez_stamp == '1')&&(_let_stamp == 'Z')) { char app = ' '; set_row (_i++,"@0g%c", app); set_row (_i,"@0gTOTALE CONTI D' ORDINE ATTIVI"); set_row (_i++,"@86g%r", &_totale_ordine_attivo); _totale_ordine_attivo = 0; } if ((_sez_stamp == '2')&&(_let_stamp == 'Z')) { char app = ' '; set_row (_i++,"@0g%c", app); set_row (_i,"@0gTOTALE CONTI D' ORDINE PASSIVI"); set_row (_i++,"@86g%r", &_totale_ordine_passivo); _totale_ordine_passivo = 0; } } if (_sez_stamp == '2') { char app = ' '; set_row (_i++,"@0g%c", app); set_row (_i++,"@0gSALDO STATO PATRIMONIALE"); set_row (_i,"@0gSBILANCIO (ATTIVITA' - PASSIVITA')"); _totale_patrimoniale = _totale_attivita - _totale_passivita; set_row (_i++,"@86g%r", &_totale_patrimoniale); _totale_patrimoniale = 0; } if (_sez_stamp == '5') { char app = ' '; set_row (_i++,"@0g%c", app); set_row (_i,"@0gTOTALE CONTI D' ORDINE"); set_row (_i++,"@86g%r", &_totale_ordine); _totale_ordine = 0; } if (_sez_stamp == '9') { char app = ' '; set_row (_i++,"@0g%c", app); set_row (_i,"@0gTOTALE CONTO ECONOMICO"); set_row (_i++,"@86g%r", &_totale_economico); _totale_economico = 0; } _cont_gcs = 0; _cont_num = 0; _cont_numr = 0; _cont_let = 0; _totale_numero = 0; _totale_numr = 0; _totale_lettera = 0; } } void CG1600_application::stampa_totali_con_raffronto() { bool gia_stampato_conto_ord = FALSE; _num = _num_tot; _numr = _numr_tot; _let = _let_tot; if (_buff == NULL) { _num_tot = ""; _numr_tot = ""; _let_tot = ' '; _sez_tot = ' '; } if (_num_da_stamp!=_num_tot) { if (_let_stamp != 'Z') { if (_sez_stamp != '5') if (_cont_gcs >= 2) { //Fai il totale del numero arabo e stampalo set_row (_i,"@18gTotale@25g%s@27g)",(const char*) _num); set_row (_i,"@86g%r", &_totale_numero); set_row (_i++,"@112g%r", &_totale_num_raf); } } _cont_gcs = 0; _totale_numero = 0; _totale_num_raf = 0; } if (_numr_da_stamp!=_numr_tot) { if (_let_stamp != 'Z') { if (_sez_stamp != '5') { if (_cont_gcs >= 2) { //Fai il totale del numero arabo e stampalo set_row (_i,"@18gTotale@25g%s@27g)",(const char*) _num); set_row (_i,"@86g%r", &_totale_numero); set_row (_i++,"@112g%r", &_totale_num_raf); } if (_cont_num >= 2) { //Fai il totale del numero romano e stampalo int numeror = atoi(_numr); TString numrom = itor(numeror); set_row (_i,"@14gTotale@21g%s", (const char*) numrom); set_row (_i,"@86g%r", &_totale_numr); set_row (_i++,"@112g%r", &_totale_numr_raf); } } } _cont_gcs = 0; _cont_num = 0; _totale_numero = 0; _totale_numr = 0; _totale_num_raf = 0; _totale_numr_raf = 0; } if (_let_da_stamp!=_let_tot) { if (_let_stamp != 'Z') { if (_sez_stamp != '5') { if (_cont_gcs >= 2) { //Fai il totale del numero arabo e stampalo set_row (_i,"@18gTotale@25g%s@27g)",(const char*) _num); set_row (_i,"@86g%r", &_totale_numero); set_row (_i++,"@112g%r", &_totale_num_raf); } if (_cont_num >= 2) { //Fai il totale del numero romano e stampalo int numeror = atoi(_numr); TString numrom = itor(numeror); set_row (_i,"@14gTotale@21g%s", (const char*) numrom); set_row (_i,"@86g%r", &_totale_numr); set_row (_i++,"@112g%r", &_totale_numr_raf); } if (_cont_numr >= 2) { //Fai il totale della lettera e stampalo set_row (_i,"@3gTotale@10g%c@12g)", _let); set_row (_i,"@86g%r", &_totale_lettera); set_row (_i++,"@112g%r", &_totale_let_raf); } } } if ((_sez_stamp == '1')&&(_let_da_stamp == 'Z')) { char app = ' '; set_row (_i++,"@0g%c", app); set_row (_i,"@0gTOTALE ATTIVITA'"); set_row (_i,"@86g%r", &_totale_sezione); set_row (_i++,"@112g%r", &_totale_sez_raf); _totale_attivita = _totale_sezione; _totale_attiv_raf = _totale_sez_raf; _totale_sezione = 0; _totale_sez_raf = 0; _totale_attivita_gia_stampato = TRUE; } if ((_sez_stamp == '2')&&(_let_da_stamp == 'Z')) { char app = ' '; set_row (_i++,"@0g%c", app); set_row (_i,"@0gTOTALE PASSIVITA'"); set_row (_i,"@86g%r", &_totale_sezione); set_row (_i++,"@112g%r", &_totale_sez_raf); _totale_passivita = _totale_sezione; _totale_passiv_raf = _totale_sez_raf; _totale_sezione = 0; _totale_sez_raf = 0; _totale_passivita_gia_stampato = TRUE; } if ((_sez_stamp == '1')&&(_let_stamp == 'Z')) { char app = ' '; set_row (_i++,"@0g%c", app); set_row (_i,"@0gTOTALE CONTI D' ORDINE ATTIVI"); set_row (_i,"@86g%r", &_totale_ordine_attivo); set_row (_i++,"@112g%r", &_totale_ordine_attivo_raf); _totale_ordine_attivo = 0; _totale_ordine_attivo_raf = 0; gia_stampato_conto_ord = TRUE; } if ((_sez_stamp == '2')&&(_let_stamp == 'Z')) { char app = ' '; set_row (_i++,"@0g%c", app); set_row (_i,"@0gTOTALE CONTI D' ORDINE PASSIVI"); set_row (_i,"@86g%r", &_totale_ordine_passivo); set_row (_i++,"@112g%r", &_totale_ordine_passivo_raf); _totale_ordine_passivo = 0; _totale_ordine_passivo_raf = 0; gia_stampato_conto_ord = TRUE; } _cont_gcs = 0; _cont_num = 0; _cont_numr = 0; _totale_numero = 0; _totale_numr = 0; _totale_lettera = 0; _totale_num_raf = 0; _totale_numr_raf = 0; _totale_let_raf = 0; } if (_sez_da_stamp != _sez_tot) { if (_let_stamp != 'Z') { if (_sez_stamp != '5') { if (_cont_gcs >= 2) { //Fai il totale del numero arabo e stampalo set_row (_i,"@18gTotale@25g%s@27g)",(const char*) _num); set_row (_i,"@86g%r", &_totale_numero); set_row (_i++,"@112g%r", &_totale_num_raf); } if (_cont_num >= 2) { //Fai il totale del numero romano e stampalo int numeror = atoi(_numr); TString numrom = itor(numeror); set_row (_i,"@14gTotale@21g%s", (const char*) numrom); set_row (_i++,"@86g%r", &_totale_numr); set_row (_i++,"@112g%r", &_totale_numr_raf); } if (_cont_numr >= 2) { //Fai il totale della lettera e stampalo set_row (_i,"@3gTotale@10g%c@12g)", _let); set_row (_i++,"@86g%r", &_totale_lettera); set_row (_i++,"@112g%r", &_totale_let_raf); } } } if (!_totale_attivita_gia_stampato) if ((_sez_stamp == '1') && (_let_stamp != 'Z')) { char app = ' '; set_row (_i++,"@0g%c", app); set_row (_i,"@0gTOTALE ATTIVITA'"); set_row (_i,"@86g%r", &_totale_sezione); set_row (_i++,"@112g%r", &_totale_sez_raf); _totale_attivita = _totale_sezione; _totale_attiv_raf = _totale_sez_raf; _totale_sezione = 0; _totale_sez_raf = 0; _totale_attivita_gia_stampato = TRUE; } if (!_totale_passivita_gia_stampato) if ((_sez_stamp == '2') && (_let_stamp != 'Z')) { char app = ' '; set_row (_i++,"@0g%c", app); set_row (_i,"@0gTOTALE PASSIVITA'"); set_row (_i,"@86g%r", &_totale_sezione); set_row (_i++,"@112g%r", &_totale_sez_raf); _totale_passivita = _totale_sezione; _totale_passiv_raf = _totale_sez_raf; _totale_sezione = 0; _totale_sez_raf = 0; _totale_passivita_gia_stampato = TRUE; } if (!gia_stampato_conto_ord) { if ((_sez_stamp == '1')&&(_let_stamp == 'Z')) { char app = ' '; set_row (_i++,"@0g%c", app); set_row (_i,"@0gTOTALE CONTI D' ORDINE ATTIVI"); set_row (_i++,"@86g%r", &_totale_ordine_attivo); _totale_ordine_attivo = 0; } if ((_sez_stamp == '2')&&(_let_stamp == 'Z')) { char app = ' '; set_row (_i++,"@0g%c", app); set_row (_i,"@0gTOTALE CONTI D' ORDINE PASSIVI"); set_row (_i++,"@86g%r", &_totale_ordine_passivo); _totale_ordine_passivo = 0; } } if (_sez_stamp == '2') { char app = ' '; set_row (_i++,"@0g%c", app); set_row (_i++,"@0gSALDO STATO PATRIMONIALE"); set_row (_i,"@0gSBILANCIO (ATTIVITA' - PASSIVITA')"); _totale_patrimoniale = _totale_attivita - _totale_passivita; _totale_patrim_raf = _totale_attiv_raf - _totale_passiv_raf; set_row (_i,"@86g%r", &_totale_patrimoniale); set_row (_i++,"@112g%r", &_totale_patrim_raf); _totale_patrimoniale = 0; _totale_patrim_raf = 0; } if (_sez_stamp == '5') { char app = ' '; set_row (_i++,"@0g%c", app); set_row (_i,"@0gTOTALE CONTI D' ORDINE"); set_row (_i,"@86g%r", &_totale_ordine); set_row (_i++,"@112g%r", &_totale_ordine_raf); _totale_ordine = 0; _totale_ordine_raf = 0; } if (_sez_stamp == '9') { char app = ' '; set_row (_i++,"@0g%c", app); set_row (_i,"@0gTOTALE CONTO ECONOMICO"); set_row (_i,"@86g%r", &_totale_economico); set_row (_i++,"@112g%r", &_totale_economico_raf); _totale_economico = 0; _totale_economico_raf = 0; } _cont_gcs = 0; _cont_num = 0; _cont_numr = 0; _cont_let = 0; _totale_numero = 0; _totale_numr = 0; _totale_lettera = 0; _totale_num_raf = 0; _totale_numr_raf = 0; _totale_let_raf = 0; } } void CG1600_application::stampa_totali_verifica() { _num = _num_tot; _numr = _numr_tot; _let = _let_tot; _sez = _sez_tot; if (_buff == NULL) { _num_tot = ""; _numr_tot = ""; _let_tot = ' '; _sez_tot = ' '; } if (_num_da_stamp!=_num_tot) { if (_cont_gcs >= 2) { //Fai il totale del numero arabo e stampalo if (((_sez == '1')||(_sez == '2')||(_sez == '9'))&&(_let != 'Z')) { set_row (_i,"@8gTotale@15g%s@17g)",(const char*) _num); } else set_row (_i,"@8gTotale"); set_row (_i,"@49g%r", &_tot_num_prg_d); set_row (_i,"@65g%r", &_tot_num_prg_a); set_row (_i,"@82g%r", &_tot_num_mov_d); set_row (_i,"@98g%r", &_tot_num_mov_a); if (!_stampa_modulo) { if (_tot_num_saldo < ZERO) { _tot_num_saldo = -_tot_num_saldo; _tot_sez_saldo = 'A'; } else _tot_sez_saldo = 'D'; stampa_saldo_132(_tot_num_saldo); } else { stampa_saldo_198(_tot_num_saldo_d,_tot_num_saldo_a); // _tot_num_saldo_d = 0; // _tot_num_saldo_a = 0; } } _cont_gcs = 0; _tot_num_prg_d = ZERO; _tot_num_prg_a = ZERO; _tot_num_mov_d = ZERO; _tot_num_mov_a = ZERO; _tot_num_saldo = ZERO; } if (_numr_da_stamp!=_numr_tot) { if (_cont_gcs >= 2) { //Fai il totale del numero arabo e stampalo if (((_sez == '1')||(_sez == '2')||(_sez == '9'))&&(_let != 'Z')) { set_row (_i,"@8gTotale@15g%s@17g)",(const char*) _num); } else set_row (_i,"@8gTotale"); set_row (_i,"@49g%r", &_tot_num_prg_d); set_row (_i,"@65g%r", &_tot_num_prg_a); set_row (_i,"@82g%r", &_tot_num_mov_d); set_row (_i,"@98g%r", &_tot_num_mov_a); if (!_stampa_modulo) { if (_tot_num_saldo < ZERO) { _tot_num_saldo = -_tot_num_saldo; _tot_sez_saldo = 'A'; } else _tot_sez_saldo = 'D'; stampa_saldo_132(_tot_num_saldo); } else { stampa_saldo_198(_tot_num_saldo_d,_tot_num_saldo_a); //_tot_num_saldo_d = 0; //_tot_num_saldo_a = 0; } } if (_cont_num >= 2) { //Fai il totale del numero romano e stampalo int numeror = atoi(_numr); TString numrom = itor(numeror); set_row (_i,"@8gTotale@15g%s", (const char*) numrom); set_row (_i,"@49g%r", &_tot_numr_prg_d); set_row (_i,"@65g%r", &_tot_numr_prg_a); set_row (_i,"@82g%r", &_tot_numr_mov_d); set_row (_i,"@98g%r", &_tot_numr_mov_a); if (!_stampa_modulo) { if (_tot_numr_saldo < ZERO) { _tot_numr_saldo = -_tot_numr_saldo; _tot_sez_saldo = 'A'; } else _tot_sez_saldo = 'D'; stampa_saldo_132(_tot_numr_saldo); } else { stampa_saldo_198(_tot_numr_saldo_d,_tot_numr_saldo_a); // _tot_numr_saldo_d = 0; // _tot_numr_saldo_a = 0; } } _cont_gcs = 0; _cont_num = 0; _tot_num_prg_d = ZERO; _tot_num_prg_a = ZERO; _tot_num_mov_d = ZERO; _tot_num_mov_a = ZERO; _tot_num_saldo = ZERO; _tot_numr_prg_d = ZERO; _tot_numr_prg_a = ZERO; _tot_numr_mov_d = ZERO; _tot_numr_mov_a = ZERO; _tot_numr_saldo = ZERO; } if ((_let_da_stamp!=_let_tot) || (_sez_da_stamp != _sez_tot)) { if (_cont_gcs >= 2) { //Fai il totale del numero arabo e stampalo if (((_sez == '1')||(_sez == '2')||(_sez == '9'))&&(_let != 'Z')) { set_row (_i,"@8gTotale@15g%s@17g)",(const char*) _num); } else set_row (_i,"@8gTotale"); set_row (_i,"@49g%r", &_tot_num_prg_d); set_row (_i,"@65g%r", &_tot_num_prg_a); set_row (_i,"@82g%r", &_tot_num_mov_d); set_row (_i,"@98g%r", &_tot_num_mov_a); if (!_stampa_modulo) { if (_tot_num_saldo < ZERO) { _tot_num_saldo = -_tot_num_saldo; _tot_sez_saldo = 'A'; } else _tot_sez_saldo = 'D'; stampa_saldo_132(_tot_num_saldo); } else { stampa_saldo_198(_tot_num_saldo_d,_tot_num_saldo_a); // _tot_num_saldo_d = 0; // _tot_num_saldo_a = 0; } } if (_cont_num >= 2) { //Fai il totale del numero romano e stampalo int numeror = atoi(_numr); TString numrom = itor(numeror); set_row (_i,"@8gTotale@15g%s", (const char*) numrom); set_row (_i,"@49g%r", &_tot_numr_prg_d); set_row (_i,"@65g%r", &_tot_numr_prg_a); set_row (_i,"@82g%r", &_tot_numr_mov_d); set_row (_i,"@98g%r", &_tot_numr_mov_a); if (!_stampa_modulo) { if (_tot_numr_saldo < ZERO) { _tot_numr_saldo = -_tot_numr_saldo; _tot_sez_saldo = 'A'; } else _tot_sez_saldo = 'D'; stampa_saldo_132(_tot_numr_saldo); } else { stampa_saldo_198(_tot_numr_saldo_d,_tot_numr_saldo_a); // _tot_numr_saldo_d = 0; // _tot_numr_saldo_a = 0; } } if (_cont_numr >= 2) { //Fai il totale della lettera e stampalo set_row (_i,"@8gTotale@15g%c@16g)", _let); set_row (_i,"@49g%r", &_tot_let_prg_d); set_row (_i,"@65g%r", &_tot_let_prg_a); set_row (_i,"@82g%r", &_tot_let_mov_d); set_row (_i,"@98g%r", &_tot_let_mov_a); if (!_stampa_modulo) { if (_tot_let_saldo < ZERO) { _tot_let_saldo = -_tot_let_saldo; _tot_sez_saldo = 'A'; } else _tot_sez_saldo = 'D'; stampa_saldo_132(_tot_let_saldo); } else { stampa_saldo_198(_tot_let_saldo_d,_tot_let_saldo_a); // _tot_let_saldo_d = 0; // _tot_let_saldo_a = 0; } } _cont_gcs = 0; _cont_num = 0; _cont_numr = 0; _tot_num_prg_d = ZERO; _tot_num_prg_a = ZERO; _tot_num_mov_d = ZERO; _tot_num_mov_a = ZERO; _tot_num_saldo = ZERO; _tot_numr_prg_d = ZERO; _tot_numr_prg_a = ZERO; _tot_numr_mov_d = ZERO; _tot_numr_mov_a = ZERO; _tot_numr_saldo = ZERO; _tot_let_prg_d = ZERO; _tot_let_prg_a = ZERO; _tot_let_mov_d = ZERO; _tot_let_mov_a = ZERO; _tot_let_saldo = ZERO; } } void CG1600_application::stampa_saldo_198(real& saldo_d,real& saldo_a) { set_row (_i,"@115g%r", &saldo_d); set_row (_i,"@48g|@81g|@114g|@131g|"); set_row (_i,"@133g%r", &saldo_a); set_row (_i++,"@48g|@81g|@114g|@131g|"); saldo_d = real(ZERO); saldo_a = real(ZERO); } void CG1600_application::stampa_saldo_132(const real& saldo) { set_row (_i,"@115g%r", &saldo); set_row (_i,"@48g|@81g|@114g|"); set_row (_i++,"@131g%c", _tot_sez_saldo); } print_action CG1600_application::postprocess_page(int file, int counter) { if (_tipo_bilancio == 1) { if (_sez_da_stamp != _sez_stamp) { if (_sez_da_stamp == '5') { reset_print(); _i = 1; setta_righe("CONTI D' ORDINE"); _reset_righe_stampa = FALSE; } if (_sez_da_stamp == '9') { reset_print(); _i = 1; setta_righe("CONTO ECONOMICO"); _reset_righe_stampa = FALSE; } } set_auto_ff(FALSE); } if (_buff == NULL) return NEXT_PAGE; _sale = 0; _salerafr = 0; return REPEAT_PAGE; } bool CG1600_application::preprocess_page(int file, int counter) { if (_tipo_bilancio == 1) { if (preprocess_stampa_scalare(counter)) return TRUE; else return FALSE; } else if (_tipo_bilancio == 2) { if (preprocess_stampa_verifica(counter)) return TRUE; else return FALSE; } return TRUE; } bool CG1600_application::preprocess_stampa_scalare(int counter) { struct bil_ivd* bil = (struct bil_ivd*) _buff; int g,c; long s; bool fai = TRUE; if (!counter) { reset_print(); _i = 1; } if (_reset_righe_stampa) { reset_print(); _i = 1; } else _reset_righe_stampa = TRUE; if (counter) { if (!_intera_struttura) { if (bil->gruppo[0] != 'Z') { _sez_stamp = bil->sez; _let_stamp = bil->let; _numr_stamp = bil->numr; _numr_stamp.ltrim(); _num_stamp = bil->num; _num_stamp.ltrim(); _sez_tot = bil->sez; _let_tot = bil->let; _numr_tot = bil->numr; _numr_tot.ltrim(); _num_tot = bil->num; _num_tot.ltrim(); } } else { _classe_stampata = format ("%1c%1c%8s%2d",bil->sez,bil->let,(const char*) bil->numr,bil->num); _sez_stamp = bil->sez; _let_stamp = bil->let; _numr_stamp = bil->numr; _numr_stamp.ltrim(); _num_stamp = bil->num; _num_stamp.ltrim(); _sez_tot = bil->sez; _let_tot = bil->let; _numr_tot = bil->numr; _numr_tot.ltrim(); _num_tot = bil->num; _num_tot.ltrim(); } } _buff = _sort->retrieve(); if (_buff == NULL) { if (_annoeserafr == 0) stampa_totali(); else stampa_totali_con_raffronto(); _sez_da_stamp = ' '; _sez_stamp = ' '; return TRUE; } if (_buff != NULL) { bil = (struct bil_ivd*) _buff; _classe_da_stampare = format ("%1c%1c%8s%2d",bil->sez,bil->let,(const char*) bil->numr,bil->num); _sez_da_stamp = bil->sez; _let_da_stamp = bil->let; _numr_da_stamp = bil->numr; _numr_da_stamp.ltrim(); _num_da_stamp = bil->num; _num_da_stamp.ltrim(); g = atoi(bil->gruppo); c = atoi(bil->conto); s = atol(bil->sottoc); if (_intera_struttura) fai = TRUE; else { if (bil->gruppo[0] != 'Z') fai = TRUE; else fai = FALSE; } if (counter) { if (fai) if (_annoeserafr == 0) stampa_totali(); else stampa_totali_con_raffronto(); } //Fare ricerca di dataregmov if (!_intera_struttura) { if (bil->gruppo[0]=='Z') return FALSE; _sale = bil->saldo; if (_annoeserafr != 0) _salerafr = bil->saldorafr; if (_stampamov) { if (_annoeserafr != 0) { if ((_sale.is_zero()) && (_salerafr.is_zero())) return FALSE; } else if (_sale.is_zero()) return FALSE; } } else { if (bil->gruppo[0]=='Z') { if (_classe_da_stampare != _classe_stampata) { sprintf (bil->gruppo,"%s", " "); sprintf (bil->conto ,"%s", " "); sprintf (bil->sottoc,"%s", " "); } else return FALSE; } _sale = bil->saldo; if (_annoeserafr != 0) _salerafr = bil->saldorafr; if (_stampamov) { if (_annoeserafr != 0) { if ((_sale.is_zero()) && (_salerafr.is_zero())) return FALSE; } else { if (_sale.is_zero()) return FALSE; } } } if ((g != 0) && (c != 0) && (s != 0)) { if (_sez_da_stamp == '5') if (_sale < ZERO) _sale = -_sale; if (_sez_da_stamp == '9') if (_sale> ZERO) _sale = -_sale; _totale_numero += _sale; _totale_numr += _sale; _totale_lettera += _sale; if ((_sez_da_stamp == '1')||(_sez_da_stamp == '2')) { if (_let_da_stamp != 'Z') _totale_sezione += _sale; else { if (_sez_da_stamp == '1') _totale_ordine_attivo += _sale; else if (_sez_da_stamp == '2') _totale_ordine_passivo += _sale; } } if (_sez_da_stamp == '5') _totale_ordine += _sale; if (_sez_da_stamp == '9') _totale_economico += _sale; if (_annoeserafr != 0) { if (_sez_da_stamp == '5') if (_salerafr < ZERO) _salerafr = -_salerafr; if (_sez_da_stamp == '9') if (_salerafr> ZERO) _salerafr = -_salerafr; _totale_num_raf += _salerafr; _totale_numr_raf += _salerafr; _totale_let_raf += _salerafr; if ((_sez_da_stamp == '1')||(_sez_da_stamp == '2')) { if (_let_da_stamp != 'Z') _totale_sez_raf += _salerafr; else { if (_sez_da_stamp == '1') _totale_ordine_attivo_raf += _salerafr; else if (_sez_da_stamp == '2') _totale_ordine_passivo_raf += _salerafr; } } if (_sez_da_stamp == '5') _totale_ordine_raf += _salerafr; if (_sez_da_stamp == '9') _totale_economico_raf += _salerafr; } } return TRUE; } else return FALSE; } bool CG1600_application::preprocess_stampa_verifica(int counter) { struct bil_ivd* bil = (struct bil_ivd*) _buff; int g,c; long s; bool fai = TRUE; if (!counter) { reset_print(); _i = 1; } if (_reset_righe_stampa) { reset_print(); _i = 1; } else _reset_righe_stampa = TRUE; if (counter) { if (!_intera_struttura) { if (bil->gruppo[0] != 'Z') { _sez_stamp = bil->sez; _let_stamp = bil->let; _numr_stamp = bil->numr; _numr_stamp.ltrim(); _num_stamp = bil->num; _num_stamp.ltrim(); _sez_tot = bil->sez; _let_tot = bil->let; _numr_tot = bil->numr; _numr_tot.ltrim(); _num_tot = bil->num; _num_tot.ltrim(); } } else { _classe_stampata = format ("%1c%1c%8s%2d",bil->sez,bil->let,(const char*) bil->numr,bil->num); _sez_stamp = bil->sez; _let_stamp = bil->let; _numr_stamp = bil->numr; _numr_stamp.ltrim(); _num_stamp = bil->num; _num_stamp.ltrim(); _sez_tot = bil->sez; _let_tot = bil->let; _numr_tot = bil->numr; _numr_tot.ltrim(); _num_tot = bil->num; _num_tot.ltrim(); } } _buff = _sort->retrieve(); if (_buff == NULL) { stampa_totali_verifica(); set_row (_i,"@0g****** ******** TOTALE GENERALE"); set_row (_i,"@49g%r", &_tot_gen_prg_d); set_row (_i,"@65g%r", &_tot_gen_prg_a); set_row (_i,"@82g%r", &_tot_gen_mov_d); set_row (_i,"@98g%r", &_tot_gen_mov_a); if (!_stampa_modulo) { if (_tot_gen_saldo < ZERO) { _tot_gen_saldo = -_tot_gen_saldo; _tot_sez_saldo = 'A'; } else _tot_sez_saldo = 'D'; stampa_saldo_132(_tot_gen_saldo); } else stampa_saldo_198(_tot_gen_saldo_d,_tot_gen_saldo_a); _sez_da_stamp = ' '; _sez_stamp = ' '; return TRUE; } if (_buff != NULL) { bil = (struct bil_ivd*) _buff; _classe_da_stampare = format ("%1c%1c%8s%2d",bil->sez,bil->let,(const char*) bil->numr,bil->num); _sez_da_stamp = bil->sez; _let_da_stamp = bil->let; _numr_da_stamp = bil->numr; _numr_da_stamp.ltrim(); _num_da_stamp = bil->num; _num_da_stamp.ltrim(); g = atoi(bil->gruppo); c = atoi(bil->conto); s = atol(bil->sottoc); if (_intera_struttura) fai = TRUE; else { if (bil->gruppo[0] != 'Z') fai = TRUE; else fai = FALSE; } if (counter) { if (fai) stampa_totali_verifica(); } _sale = bil->saldo; _sld_prg_dare = bil->sld_prg_dare; _sld_prg_avere = bil->sld_prg_avere; _mov_dare = bil->mov_dare; _mov_avere = bil->mov_avere; if (!_intera_struttura) { if (bil->gruppo[0]=='Z') return FALSE; if (_stampamov) { if (_sale.is_zero()) return FALSE; } } else { if (bil->gruppo[0]=='Z') { if (_classe_da_stampare != _classe_stampata) { sprintf (bil->gruppo,"%s", " "); sprintf (bil->conto ,"%s", " "); sprintf (bil->sottoc,"%s", " "); } else return FALSE; } if (_stampamov) { if (_sale.is_zero()) return FALSE; } } if ((g != 0) && (c != 0) && (s == 0)) { if (_sld_prg_avere < ZERO) _sld_prg_avere = -_sld_prg_avere; if (_mov_avere < ZERO) _mov_avere = -_mov_avere; if (_sale < ZERO) { _sale = -_sale; _sez_saldo = 'A'; } else _sez_saldo = 'D'; } if ((g != 0) && (c != 0) && (s != 0)) { _tot_num_saldo += _sale; _tot_numr_saldo += _sale; _tot_let_saldo += _sale; _tot_gen_saldo += _sale; if (_sld_prg_avere < ZERO) _sld_prg_avere = -_sld_prg_avere; if (_mov_avere < ZERO) _mov_avere = -_mov_avere; if (_sale < ZERO) { _sale = -_sale; _sez_saldo = 'A'; if (_stampa_modulo) { _tot_num_saldo_a += _sale; _tot_numr_saldo_a += _sale; _tot_let_saldo_a += _sale; _tot_gen_saldo_a += _sale; } } else { _sez_saldo = 'D'; if (_stampa_modulo) { _tot_num_saldo_d += _sale; _tot_numr_saldo_d += _sale; _tot_let_saldo_d += _sale; _tot_gen_saldo_d += _sale; } } _tot_num_prg_d += _sld_prg_dare; _tot_numr_prg_d += _sld_prg_dare; _tot_let_prg_d += _sld_prg_dare; _tot_gen_prg_d += _sld_prg_dare; _tot_num_prg_a += _sld_prg_avere; _tot_numr_prg_a += _sld_prg_avere; _tot_let_prg_a += _sld_prg_avere; _tot_gen_prg_a += _sld_prg_avere; _tot_num_mov_d += _mov_dare; _tot_numr_mov_d += _mov_dare; _tot_let_mov_d += _mov_dare; _tot_gen_mov_d += _mov_dare; _tot_num_mov_a += _mov_avere; _tot_numr_mov_a += _mov_avere; _tot_let_mov_a += _mov_avere; _tot_gen_mov_a += _mov_avere; } return TRUE; } else return FALSE; } void CG1600_application::set_page(int file, int counter) { if (_tipo_bilancio == 1) { if (_sez_da_stamp != _sez_stamp) { if ((_sez_da_stamp=='1')||((_sez_da_stamp=='2')&&(_statopatr_no_stamp))) { setta_righe ("STATO PATRIMONIALE"); _statopatr_no_stamp = FALSE; } if (_sez_da_stamp == '2') setta_righe(""); if ((_sez_da_stamp == '5') || (_sez_da_stamp == '9')) set_auto_ff(TRUE); } else { if (_buff != NULL) setta_righe(""); } } else if (_tipo_bilancio == 2) { if (_buff != NULL) setta_righe_verifica(); } } void CG1600_application::setta_righe(const char * titolo) { struct bil_ivd* bil = (struct bil_ivd*) _buff; int numeror, numero, gruppo, conto; char sezione,lettera; long sottoc; TString numrom,numr,num; TString descr_let,descr_numr,descr_num,descr_sottoc,descr_classe; bool stampa_classe = TRUE; sezione = bil->sez; lettera = bil->let; numr = bil->numr; // numr.ltrim(); numeror = atoi(bil->numr); numrom = itor(numeror); numero = atoi(bil->num); num = bil->num; gruppo = atoi(bil->gruppo); conto = atoi(bil->conto); sottoc = atoi(bil->sottoc); _descr_sez = descrizione_sezione(sezione); descr_let = descrizione_lettera(sezione,lettera); descr_numr = descrizione_numeroromano(sezione,lettera,numr); descr_num = descrizione_numero(sezione,lettera,numr,numero); descr_sottoc = descrizione_sottoconto(gruppo,conto,sottoc); //Se la classe prelevata dal record corrente del sort e' diversa dalla classe //prelevata dal record precedente, allora stampo la nuova classe con i relativi //sottoconti. In caso contrario continuo a stampare solo i sottoconti. if (_sez_da_stamp != _sez_stamp) { set_row (_i++,"@0g%s", titolo); char app = ' '; set_row(_i++,"@0g%c", app); if ((_sez_da_stamp == '1')&&(_let_da_stamp == 'Z')) { char app = ' '; set_row (_i++,"@0g%c", app); set_row (_i++,"@0gCONTI D' ORDINE ATTIVI"); set_row (_i++,"@0g%c", app); stampa_classe = FALSE; } if ((_sez_da_stamp == '2')&&(_let_da_stamp == 'Z')) { char app = ' '; set_row(_i++,"@0g%c", app); set_row (_i++,"@0gCONTI D' ORDINE PASSIVI"); set_row(_i++,"@0g%c", app); stampa_classe = FALSE; } if (stampa_classe) { if ((_sez_da_stamp=='1')||(_sez_da_stamp=='2')||(_sez_da_stamp== '9')) { set_row(_i++,"@0g%s", (const char*) _descr_sez); _cont_let = 1; _cont_numr = 1; _cont_num = 1; _cont_gcs = 0; if (lettera != ' ') { set_row(_i,"@0g%c", bil->let); set_row(_i++,"@1g)@3g%s", (const char*) descr_let); } if (numrom != "") { set_row(_i,"@9g%s", (const char*) numrom); set_row(_i++,"@12g-@14g%s", (const char*) descr_numr); } if (num != "") { set_row(_i,"@13g%s", bil->num); set_row(_i++,"@15g)@18g%s", (const char*) descr_num); } } } } else if ((_let_da_stamp!=_let_stamp)&&(_sez_da_stamp==_sez_stamp)) { if ((_sez_da_stamp == '1')&&(_let_da_stamp == 'Z')) { char app = ' '; set_row (_i++,"@0g%c", app); set_row (_i++,"@0gCONTI D' ORDINE ATTIVI"); set_row (_i++,"@0g%c", app); stampa_classe = FALSE; } if ((_sez_da_stamp == '2')&&(_let_da_stamp == 'Z')) { char app = ' '; set_row(_i++,"@0g%c", app); set_row (_i++,"@0gCONTI D' ORDINE PASSIVI"); set_row(_i++,"@0g%c", app); stampa_classe = FALSE; } if (stampa_classe) { if ((_sez_da_stamp=='1')||(_sez_da_stamp=='2')||(_sez_da_stamp=='9')) { set_row(_i,"@0g%c", bil->let); set_row(_i++,"@1g)@3g%s", (const char*) descr_let); _cont_let += 1; if (numrom != "") { set_row(_i,"@9g%s", (const char*) numrom); set_row(_i++,"@12g-@14g%s", (const char*) descr_numr); } if (num != "") { set_row(_i,"@13g%s", bil->num); set_row(_i++,"@15g)@18g%s", (const char*) descr_num); } } } } else if ((_numr_da_stamp!=_numr_stamp)&&(_sez_da_stamp==_sez_stamp)&&(_let_da_stamp==_let_stamp)) { if ((_sez_da_stamp=='1')||(_sez_da_stamp=='2')||(_sez_da_stamp=='9')) { set_row(_i,"@9g%s", (const char*) numrom); set_row(_i++,"@12g-@14g%s", (const char*) descr_numr); _cont_numr += 1; if (num != "") { set_row(_i,"@13g%s", bil->num); set_row(_i++,"@15g)@18g%s", (const char*) descr_num); } } } else if ((_num_da_stamp!=_num_stamp)&&(_sez_da_stamp==_sez_stamp)&&(_let_da_stamp==_let_stamp)&&(_numr_da_stamp==_numr_stamp)) { if ((_sez_da_stamp=='1')||(_sez_da_stamp=='2')||(_sez_da_stamp=='9')) { set_row(_i,"@13g%s", bil->num); set_row(_i++,"@15g)@18g%s", (const char*) descr_num); _cont_num += 1; } } if (bil->gruppo[0] != 'A') { _cont_gcs += 1; if (!_stampacod) { set_row (_i,"@18g%s", bil->gruppo); set_row (_i,"@22g%s", bil->conto); set_row (_i,"@26g%s", bil->sottoc); set_row (_i,"@33g%s", (const char*) descr_sottoc); set_row (_i,"@86g%r", &_sale); if (_annoeserafr != 0) set_row (_i,"@112g%r", &_salerafr); _i++; } else { if ((sezione != ' ')&&(lettera == ' ')&&(numrom == "")&&(num == "")) descr_classe = _descr_sez; if ((sezione != ' ')&&(lettera != ' ')&&(numrom == "")&&(num == "")) descr_classe = descr_let; if ((sezione != ' ')&&(lettera != ' ')&&(numrom != "")&&(num == "")) descr_classe = descr_numr; if ((sezione != ' ')&&(lettera != ' ')&&(numrom != "")&&(num != "")) descr_classe = descr_num; if (descr_classe != descr_sottoc) { set_row (_i,"@33g%s", (const char*) descr_sottoc); set_row (_i,"@86g%r", &_sale); if (_annoeserafr != 0) set_row (_i,"@112g%r", &_salerafr); _i++; } } } } void CG1600_application::setta_righe_verifica() { struct bil_ivd* bil = (struct bil_ivd*) _buff; int numeror, numero, gruppo, conto; char sezione,lettera,tmcf; long sottoc; TString numrom,numr,num; TString descr_let,descr_numr,descr_num,descr_sottoc,descr_classe; sezione = bil->sez; lettera = bil->let; numr = bil->numr; numeror = atoi(bil->numr); numrom = itor(numeror); numero = atoi(bil->num); num = bil->num; gruppo = atoi(bil->gruppo); conto = atoi(bil->conto); sottoc = atoi(bil->sottoc); tmcf = bil->tipocf; _descr_sez = descrizione_sezione(sezione); descr_let = descrizione_lettera(sezione,lettera); descr_numr = descrizione_numeroromano(sezione,lettera,numr); descr_num = descrizione_numero(sezione,lettera,numr,numero); if ((tmcf == 'C') || (tmcf == 'F')) descr_sottoc = descr_sottoc_clifo(tmcf,gruppo,conto,sottoc); else descr_sottoc = descrizione_sottoconto(gruppo,conto,sottoc); //Se la classe prelevata dal record corrente del sort e' diversa dalla classe //prelevata dal record precedente, allora stampo la nuova classe con i relativi //sottoconti. In caso contrario continuo a stampare solo i sottoconti. if (_sez_da_stamp != _sez_stamp) { char app = ' '; set_row (_i,"@0g%c", app); set_row (_i++,"@48g|@81g|@114g|"); if ((_sez_da_stamp=='1')||(_sez_da_stamp=='2')||(_sez_da_stamp== '9')) { if (_let_da_stamp != 'Z') { _cont_let = 1; _cont_numr = 1; _cont_num = 1; _cont_gcs = 0; if (lettera != '\0') { set_row(_i,"@0g%c", bil->let); set_row(_i,"@1g)@3g%s", (const char*) descr_let); set_row (_i++,"@48g|@81g|@114g|"); } if (numrom != "") { set_row(_i,"@0g%s", (const char*) numrom); set_row(_i,"@8g)@10g%s", (const char*) descr_numr); set_row (_i++,"@48g|@81g|@114g|"); } if (num != " 0") { set_row(_i,"@0g%s", bil->num); set_row(_i,"@2g)@4g%s", (const char*) descr_num); set_row (_i++,"@48g|@81g|@114g|"); } } } } else if ((_let_da_stamp!=_let_stamp)&&(_sez_da_stamp==_sez_stamp)) { char app = ' '; set_row (_i,"@0g%c", app); set_row (_i++,"@48g|@81g|@114g|"); if ((_sez_da_stamp=='1')||(_sez_da_stamp=='2')||(_sez_da_stamp=='9')) { if (_let_da_stamp != 'Z') { set_row(_i,"@0g%c", bil->let); set_row(_i,"@1g)@3g%s", (const char*) descr_let); set_row (_i++,"@48g|@81g|@114g|"); _cont_let += 1; if (numrom != "") { set_row(_i,"@0g%s", (const char*) numrom); set_row(_i,"@8g)@10g%s", (const char*) descr_numr); set_row (_i++,"@48g|@81g|@114g|"); } if (num != " 0") { set_row(_i,"@0g%s", bil->num); set_row(_i,"@2g)@4g%s", (const char*) descr_num); set_row (_i++,"@48g|@81g|@114g|"); } } } } else if ((_numr_da_stamp!=_numr_stamp)&&(_sez_da_stamp==_sez_stamp)&&(_let_da_stamp==_let_stamp)) { char app = ' '; set_row (_i,"@0g%c", app); set_row (_i++,"@48g|@81g|@114g|"); if ((_sez_da_stamp=='1')||(_sez_da_stamp=='2')||(_sez_da_stamp=='9')) { if (_let_da_stamp != 'Z') { set_row(_i,"@0g%s", (const char*) numrom); set_row(_i,"@8g)@10g%s", (const char*) descr_numr); set_row (_i++,"@48g|@81g|@114g|"); _cont_numr += 1; if (num != " 0") { set_row(_i,"@0g%s", bil->num); set_row(_i,"@2g)@4g%s", (const char*) descr_num); set_row (_i++,"@48g|@81g|@114g|"); } } } } else if ((_num_da_stamp!=_num_stamp)&&(_sez_da_stamp==_sez_stamp)&&(_let_da_stamp==_let_stamp)&&(_numr_da_stamp==_numr_stamp)) { char app = ' '; set_row (_i,"@0g%c", app); set_row (_i++,"@48g|@81g|@114g|"); if ((_sez_da_stamp=='1')||(_sez_da_stamp=='2')||(_sez_da_stamp=='9')) { if (_let_da_stamp != 'Z') { set_row(_i,"@0g%s", bil->num); set_row(_i,"@2g)@4g%s", (const char*) descr_num); set_row (_i++,"@48g|@81g|@114g|"); _cont_num += 1; } } } if (bil->gruppo[0] != 'A') { _cont_gcs += 1; if (!_stampacod) { set_row (_i,"@0g%s", bil->gruppo); set_row (_i,"@4g%s", bil->conto); set_row (_i,"@8g%s", bil->sottoc); set_row (_i,"@15g%s", (const char*) descr_sottoc); set_row (_i,"@49g%r", &_sld_prg_dare); set_row (_i,"@65g%r", &_sld_prg_avere); set_row (_i,"@82g%r", &_mov_dare); set_row (_i,"@98g%r", &_mov_avere); if (_stampa_modulo) { if (_sez_saldo == 'D') { set_row (_i,"@115g%r", &_sale); set_row (_i,"@48g|@81g|@114g|@131g|"); } else if (_sez_saldo == 'A') { set_row (_i,"@133g%r", &_sale); set_row (_i,"@48g|@81g|@114g|@131g|"); } } else { set_row (_i,"@115g%r", &_sale); set_row (_i,"@131g%c", _sez_saldo); set_row (_i,"@48g|@81g|@114g|"); } } else { if ((sezione != ' ')&&(lettera == ' ')&&(numrom == "")&&(num == "")) descr_classe = _descr_sez; if ((sezione != ' ')&&(lettera != ' ')&&(numrom == "")&&(num == "")) descr_classe = descr_let; if ((sezione != ' ')&&(lettera != ' ')&&(numrom != "")&&(num == "")) descr_classe = descr_numr; if ((sezione != ' ')&&(lettera != ' ')&&(numrom != "")&&(num != "")) descr_classe = descr_num; if (descr_classe != descr_sottoc) { set_row (_i,"@33g%s", (const char*) descr_sottoc); set_row (_i,"@49g%r", &_sld_prg_dare); set_row (_i,"@66g%r", &_sld_prg_avere); set_row (_i,"@82g%r", &_mov_dare); set_row (_i,"@99g%r", &_mov_avere); if (_stampa_modulo) { if (_sez_saldo == 'D') { set_row (_i,"@115g%r", &_sale); set_row (_i,"@48g|@81g|@114g|@131g|"); } else if (_sez_saldo == 'A') { set_row (_i,"@133g%r", &_sale); set_row (_i,"@48g|@81g|@114g|@131g|"); } } else { set_row (_i,"@115g%r", &_sale); set_row (_i,"@131g%c", _sez_saldo); set_row (_i,"@48g|@81g|@114g|"); } } } } } TDate CG1600_application::data_inferiore() { TDate data; TDate data_ini_ese_prec,data_fine_ese_prec,data_ini_ese,data_fine_ese; long annoese,annoeseprec; annoese = _msk->get_long(F_ANNOESE); annoeseprec = annoese - 1; _anni_es.aggiungi_anno(annoese, data_ini_ese, data_fine_ese); _anni_es.aggiungi_anno(annoeseprec, data_ini_ese_prec, data_fine_ese_prec); if ((_datalimite>=data_ini_ese_prec)&&(_datalimite<=data_fine_ese_prec)) data = data_ini_ese_prec; if ((_datalimite>=data_ini_ese)&&(_datalimite<=data_fine_ese)) data = data_ini_ese; _data_ini_ese = data_ini_ese; return (data); } TDate CG1600_application::data_inferiore_raf() { TDate data; TDate data_ini_raf_prec,data_fine_raf_prec,data_ini_raf,data_fine_raf; long annoese,annoeseprec; annoese = _msk->get_long(F_ANNORAFFR); annoeseprec = annoese - 1; _anni_es.aggiungi_anno(annoese, data_ini_raf, data_fine_raf); _anni_es.aggiungi_anno(annoeseprec, data_ini_raf_prec, data_fine_raf_prec); _data_fine_raf = data_fine_raf; _data_fine_raf_prec = data_fine_raf_prec; if ((_databilrafr>=data_ini_raf_prec)&&(_databilrafr<=data_fine_raf_prec)) data = data_ini_raf_prec; if ((_databilrafr>=data_ini_raf)&&(_databilrafr<=data_fine_raf)) data = data_ini_raf; return (data); } const char* CG1600_application::descrizione_sezione(char sezione) { TTable tabivd(TAB_IVD); TString dep, dep2; tabivd.zero(); dep = format("%1c", sezione); tabivd.put("CODTAB", dep); tabivd.read(); dep2 = tabivd.get("CODTAB"); if (dep == dep2) tmp = tabivd.get("S0"); else tmp = ""; return (__tmp); } const char* CG1600_application::descrizione_lettera(char sezione, char lettera) { TTable tabivd(TAB_IVD); TString dep, dep2; tabivd.zero(); dep = format("%1c%1c", sezione, lettera); tabivd.put("CODTAB", dep); tabivd.read(); dep2 = tabivd.get("CODTAB"); if (dep == dep2) tmp = tabivd.get("S0"); else tmp = ""; return (__tmp); } const char* CG1600_application::descrizione_numeroromano(char sezione, char lettera, TString numr) { TTable tabivd(TAB_IVD); TString dep, dep2; tabivd.zero(); dep = format("%1c%1c%8s", sezione, lettera, (const char*) numr); tabivd.put("CODTAB", dep); tabivd.read(); dep2 = tabivd.get("CODTAB"); if (dep == dep2) tmp = tabivd.get("S0"); else tmp = ""; return (__tmp); } const char* CG1600_application::descrizione_numero(char sezione, char lettera, TString numr, int numero) { TTable tabivd(TAB_IVD); TString dep; tabivd.zero(); dep = format("%1c%1c%8s%02d",sezione, lettera, (const char*) numr, numero); tabivd.put("CODTAB", dep); tabivd.read(); if (tabivd.bad()) tabivd.zero(); tmp = tabivd.get("S0"); return (__tmp); } const char* CG1600_application::descrizione_sottoconto(int gruppo, int conto, long sottoc) { TLocalisamfile pconti (LF_PCON); pconti.zero(); pconti.put(PCN_GRUPPO , gruppo); if (conto != 0) pconti.put(PCN_CONTO , conto ); if (sottoc != 0) pconti.put(PCN_SOTTOCONTO, sottoc); pconti.read(); if (pconti.bad()) pconti.zero(); tmp = pconti.get(PCN_DESCR); return (__tmp); } const char* CG1600_application::descr_sottoc_clifo(char tipocf,int g,int c,long s) { TLocalisamfile clifo (LF_CLIFO); clifo.zero(); clifo.put(CLI_TIPOCF,tipocf); clifo.put(CLI_GRUPPO , g); if (c != 0) clifo.put(CLI_CONTO , c ); if (s != 0) clifo.put(CLI_CODCF, s); clifo.read(); if (clifo.bad()) clifo.zero(); tmp = clifo.get(CLI_RAGSOC); return (__tmp); } void CG1600_application::preprocess_header() { } // Crea l'intestazione per la stampa a 132 e a 198 caratteri void CG1600_application::crea_intestazione() { TString datastampastr; TString sep(132),sep1(147); TString app(8); TLocalisamfile nditte (LF_NDITTE); TLocalisamfile comuni (LF_COMUNI); TLocalisamfile unloc (LF_UNLOC); TLocalisamfile anag (LF_ANAG); TString codice_ditta,ragsoc,indulc,civulc,capulc,com,prov,comulc; TString cofi,paiv,tipoa,codanagr; reset_header(); nditte.setkey(1); codice_ditta << get_firm(); nditte.curr().zero(); nditte.curr().put(NDT_CODDITTA,codice_ditta); nditte.read(); app=nditte.curr().get(NDT_CODDITTA); ragsoc=nditte.curr().get(NDT_RAGSOC); tipoa =nditte.curr().get(NDT_TIPOA); codanagr = nditte.get(NDT_CODANAGR); unloc.setkey(1); unloc.curr().zero(); unloc.curr().put(ULC_CODDITTA,app); unloc.curr().put(ULC_CODULC,"1"); unloc.read(); indulc=unloc.curr().get(ULC_INDULC); civulc=unloc.curr().get(ULC_CIVULC); capulc=unloc.curr().get(ULC_CAPULC); comulc=unloc.curr().get(ULC_COMULC); comuni.setkey(1); comuni.curr().zero(); comuni.curr().put(COM_COM,comulc); comuni.read(); com=comuni.curr().get(COM_DENCOM); prov=comuni.curr().get(COM_PROVCOM); anag.setkey(2); anag.curr().zero(); anag.curr().put(ANA_TIPOA,tipoa); anag.curr().put(ANA_CODANAGR,codanagr); anag.read(); cofi=anag.curr().get(ANA_COFI); paiv=anag.curr().get(ANA_PAIV); set_header (1, "@0gDITTA@6g%-5s", (const char*) codice_ditta); set_header (1, "@12g%-45s", (const char*) ragsoc); set_header (1, "@59g%-25s", (const char*) indulc); set_header (1, "@86g%-9s", (const char*) civulc); set_header (1, "@97g%-5s", (const char*) capulc); set_header (1, "@103g%-25s", (const char*) com); set_header (1, "@129g%-3s", (const char*) prov); if (_stampa_modulo) { sep1 << "Pag. @#"; sep1.right_just(139); set_header(2,(const char*) sep1); } else { sep << "Pag. @#"; sep.right_just(132); set_header(2,(const char*) sep); } datastampastr = _datastampa.string(); set_header (2,"@0gPartita iva@12g%-11s", (const char*) paiv); set_header (2,"@30gCodice fiscale@45g%-16s", (const char*) cofi); if (_stampa_modulo) set_header (2,"@131gData@136g%s",(const char*) datastampastr); else set_header (2,"@105gData@110g%s",(const char*) datastampastr); if (_tipo_bilancio == 1) { intesta_scalare(); } else if (_tipo_bilancio == 2) { intesta_verifica(); } } void CG1600_application::intesta_verifica_fissa() { TString sep(132),app(32),sep1(147); if (_tipo_stampa == 1) { if (_dataini == _data_ini_ese) set_header(5,"@57gSALDO INIZIALE@87gMOVIMENTI DEL PERIODO"); else if (_dataini > _data_ini_ese) set_header(5,"@54gPROGRESSIVI PRECEDENTI@87gMOVIMENTI DEL PERIODO"); } else if ((_tipo_stampa == 2) || (_tipo_stampa == 3)) set_header(5,"@57gSALDO INIZIALE@87gMOVIMENTI DEL PERIODO"); if (_stampa_modulo) set_header(5,"@129gSALDO"); set_header(5,"@48g|@81g|@114g|"); if (_stampa_modulo) { set_header(5,"@147g|"); set_header(6,"@131g|@147g|"); } set_header(6,"@48g|@81g|@114g|"); app = "--------------------------------"; if (_stampa_modulo) { set_header(6,"@49g%s@82g%s@115g%s", (const char*) app, (const char*) app,(const char*) app); set_header(7,"@1gdescrizione voce@48g|@57gDare@65g|@72gAvere@81g|@90gDare@98g|@105gAvere@114g|@122gDare@131g|@138gAvere@147g|"); sep1.fill('-'); //Stampa 132 - (sep(132)) set_header (8, (const char *) sep1); } else { set_header(6,"@49g%s@82g%s@122gSALDO", (const char*) app, (const char*) app); set_header(7,"@1gdescrizione voce@48g|@57gDare@65g|@72gAvere@81g|@90gDare@98g|@105gAvere@114g|"); sep.fill('-'); //Stampa 132 - (sep(132)) set_header (8, (const char *) sep); } } void CG1600_application::intesta_scalare() { TString datalimitestr,databilrafrstr; TString sep(132); set_header (3,"@0gSTAMPA BILANCIO CONFORME ALLA IV DIRETTIVA"); if (_competenza) set_header (3,"@48g(con controllo competenza)"); set_header (3,"@89gEsercizio@99g%d", _annoese); if (_annoeserafr != 0) { set_header (3,"@115gEsercizio@125g%d", _annoeserafr); databilrafrstr = _databilrafr.string(); set_header (4,"@112galla data@122g%s", (const char*) databilrafrstr); } if (_tipo_stampa == 1) { datalimitestr = _datalimite.string(); set_header (4,"@86galla data@96g%s", (const char*) datalimitestr); } else if ((_tipo_stampa == 2) || (_tipo_stampa == 3)) set_header (4,"@90gall' ultima immissione"); sep.fill('-'); //Stampa 132 - (sep(132)) set_header (5, (const char *) sep); } void CG1600_application::intesta_verifica() { TString sep(132),sep1(147); set_header (3,"@0gBILANCIO DI VERIFICA IV DIRETTIVA"); if (_competenza) set_header (3,"@87g(con controllo competenza)"); if (_tipo_stampa == 1) { TString datainistr = _dataini.string(); TString datafinestr = _datafine.string(); set_header (3,"@43gdalla data@54g%s", (const char*) datainistr); set_header (3,"@65galla data@75g%s", (const char*) datafinestr); } else if (_tipo_stampa == 2) set_header (3,"@42gall' ultima immissione esercizio in corso"); else if (_tipo_stampa == 3) set_header (3,"@42gall' ultima immissione esercizio precedente"); if (_stampa_modulo) { sep1.fill('-'); //Stampa 132 - (sep(132)) set_header (4, (const char *) sep1); } else { sep.fill('-'); //Stampa 132 - (sep(132)) set_header (4, (const char *) sep); } intesta_verifica_fissa(); } void CG1600_application::init_sort() { _bil = new bil_ivd; _sort = new TSort (sizeof(bil_ivd)); _sort -> addsortkey ((char*)&(_bil->sez) - (char*)&(_bil->sez),1); _sort -> addsortkey ((char*)&(_bil->let) - (char*)&(_bil->sez),1); _sort -> addsortkey ((char*)&(_bil->numr) - (char*)&(_bil->sez),8); _sort -> addsortkey ((char*)&(_bil->num) - (char*)&(_bil->sez),2); _sort -> addsortkey ((char*)&(_bil->gruppo) - (char*)&(_bil->sez),3); _sort -> addsortkey ((char*)&(_bil->conto) - (char*)&(_bil->sez),3); _sort -> addsortkey ((char*)&(_bil->sottoc) - (char*)&(_bil->sez),6); _sort->init(); } void CG1600_application::user_create() { _nditte = new TLocalisamfile (LF_NDITTE); _comuni = new TLocalisamfile (LF_COMUNI); _unloc = new TLocalisamfile (LF_UNLOC); _anag = new TLocalisamfile (LF_ANAG); _pconti = new TLocalisamfile (LF_PCON); _clifo = new TLocalisamfile (LF_CLIFO); _tabivd = new TTable (TAB_IVD); _tabesc = new TTable (TAB_ESC); _msk = new TMask("cg1600a"); } void CG1600_application::user_destroy() { delete _msk; delete _tabivd; delete _tabesc; delete _nditte; delete _comuni; delete _unloc; delete _anag; delete _pconti; delete _clifo; } int cg1600 (int argc, char* argv[]) { CG1600_application a; a.run(argc, argv, "Stampa Bilancio IV direttiva CEE"); return 0; }