// cg3400 - Stampa libro giornale #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #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; enum descr { causale, conto, operazione }; enum tipo_sospensione { nessuna, normale, vol_affari, liquidazione }; class TContoOccas : public TBill { TString16 _occfpi; 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() { } const TContoOccas& TContoOccas::set(int g, int c, long s, char t, const char* occfpi) { TBill::set(g,c,s,t); _occfpi = t > ' ' ? occfpi : ""; return *this; } const TString& TContoOccas::descrizione() { if (tipo() > ' ' && _occfpi.not_empty()) { TString16 code; code << tipo() << '|' << sottoconto(); const bool really_occas = cache().get(LF_CLIFO, code, CLI_OCCAS).not_empty(); if (really_occas) return cache().get(LF_OCCAS, _occfpi, "RAGSOC"); } 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: Togliere '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, _stampa_num_pag; // bool _gia_settata_riga_mov; // per la stampa no iva TString80 _ragsoc, _paiva, _comunefis, _viafis; TString16 _provfis, _cap, _occfpi; TString80 _cofi; TTable *_tabreg; 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 TString& 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 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->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 TRectype& reg = r->lfile("REG").curr(); const tipo_sospensione ts = reg.get_bool("B1") ? (tipo_sospensione) 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->curr(LF_RMOV); recrmov.zero(); recrmov.put("NUMREG", numreg); recrmov.put("NUMRIG", 1); 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 cache().get(LF_COMUNI, codice); } const TString & TStampa_giornale::get_descr_caus (const char * codcaus) { return cache().get(LF_CAUSALI, codcaus).get("DESCR"); } void TStampa_giornale::get_dati_ditta () { TString16 codanagr; char tipoa; const TRectype & nditte = cache().get(LF_NDITTE, get_firm()); _ragsoc = nditte.get(NDT_RAGSOC); codanagr = nditte.get(NDT_CODANAGR); tipoa = nditte.get_char(NDT_TIPOA); TToken_string key ; key.add(tipoa); key.add(codanagr); const TRectype & anag = cache().get(LF_ANAG, key); _cofi = anag.get(ANA_COFI); _paiva = anag.get(ANA_PAIV); _comunefis = anag.get(ANA_COMRF); _cap = anag.get(ANA_CAPRF); if (_comunefis.empty()) _comunefis = anag.get(ANF_COMRES); const TRectype& dep = look_com(_comunefis); _comunefis = dep.get(COM_DENCOM); _provfis = dep.get(COM_PROVCOM); if (_cap.empty()) _cap = dep.get(COM_CAPCOM); if (_comunefis.empty()) { _viafis = anag.get(ANA_INDRF); _viafis.rtrim(); _viafis << " " << anag.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; open_files(LF_TABCOM, LF_TAB, LF_NDITTE, LF_ANAG, LF_COMUNI, LF_CLIFO, LF_PCON, LF_OCCAS, 0); _tabreg = new TTable ("REG"); _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"); // CM500302 senza == si incasina con registri vuoti! _cur = new TCursor (_rel, "", 2); // usa la chiave 2: DATAREG+NUMREG _RecPartoDa = new TRectype(_cur->curr()); _RecArrivoA = new TRectype(_cur->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 _tabreg; return TRUE; } void TStampa_giornale::aggiorna_mov() { TLocalisamfile& mov = _cur->file(LF_MOV); long nprog = _nprog_da + 1; _cur->setregion(*_RecPartoDa, *_RecArrivoA); const long items = _cur->items(); TProgind prnd (items, TR("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; // 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, FR("@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, FR("@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(TR("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 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, TR("A riportare "), _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_footer (r++, (const char*) riga); _forza_ariportare = FALSE; if (_devo_riportare > 1) _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(FR("@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(FR("@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(FR("@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 (FR("@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, FR("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 (FR("Partita iva %s @24gCodice fiscale %s"), (const char*)_paiva, (const char*)_cofi, _stampa_width == 132 ? 102 : 168 ); else intes.format (FR("Partita iva %s @24gCodice fiscale %s @%dg%s @%dgData @>"), (const char*)_paiva, (const char*)_cofi, _stampa_width == 132 ? 102 : 168, FR("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 r += 2; if (_stampa_definitiva) set_header(r++, FR("Codice libro: %s %s "),(const char *) _reg_cod, (const char *) _reg_descr); else set_header(r++, FR("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, FR("@59gCodice Conto")); if (!_stampa_definitiva) { if (_stampa_width == 132) { set_header(r++, "@131gS"); set_header(r, FR("@1gN.riga")); } else { set_header(r++, "@197gS"); set_header(r, FR("@1gN.riga")); } } else if (_libro_cronologico) r++; // NON LASCIARE RIGHE IN BIANCO!! set_header(r, FR("@8gDescrizione operazione@36gCausale")); if (_libro_cronologico) // POSCONTO = 74; set_header(r, FR("@74gGeneralita' cliente/fornitore")); else set_header(r, FR("@59gCodice Conto")); if (_stampa_width == 132) set_header(r, FR("@120gImporto")); else set_header(r, FR("@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(); real riporto_dare, riporto_avere; if (_stampa_num_pag) // Stampa numero di pagina in alto a destra { TEsercizi_contabili esc; const int esercizio = esc.date2esc(_data_a); //codice esercizio correntemente selezionato const int anno = esc[esercizio].inizio().year(); //anno finale dell'esercizio TString16 numpag, riga; numpag.format("%d/%d", anno, _pagina_da+pag); const int tab = _stampa_width - numpag.len(); riga.format("@%dg%s", tab, (const char*)numpag); set_header(2, riga); // Sempre quasi sulla prima riga! } // _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); TString256 riporto; riporto.format(FR("@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->curr(); break; default: break; } return TRUE; } 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 r = righe_da_stampare + 1; 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); 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,FR("Operazione n. @b%-7ld@r"), _nprog_mov); set_row(r,FR(" del @b%s@r"), (const char*)datareg_str); // XX/XX/XXXX set_row(r,FR(" doc. n. @b%-7s@r"),(const char*)numdoc); set_row(r,FR(" del @b%s@r %-50s"),(const char*)datadoc_str, (const char*)mov_descr); } else { set_row(r,FR("Operazione n. @b%-7ld@r"), numreg); set_row(r,FR(" del @b%s@r"), (const char*) datareg_str); set_row(r,FR(" doc. n. @b%-7s@r"), (const char*) numdoc); set_row(r,FR(" del @b%s@r %-50s"), (const char*)datadoc_str,(const char*)mov_descr); } if (_annoEsMov != _ae) set_row(r,FR(" 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, FR("@36gCausale %3s %-50s"), (const char*) caus, desc_caus); if (_reg.not_empty()) set_row(r+1, FR(" (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); if (cf > ' ' && _occfpi.not_empty() && s == _cur->curr(LF_MOV).get_long(MOV_CODCF)) _tc.set(g,c,s,cf,_occfpi); else _tc.set(g,c,s,cf,""); 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 cache().get("%IVA", codiva).get("S0"); } // 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, FR(" Imponibile@15g%15s"), (const char*)impon_str); set_row(r, FR("@35gImposta@43g%15s"), (const char*)impos_str); set_row(r, FR("@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 << TR("Detraibile "); break; case 1 : rig << TR("Indetraib. su op.es. "); break; case 3 : rig << TR("Passaggi interni "); break; case 9 : rig << TR("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, FR(" 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, FR(" 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,FR("@56gValuta %3s"), (const char*)codvali); if (_stampa_width == 132) set_row(r,FR("@89gCorr.in valuta @109g%20v"), &cur); else set_row(r,FR("@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; char tipoa; long codanagr; char riga[256]; int r = rdes; TToken_string key; key.add(tipocf); key.add( codcf); const TRectype & clifo = cache().get(LF_CLIFO, key); if (_occfpi.not_empty() && clifo.get_bool(CLI_OCCAS)) // => e' un occasionale... { const TRectype & occ = cache().get(LF_OCCAS, _occfpi); viacf = occ.get(OCC_INDIR); civcf = occ.get(OCC_CIV); capcf = occ.get(OCC_CAP); comcf = occ.get(OCC_COM); } else { 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 ("I1", (long)_pagina_da + 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(); } } bool TStampa_giornale::controlla_mov_aep() { TWait_cursor hourglass; TEsercizi_contabili esc; const int aep = esc.pred(_ae); TDate inizio_ep, fine_ep; if (aep > 0) { inizio_ep = esc[aep].inizio(); fine_ep = esc[aep].fine(); } else return TRUE; // = e' il primo esercizio TRectype da(LF_MOV), a(LF_MOV); da.put(MOV_DATAREG, inizio_ep); a.put (MOV_DATAREG, fine_ep); _cur->setregion(da, a); _cur->setfilter(""); _cur->set_filterfunction(filter_func, TRUE); const TRecnotype items = _cur->items(); _cur->freeze(); TProgind pi(items, TR("Controllo movimenti esercizio precedente"), FALSE, TRUE); bool gia_stampati = TRUE; for (*_cur = 0L ; _cur->pos() < items; ++(*_cur)) { pi.addstatus(1); gia_stampati = _cur->file().get_bool("STAMPATO"); if (!gia_stampati) break; // basta trovarne uno ancora da stampare } _cur->freeze(FALSE); if (!gia_stampati) error_box(TR("Impossibile proseguire con la stampa:\n" "Esistono movimenti nell'esercizio precedente\n" "che non sono ancora stati stampati su bollato.")); return gia_stampati; } bool TStampa_giornale::leggi_tabreg(const char * reg_cod, int reg_anno) { TString16 codtab; codtab.format ("%04d%-3s", reg_anno, reg_cod); _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_num_pag = _tabreg->get_bool("S11"); _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' quello iniziale (in caso di esercizio a cavallo di 2 anni!) // 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; const int esercizio = esc.date2esc(data_a); if (esercizio <= 0) return f.error_box(TR("La data non appartiene a nessun esercizio")); app()._ae_solare = esc[esercizio].inizio().year(); //in caso di esercizio a cavallo di 2 anni va preso il primo anno app()._ae = esercizio; 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(TR("Le date specificate non appartengono allo stesso anno")); if (data_da > data_a) return f.warning_box(TR("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(TR("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(TR("Manca la data di partenza")); if (data_da.ok() && data_da > data_a) return f.warning_box(TR("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); //qui verificare 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; const int esercizio = esc.date2esc(data_a); if (esercizio > 0) { a._ae_solare = esc[esercizio].inizio().year(); // Anno solare usato per la tabella dei registriin caso di esercizio a cavallo di 2 anni va preso il primo anno a._ae = esercizio; // Anno esercizio } } const TString16 reg_cod(f.get()); 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); } return TRUE; } // // mask_b_ripristina // // Se premo il bottone 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(TR("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; isetregion(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(TR("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; _ae = esc.date2esc(_data_a); _data_da = esc[_ae].inizio(); _ae_solare = _data_da.year(); // qui modificato // 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, TR("Stampa libro giornale")); return TRUE; }