#include "77stq.h" #include "77stba.h" #include "77stqab.h" #include "77stqc.h" // // Lista modifiche // // 3.4.96 Nella stampa per Modulaser, aggiunto all'inizio un comando per settare // il font della stampante a 17cpi (v.riga 176) // const char* get_ragsoc_anagr(char tipo, long codanagr) { TLocalisamfile anagr (LF_ANAG); anagr.setkey(1); anagr.zero(); anagr.put(ANA_TIPOA, tipo); anagr.put(ANA_CODANAGR, codanagr); if (anagr.read() == NOERR) __dep80 = anagr.get(ANA_RAGSOC); else __dep80 = ""; return __dep80; } const char* get_ragsoc(const long codditta) { TLocalisamfile ndt(LF_NDITTE); ndt.zero(); ndt.put("CODDITTA",(long)codditta); if (ndt.read() == NOERR) __dep80=ndt.get("RAGSOC"); else __dep80=""; return __dep80; } int TDicForm::prima_riga(PaginaQuadro p) const { return p == PRIMA ? 9 : 8; } void TDicForm::set_cofi_dic(const char* cofi) { _cofi_dic = cofi; // salva il cod.dich. (serve per modulaser) _codditta_dic = sogg_estinto(_codditta); } /*TCursor& TDicForm::cur() { return *_cur; } */ void TDicForm::set_cursor(TCursor* cur) { CHECK(cur, "NULL cursor in TDicForm"); _cur = cur; } TDicForm::TDicForm(const char* form, const char* quadro) : TForm(form), _quadro(quadro), _prog(NULL), _cur(NULL) { _can_print_tot_fis = _can_print_tot_nofis = FALSE; _GiaStampatiFis = _GiaStampatiNoFis = _GiaMessoStartDoc = FALSE; _GiaPosizionato = _posiziona = _modulaser = FALSE; _LastDitta = _EndPrintDitta = _PaginaPosizionamento = FALSE; ClearFlagModulaser(); } long TDicForm::filtra(const long codditta) { TString filtr(24); _codditta=codditta; filtr.format("CODDITTA=%ld", codditta); _cur->setfilter(filtr, TRUE); const long items = _cur->items(); return items; } bool TDicForm::InitPrint(const long codditta) { _codditta = codditta; _RigaCorr = 0; TPrinter& pr = printer(); _posiziona=pr.printtype()==winprinter; // if (_posiziona && !_GiaPosizionato && pr.printtype() == winprinter) if (_posiziona && !_GiaPosizionato && pr.printtype() == winprinter) { posiziona(); #ifdef DBG if (!yesno_box("Proseguire con la stampa ?")) return FALSE; #endif } const bool was_open = pr.isopen(); set_last_page(FALSE); // set_background(1, TRUE); set_curr_page(PRIMA); if (!was_open && !pr.open()) return FALSE; do_events(); _Items = filtra(codditta); if (_Items == 0L) // Se non ci sono record non stampa return FALSE; if (_prog) { delete _prog; _prog = NULL; } if (pr.printtype() != screenvis) { TString msg(60); msg.format("Elaborazione in corso ditta %ld", codditta); _prog = new TProgind(_Items, msg, FALSE,TRUE); } return TRUE; } void TDicForm::close_print() { if (_prog) { delete _prog; _prog = NULL; } } bool TDicForm::print(const long codditta, const long NumFis, const long NumNoFis) { bool StabilitaInesistenzaNoFis = FALSE; bool StabilitaInesistenzaFis = FALSE; long CtrFis = NumFis; long CtrNoFis = NumNoFis; long PtrFis = -1L, PtrNoFis=-1L; TPrinter& pr = printer(); _CtrFisStampati = _CtrNoFisStampati = 0; _finite_fis = _finite_nofis = FALSE; _GiaStampatiFis = _GiaStampatiNoFis = FALSE; _EndPrintDitta = FALSE; // Vero se stampato l'ultimo record bool LastRecord = FALSE; // Vero se letto l'ultimo record _PaginaCorrente = PRIMA; if (!InitPrint(codditta)) return FALSE; TCursor* cur = cursor(); while (!_EndPrintDitta) { for (int pagina=1; pagina <= QD_PAGINE; pagina++, next_page(pr)) { pr.formlen(QD_FORMLEN); if (_PaginaCorrente == PRIMA) { if (_modulaser) ClearFlagModulaser(); for (int righe=0; righe < QD_RIGHE_PRIMA; righe++) { // Stampa intestazione, solo sul primo foglio. if (!righe) { (*cur) = PtrFis >= 0L ? PtrFis : 0L; stampa_testata(pr); } if (_finite_fis || StabilitaInesistenzaFis) break; // La prima volta si deve posizionare sul primo record di p.f. if (PtrFis<0L && !StabilitaInesistenzaFis) { bool Trovato = FALSE; while (!Trovato) { const long ditta = cur->curr().get_long(QUD_CODDITTA); if (ditta != codditta) break; const char tipo = cur->curr().get(QUD_TIPOA)[0]; if (tipo != 'G') { PtrFis = cur->pos(); Trovato = TRUE; break; } else ++(*cur); } StabilitaInesistenzaFis = !Trovato; } if (StabilitaInesistenzaFis) break; (*cur) = PtrFis; const char tipo = cur->curr().get(QUD_TIPOA)[0]; if (tipo != 'F') break; else { CtrFis--; if (CtrFis == 0L) _finite_fis = TRUE; set_body(pr, 'F'); // La stampa e' finita se ho STAMPATO l'ultimo record LastRecord = cur->pos() >= _Items-1; _EndPrintDitta = LastRecord; if (!LastRecord) { ++(*cur); PtrFis = cur->pos(); LastRecord = cur->pos() >= _Items-1; } } } // for righe.. PtrFis = cur->pos(); } if (_PaginaCorrente == SECONDA) { // Reset del flag di pagina con posiz. if (_posiziona && _PaginaPosizionamento) _PaginaPosizionamento = FALSE; for (int righe=0; righe < QD_RIGHE_SECONDA; righe++) { if (!righe) fill_page(pr, HEADER_SECONDA); if (_finite_fis || StabilitaInesistenzaFis) break; (*cur) = PtrFis; const char tipo = cur->curr().get(QUD_TIPOA)[0]; if (tipo != 'F') break; else { CtrFis--; if (CtrFis == 0L) _finite_fis = TRUE; set_body(pr, 'F'); LastRecord = cur->pos() >= _Items-1; _EndPrintDitta = LastRecord; if (!LastRecord) { ++(*cur); PtrFis = cur->pos(); LastRecord = cur->pos() >= _Items-1; } } } PtrFis = cur->pos(); } if (_PaginaCorrente == TERZA) { for (int righe=0; righe < QD_RIGHE_TERZA; righe++) { if (!righe) { fill_page(pr, HEADER_TERZA); _CtrFisStampati = 0; // conta quelli che stampo sulla terza } if (_finite_fis || StabilitaInesistenzaFis) break; (*cur) = PtrFis; const char tipo = cur->curr().get(QUD_TIPOA)[0]; if (tipo != 'F') break; else { CtrFis--; if (CtrFis == 0L) _finite_fis = TRUE; set_body(pr, 'F'); LastRecord = cur->pos() >= _Items-1; _EndPrintDitta = LastRecord; _CtrFisStampati++; if (!LastRecord) { ++(*cur); PtrFis = cur->pos(); LastRecord = cur->pos() >= _Items-1; } } } PtrFis = cur->pos(); } if (_PaginaCorrente == QUARTA) { azzera_totali(); for (int righe=0; righe < QD_RIGHE_QUARTA; righe++) { if (!righe) _CtrNoFisStampati = 0; // All'inizio salta le righe in alto if (!righe) fill_page(pr, HEADER_QUARTA); if (_finite_nofis || StabilitaInesistenzaNoFis) break; // La prima volta si deve posizionare sul primo record di p.g. if (PtrNoFis<0L && !StabilitaInesistenzaNoFis) { bool Trovato = FALSE; bool eof = FALSE; (*cur) = PtrFis-1 > 0L ? PtrFis-1 : 0L; // parti dall'inizio while (!Trovato && !eof) { eof = cur->pos() >= _Items-1; const long ditta = cur->curr().get_long(QUD_CODDITTA); if (ditta != codditta) break; const char tipo = cur->curr().get(QUD_TIPOA)[0]; if (tipo != 'F') { PtrNoFis = cur->pos(); Trovato = TRUE; break; } else ++(*cur); } StabilitaInesistenzaNoFis = !Trovato; } if (StabilitaInesistenzaNoFis) break; (*cur) = PtrNoFis; const char tipo = cur->curr().get(QUD_TIPOA)[0]; if (tipo != 'G') break; else { CtrNoFis--; if (CtrNoFis == 0L) _finite_nofis = TRUE; set_body(pr, 'G'); LastRecord = cur->pos() >= _Items-1; _EndPrintDitta = LastRecord; _CtrNoFisStampati++; if (!LastRecord) { ++(*cur); PtrNoFis = cur->pos(); LastRecord = cur->pos() >= _Items-1; } } } PtrNoFis = cur->pos(); } } // for pagina.. } // while !_EndPrintDitta close_print(); return TRUE; } void TDicForm::ClearFlagModulaser() { for (int i=0; i<=QD_PAGINE; i++) _GiaMessoStartPage[i] = FALSE; } bool TDicForm::ultima_fis() { return _can_print_tot_fis && _finite_fis && !_GiaStampatiFis; } bool TDicForm::ultima_nofis() { return _can_print_tot_nofis && _finite_nofis && !_GiaStampatiNoFis; } void TDicForm::inc_curr_page() { if (_PaginaCorrente == PRIMA) _PaginaCorrente = SECONDA; else if (_PaginaCorrente == SECONDA) _PaginaCorrente = TERZA; else if (_PaginaCorrente == TERZA) _PaginaCorrente = QUARTA; else if (_PaginaCorrente == QUARTA) _PaginaCorrente = PRIMA; } const char* TDicForm::BuildModulaserStartPage() { __dep16="*"; if (_quadro=="Base") __dep16<<"1"; else if (_quadro=="A") __dep16<<"2"; else if (_quadro=="A1") __dep16<<"3"; else if (_quadro=="A2") __dep16<<"4"; else if (_quadro=="A3") __dep16<<"5"; else if (_quadro=="B") __dep16<<"6"; else if (_quadro=="B1") __dep16<<"7"; else if (_quadro=="C") __dep16<<"8"; else if (_quadro=="D") __dep16<<"9"; else if (_quadro=="D1") __dep16<<"10"; else if (_quadro=="E") __dep16<<"11"; else if (_quadro=="E1") __dep16<<"12"; else if (_quadro=="E2") __dep16<<"13"; else if (_quadro=="F") __dep16<<"14"; else if (_quadro=="F1") __dep16<<"15"; else if (_quadro=="F2") __dep16<<"16"; else if (_quadro=="G") __dep16<<"17"; else if (_quadro=="G1") __dep16<<"18"; else if (_quadro=="H") __dep16<<"19"; else if (_quadro=="La") __dep16<<"20"; else if (_quadro=="Na") __dep16<<"21"; else if (_quadro=="Es") __dep16<<"22"; __dep16<<"*"; return __dep16; } void TDicForm::put_modulaser(TPrintrow& row, ModulaserKey Cmd, int page) { TString riga(80); switch (Cmd) { case STARTDOC: if (!_GiaMessoStartDoc) { riga = "\xf"; // Printer escape: font 17cpi riga << VK_STARTDOC; _GiaMessoStartDoc = TRUE; } break; case STARTDITTA: { riga = "$"; TString cofi(16); TString ragsoc(50); // Legge il codice fisc.e la rag.soc. del sogg.dich. oppure della ditta corrente if (_tipo_ditta == estinto) { cofi = _cofi_dic; ragsoc = get_ragsoc(_codditta_dic); } else { cofi = cod_fis(_codditta); ragsoc = get_ragsoc(_codditta); } // cofi.format("%-16s", (const char*)_cur->file(-116).get(ANA_COFI)); // ragsoc = _cur->file(LF_NDITTE).get(NDT_RAGSOC); riga << cofi; // Cod.Fiscale riga << "$00/"; // Cod.Studio/ if (_tipo_ditta == estinto) riga << _codditta_dic; // Cod.Cliente else riga << _codditta; riga << "$"; riga << ragsoc; // RagSoc } break; case STARTPAGE: // riga = "*1*"; riga = BuildModulaserStartPage(); riga << page; _GiaMessoStartPage[page] = TRUE; break; case ENDDOC: riga = VK_ENDDOC; break; default: break; } riga.rtrim(); riga << '\r'; row.put(riga); } bool TDicForm::PaginaPosizionamento() const { return _PaginaPosizionamento && curr_page() == PRIMA; } int TDicForm::dic_form_len() const { // if (curr_page() == PRIMA && _PaginaPosizionamento && !_GiaPosizionato) if (curr_page() == PRIMA && _PaginaPosizionamento) return QD_FORMLEN-HEADER_PRIMA_NOPOS; else return QD_FORMLEN; } // Stampa "righe" righe vuote. Se righe e' -1 fa un formfeed mettendo // il codice ditta sull'ultima riga void TDicForm::fill_page(TPrinter& pr, const int righe) { TPrintrow row; PaginaQuadro pagina = curr_page(); // form feed if (righe < 0) { const int stop = dic_form_len(); for (int i = _RigaCorr; i < stop; i++) { if (i == 0) if (_modulaser) { if (!_GiaMessoStartPage[pagina]) put_modulaser(row, STARTPAGE, pagina); } // Sull'ultima riga metto il codice ditta if (i == stop - 1) { // if (_modulaser && EndJob() && curr_page() == QUARTA) if (_modulaser && EndJob() && ultima_pagina()) put_modulaser(row, ENDDOC); TString16 ditta; ditta << _codditta; row.put(ditta, POS_DITTA); } pr.print(row); row.reset(); } _RigaCorr = 0; return; } else // righe > 0 { for (int i=0; i < righe; i++) { if (i == 0 && _modulaser && !_GiaMessoStartPage[pagina]) put_modulaser(row, STARTPAGE, pagina); else row.reset(); pr.print(row); row.reset(); _RigaCorr++; } } } void TDicForm::jump_to_line(TPrinter& pr, const int lin) { if (_RigaCorr > lin) fill_page(pr, -1); fill_page(pr, lin - _RigaCorr); } void TDicForm::stampa_totali(TPrinter& pr) { TPrint_section& totali = section('F', last_page); totali.update(); for (int i = 0; i < totali.items(); i++) { pr.print(totali.row(i)); _RigaCorr++; } } void TDicForm::stampa_testata(TPrinter& pr) { TPrint_section& head = section('H', first_page); const word r = head.height()-1; TPrintrow& head_row = head.row(r-1); // Setta il numero di pagina e poi lo incrementa TForm_item& nf = head.find_field(H_NUM_FOGLIO); TString fstr(10); fstr << _num_foglio; nf.set(fstr); _num_foglio++; // Setta il cod.fis. del dichiarante se necessario if (tipo_ditta() == estinto) { TForm_item& cfd = head.find_field(H_COFI_DIC); cfd.set(_cofi_dic); } // Righe da saltare nelle prime pag. dei moduli successivi al primo (che' son // senza le righe del posizionamento...) int righedasaltare=HEADER_PRIMA_NOPOS; head.update(); for (word j = 0; j <= r; j++) { if (j==0) { if (_modulaser) { TPrintrow& r = head.row(j); if (!_GiaMessoStartDoc) put_modulaser(r, STARTDOC); put_modulaser(r, STARTDITTA); put_modulaser(r, STARTPAGE, 1); pr.print(r); _RigaCorr++; r.reset(); righedasaltare--; } if (!PaginaPosizionamento()) fill_page(pr, righedasaltare); } pr.print(head.row(j)); _RigaCorr++; } } void TDicForm::next_page(TPrinter& pr) { PaginaQuadro PagCorr = curr_page(); if (PagCorr >= TERZA) stampa_totali(pr); fill_page(pr, -1); // formfeed "adattato" inc_curr_page(); } void TDicForm::azzera_totali() { TPrint_section& foot = section('F', last_page); for (int f = foot.fields()-1; f >= 0; f--) foot.field(f).set(""); } void TDicForm::set_body(TPrinter& pr, const char tipo) { TPrint_section& body = section('B', odd_page); body.reset(); body.update(); // aggiorna_totali(tipo); const int body_righe = body.height(); for (int i=0; i < body_righe; i++) { pr.print(body.row(i)); _RigaCorr++; } if (usa_progind()) progind()->addstatus(1); } void TDicForm::firma_dichiarante() { TPrint_section& footer = section('F', last_page); TForm_item& firma = footer.find_field(FIRMADIC); if (_PaginaCorrente == PRIMA) firma.hide(); if (_PaginaCorrente == QUARTA) { firma.show(); const int y = firma.y()-1; TString cognome = firma.get(); if (cognome.len() > 30 && cognome[29] == ' ') { TString nome = cognome.mid(30, -1); cognome.cut(30); cognome.trim(); cognome << ' ' << nome; firma.set(cognome); footer.row(y).reset(); footer.row(y).put(cognome, firma.x()-1); } } // footer.update(); } void TDicForm::posiziona() { _GiaPosizionato = TRUE; _PaginaPosizionamento = TRUE; arrange_form(); } /////////////////////////////////////////////////////////////////////////////////////////// // // Quadro G // /////////////////////////////////////////////////////////////////////////////////////////// HIDDEN const int QG_FORMLEN = 72; HIDDEN const int QG_PAGINE = 2; HIDDEN const int HEADER_SECONDA_G = 8; class TQuadroG : public TDicForm { private: long _items_g, _items_gd; void stampa_prospetti1_2(TPrinter& pr); void stampa_prospetti3_4(TPrinter& pr); protected: virtual bool ultima_pagina() const { return _PaginaCorrente==SECONDA; } virtual void inc_curr_page(); virtual void next_page(TPrinter& pr); virtual void stampa_totali(TPrinter& pr) {} virtual void aggiorna_totali(const char tipo) {} virtual void set_body(TPrinter& pr, const char tipo) {} public: virtual bool print(const long codditta, const long NumFis, const long NumNoFis); void set_items_gd(const long itg, const long itgd) { _items_g = itg; _items_gd = itgd; } TQuadroG(const char* form, const char* quadro) : TDicForm(form, quadro), _items_g(0L), _items_gd(0L) {} virtual ~TQuadroG() {} }; void TQuadroG::inc_curr_page() { if (_PaginaCorrente == PRIMA) _PaginaCorrente = SECONDA; else if (_PaginaCorrente == SECONDA) _PaginaCorrente = PRIMA; } void TQuadroG::next_page(TPrinter& pr) { PaginaQuadro PagCorr = curr_page(); fill_page(pr, -1); inc_curr_page(); } void TQuadroG::stampa_prospetti1_2(TPrinter& pr) { TPrint_section& head = section('H', 1); const word rr = head.height()-1; TPrintrow& head_row = head.row(rr-1); // Setta il numero di pagina e poi lo incrementa TForm_item& nf = head.find_field(H_NUM_FOGLIO); TString fstr(10); fstr << _num_foglio; nf.set(fstr); _num_foglio++; // Setta il cod.fis. del dichiarante se necessario if (tipo_ditta() == estinto) { TForm_item& cfd = head.find_field(H_COFI_DIC); cfd.set(_cofi_dic); } TCursor* cur = cursor(); // Prospetto n. 2 TRectype& r = cur->curr(); TToken_string p22(r.get("P22")); TToken_string p23(r.get("P23")); TToken_string p24(r.get("P24")); TToken_string p25(r.get("P25")); TToken_string p26(r.get("P26")); const int START_P2 = 56; const int RIGHE_P2 = 5; const int COL_P2 = 5; int cols = 0; for (int i = 0; i < RIGHE_P2; i++) { const int fc2 = START_P2 + cols; TForm_item& c2 = head.find_field(fc2); c2.set(p22.get(i)); const int fc3 = fc2 + 1; TForm_item& c3 = head.find_field(fc3); c3.set(p23.get(i)); const int fc4 = fc3 + 1; TForm_item& c4 = head.find_field(fc4); c4.set(p24.get(i)); const int fc5 = fc4 + 1; TForm_item& c5 = head.find_field(fc5); c5.set(p25.get(i)); const int fc6 = fc5 + 1; TForm_item& c6 = head.find_field(fc6); c6.set(p26.get(i)); cols += COL_P2; } // Righe da saltare nelle prime pag. dei moduli successivi al primo (che' son // senza le righe del posizionamento...) int HEADER_PRIMA_NOPOS = 3; head.update(); for (word j = 0; j <= rr; j++) { if (j==0) { if (_modulaser) { TPrintrow& r = head.row(j); if (!_GiaMessoStartDoc) put_modulaser(r, STARTDOC); put_modulaser(r, STARTDITTA); put_modulaser(r, STARTPAGE, 1); pr.print(r); _RigaCorr++; r.reset(); HEADER_PRIMA_NOPOS--; } if (!PaginaPosizionamento()) fill_page(pr, HEADER_PRIMA_NOPOS); } pr.print(head.row(j)); _RigaCorr++; } // fill_page(pr, -1); // formfeed "adattato" // inc_curr_page(); } void TQuadroG::stampa_prospetti3_4(TPrinter& pr) { TPrint_section& sez = section('B'); const word rr = sez.height()-1; sez.reset(); TPrintrow& head_row = sez.row(rr-1); // Prospetto n. 3 TCursor* cur = cursor(); TRectype& r = cur->curr(); TToken_string p33a(r.get("P33A")); TToken_string p33b(r.get("P33B")); TToken_string p35a(r.get("P35A")); TToken_string p35b(r.get("P35B")); TToken_string p36a(r.get("P36A")); TToken_string p36b(r.get("P36B")); TString dep1,dep2,dep3,dep4; // Stabilisce se ci vuole l'aggiuntivo dep1=p35a.get(6); dep2=p35a.get(10); dep3=p35a.get(13); dep4=p35a.get(16); bool bAggiuntivo=!dep1.blank() || !dep2.blank() || !dep3.blank() || !dep4.blank(); // colonna 2 e 7 int k = 1; real tot2,tot7,tot_tot2,tot_tot7; tot2 = ZERO; tot7 = ZERO; tot_tot2 = ZERO; tot_tot7 = ZERO; for (int i=0; i<19; i++) { if (i == 6 || i == 10 || i == 13 || i ==16) continue; real token2 (p33a.get(i)); real token7 (p36b.get(i)); tot2 += token2; tot7 += token7; tot_tot2 += token2; tot_tot7 += token7; if (i == 5 || i == 9 || i == 12 || i == 15 || i == 18) { TForm_item& c2 = sez.find_field(k); TForm_item& c7 = sez.find_field(k+54); c2.set(tot2.string()); c7.set(tot7.string()); k++; tot2 = ZERO; tot7 = ZERO; // Stampa totali TForm_item& t2 = sez.find_field(k); if (!bAggiuntivo) { if (i == 18) { TForm_item& t7 = sez.find_field(k+54); t2.set(tot_tot2.string()); t7.set(tot_tot7.string()); } } else t2.set("VEDI ALLEGATO"); } } const int RIGHE_P3 = 21; // Colonna 3 const int START_P3_COL3 = 7; int c3=0; real totale = ZERO; for (i = 0, k = 0; i < RIGHE_P3; i++) { // Salta le righe dell'aggiuntivo if (i == 6 || i == 10 || i == 13 || i ==16 || i == 19) continue; c3 = START_P3_COL3 + k; TForm_item& c5a = sez.find_field(c3); real importo (p33b.get(i)); if (i != 20) c5a.set(importo.string()); else if (!bAggiuntivo) c5a.set(totale.string()); totale += importo; k++; } // Colonna 5 const int START_P3_COL5 = c3 + 1; int c5=0; totale = ZERO; for (i = 0, k = 0; i < RIGHE_P3; i++) { if (i == 6 || i == 10 || i == 13 || i ==16 || i == 19) continue; c5 = START_P3_COL5 + k; TForm_item& c5a = sez.find_field(c5); real importo (p35b.get(i)); if (i != 20) c5a.set(importo.string()); else if (!bAggiuntivo) c5a.set(totale.string()); totale += importo; k++; } // Colonna 6 const int START_P3_COL6 = c5 + 1; int c6=0; totale = ZERO; for (i = 0, k = 0; i < RIGHE_P3; i++) { if (i == 6 || i == 10 || i == 13 || i ==16 || i == 19) continue; c6 = START_P3_COL6 + k; TForm_item& c6a = sez.find_field(c6); real importo (p36a.get(i)); if (i != 20) c6a.set(importo.string()); else if (!bAggiuntivo) c6a.set(totale.string()); totale += importo; k++; } sez.update(); const int sez_righe = sez.height(); for (i=0; i < sez_righe; i++) { pr.print(sez.row(i)); _RigaCorr++; } if (usa_progind()) progind()->addstatus(1); // fill_page(pr, -1); // formfeed "adattato" // inc_curr_page(); } bool TQuadroG::print(const long codditta, const long NumFis, const long NumNoFis) { TCursor* cur = cursor(); bool StabilitaInesistenzaNoFis = FALSE; bool StabilitaInesistenzaFis = FALSE; long CtrFis = NumFis; long CtrNoFis = NumNoFis; long PtrFis = -1L, PtrNoFis=-1L; TPrinter& pr = printer(); _CtrFisStampati = _CtrNoFisStampati = 0; _finite_fis = _finite_nofis = FALSE; _GiaStampatiFis = _GiaStampatiNoFis = FALSE; _EndPrintDitta = FALSE; // Vero se stampato l'ultimo record bool LastRecord = FALSE; // Vero se letto l'ultimo record _PaginaCorrente = PRIMA; if (!InitPrint(codditta)) return FALSE; for (int pagina=1; pagina <= QG_PAGINE; pagina++, next_page(pr)) { pr.formlen(dic_form_len()); if (_PaginaCorrente == PRIMA) { if (!_PaginaPosizionamento) fill_page(pr,HEADER_PRIMA_NOPOS); if (_modulaser) ClearFlagModulaser(); (*cur) = PtrFis >= 0L ? PtrFis : 0L; stampa_prospetti1_2(pr); } if (_PaginaCorrente == SECONDA) { // Reset del flag di pagina con posiz. if (_posiziona && _PaginaPosizionamento) _PaginaPosizionamento = FALSE; pr.formlen(dic_form_len()); fill_page(pr, HEADER_SECONDA_G); stampa_prospetti3_4(pr); } } // for pagina.. return TRUE; } /////////////////////////////////////////////////////////////////////////////////////////// // // Distinta G // /////////////////////////////////////////////////////////////////////////////////////////// HIDDEN const int QGD_FORMLEN = 72; HIDDEN const int QGD_PAGINE = 2; HIDDEN const int HEADER_SECONDA_GD = 15; HIDDEN const int QGD_RIGHE_PRIMA = 5; HIDDEN const int QGD_RIGHE_SECONDA = 6; class TDistintaG : public TQuadroG { private: virtual void stampa_totali(TPrinter& pr); virtual void next_page(TPrinter& pr); virtual void set_body(TPrinter& pr, const char tipo); int calcola_firma(); public: virtual bool print(const long codditta, const long NumFis, const long NumNoFis); TDistintaG(const char* form, const char* quadro) : TQuadroG(form,quadro) {} virtual ~TDistintaG() {} }; int TDistintaG::calcola_firma() { TPrint_section& totali = section('F', even_page); TForm_item& signature = totali.find_field(16); const int y = signature.y(); TString spazi(50); spazi.fill(' '); TString cognome = signature.get(); if (cognome.len() > 30 && cognome[29] == ' ') { TString nome = cognome.mid(30, -1); cognome.cut(30); cognome.trim(); cognome << ' ' << nome; signature.set(cognome); } totali.row(y-1).put(spazi, signature.x()-1); totali.row(y-1).put(cognome, signature.x()-1); return y; } void TDistintaG::stampa_totali(TPrinter& pr) { PaginaQuadro PagCorr = curr_page(); if (PagCorr == PRIMA) { TPrint_section& totali = section('F', odd_page); totali.update(); for (int i = 0; i < totali.items(); i++) { pr.print(totali.row(i)); _RigaCorr++; } } else if (PagCorr == SECONDA) { TPrint_section& totali = section('F', even_page); totali.update(); const int lasty = calcola_firma(); for (int i = 0; i < totali.items(); i++) { pr.print(totali.row(i)); _RigaCorr++; } } } void TDistintaG::next_page(TPrinter& pr) { PaginaQuadro PagCorr = curr_page(); if (PagCorr == PRIMA) jump_to_line(pr,57); else if (PagCorr == SECONDA) jump_to_line(pr,51); stampa_totali(pr); TPrint_section& body = section('F', last_page); body.reset(); fill_page(pr, -1); // formfeed "adattato" inc_curr_page(); } /*void TDistintaG::stampa_testata(TPrinter& pr) { TPrint_section& head = section('H', 1); const word r = head.height()-1; TPrintrow& head_row = head.row(r-1); // Setta il numero di pagina e poi lo incrementa TForm_item& nf = head.find_field(H_NUM_FOGLIO); TString fstr(10); fstr << _num_foglio; nf.set(fstr); _num_foglio++; fill_page(pr, HEADER_PRIMA_GD); }*/ void TDistintaG::set_body(TPrinter& pr, const char tipo) { if (tipo == 'F') { TPrint_section& body = section('B', odd_page); body.reset(); body.update(); const int body_righe = body.height(); for (int i=0; i < body_righe; i++) { pr.print(body.row(i)); _RigaCorr++; } } else if (tipo == 'G') { TPrint_section& body = section('B', even_page); body.reset(); body.update(); const int body_righe = body.height(); for (int i=0; i < body_righe; i++) { pr.print(body.row(i)); _RigaCorr++; } } if (usa_progind()) progind()->addstatus(1); } bool TDistintaG::print(const long codditta, const long NumFis, const long NumNoFis) { TCursor* cur = cursor(); bool StabilitaInesistenzaNoFis = FALSE; bool StabilitaInesistenzaFis = FALSE; long CtrFis = NumFis; long CtrNoFis = NumNoFis; long PtrFis = -1L, PtrNoFis=-1L; TPrinter& pr = printer(); _CtrFisStampati = _CtrNoFisStampati = 0; _finite_fis = _finite_nofis = FALSE; _GiaStampatiFis = _GiaStampatiNoFis = FALSE; _EndPrintDitta = FALSE; // Vero se stampato l'ultimo record bool LastRecord = FALSE; // Vero se letto l'ultimo record _PaginaCorrente = PRIMA; _codditta = codditta; _RigaCorr = 0; const long items = filtra(codditta); while (!_EndPrintDitta) { for (int pagina=1; pagina <= QGD_PAGINE; pagina++, next_page(pr)) { pr.formlen(QGD_FORMLEN); if (_PaginaCorrente == PRIMA) { if (_modulaser) ClearFlagModulaser(); for (int righe=0; righe < QGD_RIGHE_PRIMA; righe++) { // Stampa intestazione, solo sul primo foglio. if (!righe) { (*cur) = PtrFis >= 0L ? PtrFis : 0L; stampa_testata(pr); } _EndPrintDitta=_finite_fis && _finite_nofis; if (_finite_fis || StabilitaInesistenzaFis) break; // La prima volta si deve posizionare sul primo record di p.f. if (PtrFis<0L && !StabilitaInesistenzaFis) { bool Trovato = FALSE; while (!Trovato) { const long ditta = cur->curr().get_long(QGD_CODDITTA); if (ditta != codditta) break; const char tipo = cur->curr().get(QGD_TIPOA)[0]; if (tipo != 'G') { PtrFis = cur->pos(); Trovato = TRUE; break; } else ++(*cur); } StabilitaInesistenzaFis = !Trovato; } if (StabilitaInesistenzaFis) break; (*cur) = PtrFis; const char tipo = cur->curr().get(QGD_TIPOA)[0]; if (tipo != 'F') break; else { CtrFis--; if (CtrFis == 0L) _finite_fis = TRUE; set_body(pr, 'F'); // La stampa e' finita se ho STAMPATO l'ultimo record LastRecord = cur->pos() >= items-1; _EndPrintDitta = LastRecord; if (!LastRecord) { ++(*cur); PtrFis = cur->pos(); LastRecord = cur->pos() >= items-1; } } } // for righe.. PtrFis = cur->pos(); } if (_PaginaCorrente == SECONDA) { // Reset del flag di pagina con posiz. if (_posiziona && _PaginaPosizionamento) _PaginaPosizionamento = FALSE; for (int righe=0; righe < QGD_RIGHE_SECONDA; righe++) { if (!righe) _CtrNoFisStampati = 0; // All'inizio salta le righe in alto if (!righe) fill_page(pr, HEADER_SECONDA_GD); if (_finite_nofis || StabilitaInesistenzaNoFis) break; // La prima volta si deve posizionare sul primo record di p.g. if (PtrNoFis<0L && !StabilitaInesistenzaNoFis) { bool Trovato = FALSE; bool eof = FALSE; (*cur) = PtrFis-1 > 0L ? PtrFis-1 : 0L; // parti dall'inizio while (!Trovato && !eof) { eof = cur->pos() >= items-1; const long ditta = cur->curr().get_long(QGD_CODDITTA); if (ditta != codditta) break; const char tipo = cur->curr().get(QGD_TIPOA)[0]; if (tipo != 'F') { PtrNoFis = cur->pos(); Trovato = TRUE; break; } else ++(*cur); } StabilitaInesistenzaNoFis = !Trovato; } // Gestisce i casi in cui non ci sono percipienti nella distinta.. if (items==0) _EndPrintDitta=TRUE; if (StabilitaInesistenzaNoFis) break; (*cur) = PtrNoFis; const char tipo = cur->curr().get(QGD_TIPOA)[0]; if (tipo != 'G') break; else { CtrNoFis--; if (CtrNoFis == 0L) _finite_nofis = TRUE; set_body(pr, 'G'); LastRecord = cur->pos() >= items-1; _EndPrintDitta = LastRecord; _CtrNoFisStampati++; if (!LastRecord) { ++(*cur); PtrNoFis = cur->pos(); LastRecord = cur->pos() >= items-1; } } } PtrNoFis = cur->pos(); } } // for pagina.. } // while !EndPrintDitta if (usa_progind()) { delete _prog; _prog = NULL; } return TRUE; } /////////////////////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////////////////////// // // TStDicArray // // Array delle ditte da stampare. Contiene una riga per ogni ditta che si vuole stampare // Il formato della riga e': // codditta|estinti|numfis|numnofis|ultimafis|ultimanofis // ///////////////////////////////////////////////////////////////////////////////////////////// TToken_string& TStDicArray::operator[](int i) const { return ((TString_array&)_store).row(i); } void TStDicArray::set_ultima_con_fis(const int index, const bool ultima_fis) { TToken_string riga((TString&)_store[index]); riga.add(ultima_fis, 4); _store.add(riga,index); } void TStDicArray::set_ultima_con_nofis(const int index, const bool ultima_nofis) { TToken_string riga((TString&)_store[index]); riga.add(ultima_nofis, 5); _store.add(riga,index); } void TStDicArray::set_flag_tipi(const int index, const bool ultima_fis, const bool ultima_nofis) { TToken_string riga((TString&)_store[index]); riga.add(ultima_fis,4); riga.add(ultima_nofis,5); _store[index] = riga; } void TStDicArray::set_ctr_tipi(const int index, const int num_fis, const int num_nofis) { TToken_string riga((TString&)_store[index]); riga.add(num_fis,2); riga.add(num_nofis,3); _store[index] = riga; } void TStDicArray::set(const int index, const TipoDitta tipo, const int num_fis, const int num_nofis, bool ultima_con_fis, bool ultima_con_nofis, const char* cofi_dic) { TToken_string riga((TString&)_store[index]); riga.add(tipo,1); riga.add(num_fis,2); riga.add(num_nofis,3); riga.add(ultima_con_fis,4); riga.add(ultima_con_nofis,5); TString codfis(20); codfis = cofi_dic ? cofi_dic : ""; riga.add((const char*)codfis,6); _store[index] = riga; } void TStDicArray::add(const long codditta, const TipoDitta tipo, const int num_fis, const int num_nofis, bool ultima_con_fis, bool ultima_con_nofis, const char* cfdic) { TString key(40); // Il formato della riga e': codditta|estinti|numfis|numnofis|ultimafis|ultimanofis key.format("%ld|%d|%d|%d|%d|%d|%s", codditta, tipo, num_fis, num_nofis, ultima_con_fis, ultima_con_nofis, cfdic ? cfdic : ""); _store.add(key); } ////////////////////////////////////////////////////////////////////////////////////////// // TStampaQuadro ////////////////////////////////////////////////////////////////////////////////////////// TStampaQuadro::TStampaQuadro(const char* quad, char liv) : _quadro(quad), _livello(liv) { _title = "Stampa Quadro "; _title << _quadro; } // La maschera e' uguale per tutti i quadri const char* TStampaQuadro::mask_name() const { return "77STQD"; } const char* TStampaQuadro::form_name() const { __dep16 = "77Q"; __dep16 << _quadro; return __dep16; } bool TStampaQuadro::create() { TApplication::create(); _section = name(); _section.cut(2); _cnf = new TConfig(CONFIG_USER, _section); _m = new TMask(mask_name()); _m->set_caption(taitol()); if (singola_ditta()) { _codditta = get_firm_770(); _m->set(F_CODDITTA, _codditta); } else { _m->hide(F_RAGDITTA); _m->set(F_TEXT, "Ditte selezionate"); _m->show(F_TEXT); } user_create(); dispatch_e_menu(BAR_ITEM(1)); return TRUE; } bool TStampaQuadro::destroy() { user_destroy(); delete _m; delete _cnf; return TApplication::destroy(); } void TStampaQuadro::on_config_change() { TConfig conf(singola_ditta() ? CONFIG_STUDIO : CONFIG_USER); _anno_dic = (int)conf.get_long(ANNO_SEL, _section); } bool TStampaQuadro::menu(MENU_TAG) { KEY k; _m->set(F_ANNO, _anno_dic); while ((k = _m->run()) == K_ENTER) { const bool modulaser = _m->get_bool(F_MODULASER); print(modulaser); } return FALSE; } void TStampaQuadro::fill_estinti(const long CodDic) { int NumFisiche=0, NumNoFisiche=0; TString CodFiDic(20); // Salva il cod.fis. del dichiarante CodFiDic = cod_fis(CodDic); if (conta_tipi_per()) { conta_tipiper(CodDic, _quadro, &NumFisiche, &NumNoFisiche); _ditte.add(CodDic, dichiarante, NumFisiche, NumNoFisiche); } else _ditte.add(CodDic, dichiarante); const int index_dich = _ditte.curr_index(); bool gia_trovata_ultima_fis = FALSE; bool gia_trovata_ultima_nofis = FALSE; int index = index_dich; // Leggo gli estinti TLocalisamfile base(LF_BASE); base.setkey(2); base.zero(); base.put(BSE_CODDIC, (long)CodDic); TRectype dep(base.curr()); for (base.read(); !base.eof(); base.next()) { if (base.curr() > dep) break; // Scarta il record del quadro I "globale" del dichiarante const char tipoqua = base.get(BSE_TIPOQUA)[0]; if (tipoqua == COD_QUA_I_DIC) continue; const long DittaEstinta = base.get_long(BSE_CODDITTA); if (conta_tipi_per()) { conta_tipiper(DittaEstinta, _quadro, &NumFisiche, &NumNoFisiche); _ditte.add(DittaEstinta, estinto, NumFisiche, NumNoFisiche, FALSE, FALSE, CodFiDic); } else _ditte.add(DittaEstinta, estinto, 0L, 0L, FALSE, FALSE, CodFiDic); if (conta_tipi_per()) { // Determina se con questa ditta finiscono le persone f. o g. if (NumFisiche == 0 && !gia_trovata_ultima_fis) { _ditte.set_ultima_con_fis(index, TRUE); gia_trovata_ultima_fis = TRUE; } if (NumNoFisiche == 0 && !gia_trovata_ultima_nofis) { _ditte.set_ultima_con_nofis(index, TRUE); gia_trovata_ultima_nofis = TRUE; } } index++; } if (conta_tipi_per()) { // Finiti gli estinti. L'ultima ditta deve avere i totali se non gia' trovati if (!gia_trovata_ultima_fis) _ditte.set_ultima_con_fis(index, TRUE); if (!gia_trovata_ultima_nofis) _ditte.set_ultima_con_nofis(index, TRUE); } } // _ditte e' fatto di righe siffatte: // codditta, flag 2 dichiarante, 1 normale, 0 estinto, num_fis, num_nofis, ultima_con_fis, ultima_con_nofis bool TStampaQuadro::print_quadro(const int OffsetDitta, const bool modulaser) { TDicForm* ff = get_form(); int start=0, last=0; // Setta formlen prima di printer.open per avere la lunghezza giusta nel caso di // stampa a video printer().formlen(QD_FORMLEN); bool ok = printer().open(); ff->set_cursor(get_cursor()); ff->azzera_totali(); ff->set_modulaser(modulaser); // Dice se deve eseguire il posizionamento del foglio. // Se stampa piu' ditte va eseguito solo sulla prima // Occhio a non spostarlo nel ciclo. ff->set_posiziona(TRUE); if (OffsetDitta >= 0) { start = OffsetDitta; last = OffsetDitta; } else last = _ditte.items() - 1; for (int i = start; i <= last; i++) { TString CoFiDic(20); TToken_string riga(ditte()[i]); const long codditta = atol(riga.get(0)); const TipoDitta tipo = (TipoDitta)riga.get_int(1); const long fis = riga.get_long(2); const long nofis = riga.get_long(3); const bool LastFis = (bool)riga.get_int(4); const bool LastNoFis = (bool)riga.get_int(5); // I gruppi dich-estinti hanno totali comuni // Si presume che nell'array vengano messi nell'ordine dich-estinti if (tipo == normale || tipo == dichiarante) ff->azzera_totali(); if (tipo == estinto) CoFiDic = riga.get(6); if (conta_tipi_per()) { // Se e' un dichiarante i totali vanno sull'estinto in cui finiscono o le F o le G const bool StampaTotaliFis = tipo == normale || (tipo == estinto && LastFis); const bool StampaTotaliNoFis = tipo == normale || (tipo == estinto && LastNoFis); // Dice al form se e' questa ditta e' l'ultima con f. o g. ff->can_print_tot_fis(StampaTotaliFis); ff->can_print_tot_nofis(StampaTotaliNoFis); } // Dice al form che tipo di ditta si stampa ff->set_tipo_ditta(tipo); // Numera i fogli a partire da 1 per ogni ditta normale e da 1 e di seguito negli estinti // per i sogg. dichiaranti if (tipo == normale || tipo == dichiarante) ff->set_num_foglio(1); // Se la ditta e' estinta dice al form il cod.fis. del dichiarante if (tipo == estinto) ff->set_cofi_dic(CoFiDic); // Dice al form che e' l'ultima ditta if (i == last) ff->set_last_ditta(TRUE); ff->print(codditta, fis, nofis); } printer().close(); return ok; } void TStampaQuadro::print(const bool modulaser) { int NumFisiche=0, NumNoFisiche=0; _ditte.destroy(); // Pulisce l'array delle ditte if (singola_ditta()) { if (sogg_estinto(_codditta)) { warning_box("La ditta %ld e' un soggetto estinto", _codditta); return; } // Se e' un dichiarante va a prendere tutti i suoi estinti. bool dich = sogg_dic(_codditta); if (dich) fill_estinti(_codditta); else { if (conta_tipi_per()) { conta_tipiper(_codditta, _quadro, &NumFisiche, &NumNoFisiche); _ditte.add(_codditta, normale, NumFisiche, NumNoFisiche); } else _ditte.add(_codditta, normale); } } else // stampa ditte selezionate { // Costruisco un'array delle ditte da stampare. // Tolgo i sogg. estinti, e dopo un dichiarante metto tutti i suoi estinti. long codditta_prec = get_firm_770(); long codditta = 0L; int i=0; while ((codditta = _cnf->get_long(DITTE_SEL, _section, i++)) != 0L) { if (sogg_estinto(codditta)) continue; // Se e' un dichiarante va a prendere tutti i suoi estinti. bool dich = sogg_dic(codditta); if (dich) fill_estinti(codditta); else { if (conta_tipi_per()) { conta_tipiper(codditta, _quadro, &NumFisiche, &NumNoFisiche); _ditte.add(codditta, normale, NumFisiche, NumNoFisiche); } else _ditte.add(codditta, normale); } } set_firm_770(codditta_prec); } print_quadro(-1, modulaser); } ///////////////////////////////////////////////////////////////////////////////////////////// // // STAMPA QUADRO D // ///////////////////////////////////////////////////////////////////////////////////////////// class TQuadroD : public TDicForm { enum { QD_FORMLEN = 72 }; real _totale, _somme, _imponibile, _importo, _netto; bool _devo_sommare; protected: virtual void next_page(TPrinter& pr); virtual bool print(const long codditta, const long NumFis, const long NumNoFis); public: bool controlla_percentuale(TCursor* cur, const real& perc_p); void set_body(TPrinter& pr, const char tipo); void setta_importi(TPrint_section& body); void leggi_importi(); TQuadroD(const char* form, const char* quadro) : TDicForm(form, quadro) {} virtual ~TQuadroD() {} }; bool TQuadroD::controlla_percentuale(TCursor* cur, const real& perc_p) { bool stampa = TRUE; long ditta_p = cur->curr().get_long(QUD_CODDITTA); char tipo_p = cur->curr().get_char(QUD_TIPOA); long codana_p = cur->curr().get_long(QUD_CODANAGR); TString codcaus_p = cur->curr().get (QUD_CODCAUS); if (quadro()[0] == 'D') codcaus_p = cur->curr(-14).get(quadro() == "D" ? "S2" : "S3"); ++(*cur); long ditta = cur->curr().get_long(QUD_CODDITTA); char tipo = cur->curr().get_char(QUD_TIPOA); long codana = cur->curr().get_long(QUD_CODANAGR); real perc = cur->curr().get_real(QUD_PERC); TString codcaus = cur->curr().get (QUD_CODCAUS); if (quadro()[0] == 'D') codcaus = cur->curr(-14).get(quadro() == "D" ? "S2" : "S3"); if (ditta == ditta_p && tipo == tipo_p && codana == codana_p && codcaus == codcaus_p) { if (perc == perc_p || (perc_p == ZERO && perc != ZERO)) { stampa = FALSE; _devo_sommare = TRUE; } } --(*cur); return stampa; } void TQuadroD::leggi_importi() { TCursor* cur = cursor(); _totale = cur->curr().get_real(QUD_TOTALE); _somme = cur->curr().get_real(QUD_SOMME); _imponibile = cur->curr().get_real(QUD_IMPONIBILE); _importo = cur->curr().get_real(QUD_IMPORTO); _netto = cur->curr().get_real(QUD_NETTO); } void TQuadroD::setta_importi(TPrint_section& body) { TCursor* cur = cursor(); real totale = cur->curr().get_real(QUD_TOTALE); real somme = cur->curr().get_real(QUD_SOMME); real imponibile = cur->curr().get_real(QUD_IMPONIBILE); real importo = cur->curr().get_real(QUD_IMPORTO); real netto = cur->curr().get_real(QUD_NETTO); if (_devo_sommare) { totale += _totale; somme += _somme; imponibile += _imponibile; importo += _importo; netto += _netto; _devo_sommare = FALSE; } TForm_item& ftotale = body.find_field(D_TOTALE); TForm_item& fsomme = body.find_field(D_SNSRIT); TForm_item& fimponibile = body.find_field(D_IMPONIBILE); TForm_item& fimporto = body.find_field(D_IMPORTO); TForm_item& fnetto = body.find_field(D_NETTO); TString stotale (totale.string()); TString ssomme (somme.string()); TString simponibile(imponibile.string()); TString simporto (importo.string()); TString snetto (netto.string()); // Setta i campi ftotale.set(stotale); fsomme.set(ssomme); fimponibile.set(simponibile); fimporto.set(simporto); fnetto.set(snetto); } void TQuadroD::set_body(TPrinter& pr, const char tipo) { TPrint_section& body = section('B', odd_page); body.reset(); // body.update(); setta_importi(body); TForm_item& stato_estero = body.find_field(QD_STATO_ESTERO); TCursor* cur = cursor(); TString codice = cur->curr(-24).get("CODTAB"); codice.trim(); if (codice.empty()) stato_estero.hide(); else stato_estero.show(); body.update(); const int body_righe = body.height(); for (int i=0; i < body_righe; i++) { pr.print(body.row(i)); _RigaCorr++; } body.reset(); if (usa_progind()) progind()->addstatus(1); } void TQuadroD::next_page(TPrinter& pr) { PaginaQuadro PagCorr = curr_page(); if (PagCorr >= TERZA) { if (PagCorr == TERZA) jump_to_line(pr,64); else if (PagCorr == QUARTA) jump_to_line(pr,61); stampa_totali(pr); } fill_page(pr, -1); // formfeed "adattato" inc_curr_page(); } bool TQuadroD::print(const long codditta, const long NumFis, const long NumNoFis) { bool StabilitaInesistenzaNoFis = FALSE; bool StabilitaInesistenzaFis = FALSE; long CtrFis = NumFis; long CtrNoFis = NumNoFis; long PtrFis = -1L, PtrNoFis=-1L; TPrinter& pr = printer(); _CtrFisStampati = _CtrNoFisStampati = 0; _finite_fis = _finite_nofis = FALSE; _GiaStampatiFis = _GiaStampatiNoFis = FALSE; _EndPrintDitta = FALSE; // Vero se stampato l'ultimo record bool LastRecord = FALSE; // Vero se letto l'ultimo record bool stampa = TRUE; _PaginaCorrente = PRIMA; if (!InitPrint(codditta)) return FALSE; TCursor* cur = cursor(); while (!_EndPrintDitta) { for (int pagina=1; pagina <= QD_PAGINE; pagina++, next_page(pr)) { // pr.formlen(QD_FORMLEN); firma_dichiarante(); if (_PaginaCorrente == PRIMA) { pr.formlen(dic_form_len()); if (_modulaser) ClearFlagModulaser(); bool testata = TRUE; for (int righe=0; righe < QD_RIGHE_PRIMA; righe++) { stampa = TRUE; // Stampa intestazione, solo sul primo foglio. if (testata) { (*cur) = PtrFis >= 0L ? PtrFis : 0L; if (_PaginaPosizionamento) fill_page(pr, 9); else fill_page(pr, 12); stampa_testata(pr); testata = FALSE; } if (_finite_fis || StabilitaInesistenzaFis) break; // La prima volta si deve posizionare sul primo record di p.f. if (PtrFis<0L && !StabilitaInesistenzaFis) { bool Trovato = FALSE; while (!Trovato) { const long ditta = cur->curr().get_long(QUD_CODDITTA); if (ditta != codditta) break; const char tipo = cur->curr().get(QUD_TIPOA)[0]; if (tipo != 'G') { PtrFis = cur->pos(); Trovato = TRUE; break; } else ++(*cur); } StabilitaInesistenzaFis = !Trovato; } if (StabilitaInesistenzaFis) break; (*cur) = PtrFis; const char tipo = cur->curr().get(QUD_TIPOA)[0]; if (tipo != 'F') break; else { CtrFis--; if (CtrFis == 0L) _finite_fis = TRUE; real perc_p = cur->curr().get_real(QUD_PERC); stampa = controlla_percentuale(cur,perc_p); if (stampa) set_body(pr, 'F'); else { // Siccome questo record non viene stampato perche' va sommato leggi_importi(); // con quello successivo, non e' giusto incrementare l'indice righe--; // delle righe per foglio. Siccome pero' l'ho gia' incrementato } // all'inizio del ciclo ora lo devo decrementare. // La stampa e' finita se ho STAMPATO l'ultimo record LastRecord = cur->pos() >= _Items-1; _EndPrintDitta = LastRecord; if (!LastRecord) { ++(*cur); PtrFis = cur->pos(); LastRecord = cur->pos() >= _Items-1; } } } // for righe.. PtrFis = cur->pos(); } if (_PaginaCorrente == SECONDA) { // Reset del flag di pagina con posiz. if (_posiziona && _PaginaPosizionamento) _PaginaPosizionamento = FALSE; pr.formlen(dic_form_len()); bool testata = TRUE; for (int righe=0; righe < QD_RIGHE_SECONDA; righe++) { stampa = TRUE; if (testata) { fill_page(pr, HEADER_SECONDA); testata = FALSE; } if (_finite_fis || StabilitaInesistenzaFis) break; (*cur) = PtrFis; const char tipo = cur->curr().get(QUD_TIPOA)[0]; if (tipo != 'F') break; else { CtrFis--; if (CtrFis == 0L) _finite_fis = TRUE; real perc_p = cur->curr().get_real(QUD_PERC); stampa = controlla_percentuale(cur,perc_p); if (stampa) set_body(pr, 'F'); else { leggi_importi(); righe--; } LastRecord = cur->pos() >= _Items-1; _EndPrintDitta = LastRecord; if (!LastRecord) { ++(*cur); PtrFis = cur->pos(); LastRecord = cur->pos() >= _Items-1; } } } PtrFis = cur->pos(); } if (_PaginaCorrente == TERZA) { pr.formlen(dic_form_len()); bool testata = TRUE; for (int righe=0; righe < QD_RIGHE_TERZA; righe++) { stampa = TRUE; if (testata) { fill_page(pr, HEADER_TERZA); _CtrFisStampati = 0; // conta quelli che stampo sulla terza testata = FALSE; } if (_finite_fis || StabilitaInesistenzaFis) break; (*cur) = PtrFis; const char tipo = cur->curr().get(QUD_TIPOA)[0]; if (tipo != 'F') break; else { CtrFis--; if (CtrFis == 0L) _finite_fis = TRUE; real perc_p = cur->curr().get_real(QUD_PERC); stampa = controlla_percentuale(cur,perc_p); if (stampa) set_body(pr, 'F'); else { leggi_importi(); righe--; } LastRecord = cur->pos() >= _Items-1; _EndPrintDitta = LastRecord; _CtrFisStampati++; if (!LastRecord) { ++(*cur); PtrFis = cur->pos(); LastRecord = cur->pos() >= _Items-1; } } } PtrFis = cur->pos(); } if (_PaginaCorrente == QUARTA) { pr.formlen(dic_form_len()); azzera_totali(); bool testata = TRUE; for (int righe=0; righe < QD_RIGHE_QUARTA; righe++) { stampa = TRUE; // All'inizio salta le righe in alto if (testata) { _CtrNoFisStampati = 0; fill_page(pr, HEADER_QUARTA); testata = FALSE; } if (_finite_nofis || StabilitaInesistenzaNoFis) break; // La prima volta si deve posizionare sul primo record di p.g. if (PtrNoFis<0L && !StabilitaInesistenzaNoFis) { bool Trovato = FALSE; bool eof = FALSE; (*cur) = PtrFis-1 > 0L ? PtrFis-1 : 0L; // parti dall'inizio while (!Trovato && !eof) { eof = cur->pos() >= _Items-1; const long ditta = cur->curr().get_long(QUD_CODDITTA); if (ditta != codditta) break; const char tipo = cur->curr().get(QUD_TIPOA)[0]; if (tipo != 'F') { PtrNoFis = cur->pos(); Trovato = TRUE; break; } else ++(*cur); } StabilitaInesistenzaNoFis = !Trovato; } if (StabilitaInesistenzaNoFis) break; (*cur) = PtrNoFis; const char tipo = cur->curr().get(QUD_TIPOA)[0]; if (tipo != 'G') break; else { CtrNoFis--; if (CtrNoFis == 0L) _finite_nofis = TRUE; real perc_p = cur->curr().get_real(QUD_PERC); stampa = controlla_percentuale(cur,perc_p); if (stampa) set_body(pr, 'G'); else { leggi_importi(); righe--; } LastRecord = cur->pos() >= _Items-1; _EndPrintDitta = LastRecord; _CtrNoFisStampati++; if (!LastRecord) { ++(*cur); PtrNoFis = cur->pos(); LastRecord = cur->pos() >= _Items-1; } } } PtrNoFis = cur->pos(); firma_dichiarante(); } } // for pagina.. } // while !_EndPrintDitta close_print(); return TRUE; } class TStampaQuadroD : public TStampaQuadro { TQuadroD* _form; TCursor* _cur; protected: virtual bool user_create(); virtual bool user_destroy(); virtual TDicForm* get_form() const { return _form; } virtual TCursor* get_cursor() const { return _cur; } public: TStampaQuadroD(const char* quadro, char livel); virtual ~TStampaQuadroD() { } }; TStampaQuadroD::TStampaQuadroD(const char* quadro, char liv) : TStampaQuadro(quadro, liv) { } bool TStampaQuadroD::user_create() { _form = new TQuadroD("77QD", quadro()); TString sortkey(80); sortkey.format("CODDITTA|TIPOA|216@->RAGSOC|CODANAGR|CODCAUS|PERC", LF_QUAD, LF_QUAD); _cur = new TSorted_cursor(_form->TForm::relation(), sortkey); return TRUE; } bool TStampaQuadroD::user_destroy() { delete _form; delete _cur; return TRUE; } ///////////////////////////////////////////////////////////////////////////////////////////// // QUADRO D1 ///////////////////////////////////////////////////////////////////////////////////////////// class TQuadroD1 : public TDicForm { enum { QD_FORMLEN = 72 }; real _totale, _quotapro, _speseant, _imponibile, _importo, _netto; bool _devo_sommare; protected: virtual void next_page(TPrinter& pr); virtual bool print(const long codditta, const long NumFis, const long NumNoFis); public: bool controlla_percentuale(TCursor* cur, const real& perc_p); void set_body(TPrinter& pr, const char tipo); void setta_importi(TPrint_section& body); void leggi_importi(); TQuadroD1(const char* form, const char* quadro) : TDicForm(form, quadro) {} virtual ~TQuadroD1() {} }; bool TQuadroD1::controlla_percentuale(TCursor* cur, const real& perc_p) { bool stampa = TRUE; if (perc_p == ZERO) { long ditta_p = cur->curr().get_long(QD1_CODDITTA); char tipo_p = cur->curr().get_char(QD1_TIPOA); long codana_p = cur->curr().get_long(QD1_CODANAGR); TString codcaus_p = cur->curr().get (QD1_CODCAUS); ++(*cur); long ditta = cur->curr().get_long(QD1_CODDITTA); char tipo = cur->curr().get_char(QD1_TIPOA); long codana = cur->curr().get_long(QD1_CODANAGR); TString codcaus = cur->curr().get (QD1_CODCAUS); real perc = cur->curr().get_real(QD1_PERC); if (ditta == ditta_p && tipo == tipo_p && codana == codana_p && codcaus == codcaus_p) { if (perc != ZERO) { stampa = FALSE; _devo_sommare = TRUE; } } --(*cur); } return stampa; } void TQuadroD1::leggi_importi() { TCursor* cur = cursor(); _totale = cur->curr().get_real(QD1_TOTALE); _quotapro = cur->curr().get_real(QD1_QUOTAPRO); _speseant = cur->curr().get_real(QD1_SPESEANT); _imponibile = cur->curr().get_real(QD1_IMPONIBILE); _importo = cur->curr().get_real(QD1_IMPORTO); _netto = cur->curr().get_real(QD1_NETTO); } void TQuadroD1::setta_importi(TPrint_section& body) { TCursor* cur = cursor(); real totale = cur->curr().get_real(QD1_TOTALE); real quotapro = cur->curr().get_real(QD1_QUOTAPRO); real speseant = cur->curr().get_real(QD1_SPESEANT); real imponibile = cur->curr().get_real(QD1_IMPONIBILE); real importo = cur->curr().get_real(QD1_IMPORTO); real netto = cur->curr().get_real(QD1_NETTO); if (_devo_sommare) { totale += _totale; quotapro += _quotapro; speseant += _speseant; imponibile += _imponibile; importo += _importo; netto += _netto; _devo_sommare = FALSE; } TForm_item& ftotale = body.find_field(D1_TOTALE); TForm_item& fquotapro = body.find_field(D1_QUOTAPRO); TForm_item& fspeseant = body.find_field(D1_SPESEANT); TForm_item& fimponibile = body.find_field(D1_IMPONIBILE); TForm_item& fimporto = body.find_field(D1_IMPORTO); TForm_item& fnetto = body.find_field(D1_NETTO); TString stotale (totale.string()); TString squotapro (quotapro.string()); TString sspeseant (speseant.string()); TString simponibile(imponibile.string()); TString simporto (importo.string()); TString snetto (netto.string()); // Setta i campi ftotale.set(stotale); fquotapro.set(squotapro); fspeseant.set(sspeseant); fimponibile.set(simponibile); fimporto.set(simporto); fnetto.set(snetto); } void TQuadroD1::set_body(TPrinter& pr, const char tipo) { TPrint_section& body = section('B', odd_page); body.reset(); // body.update(); setta_importi(body); body.update(); const int body_righe = body.height(); for (int i=0; i < body_righe; i++) { pr.print(body.row(i)); _RigaCorr++; } body.reset(); if (usa_progind()) progind()->addstatus(1); } void TQuadroD1::next_page(TPrinter& pr) { PaginaQuadro PagCorr = curr_page(); if (PagCorr >= TERZA) { if (PagCorr == TERZA) jump_to_line(pr,62); else if (PagCorr == QUARTA) jump_to_line(pr,62); stampa_totali(pr); } fill_page(pr, -1); // formfeed "adattato" inc_curr_page(); } bool TQuadroD1::print(const long codditta, const long NumFis, const long NumNoFis) { bool StabilitaInesistenzaNoFis = FALSE; bool StabilitaInesistenzaFis = FALSE; bool StampatoRitenutaImposta = FALSE; long CtrFis = NumFis; long CtrNoFis = NumNoFis; long PtrFis = -1L, PtrNoFis=-1L; TPrinter& pr = printer(); _CtrFisStampati = _CtrNoFisStampati = 0; _finite_fis = _finite_nofis = FALSE; _GiaStampatiFis = _GiaStampatiNoFis = FALSE; _EndPrintDitta = FALSE; // Vero se stampato l'ultimo record bool LastRecord = FALSE; // Vero se letto l'ultimo record bool stampa = TRUE; _PaginaCorrente = PRIMA; if (!InitPrint(codditta)) return FALSE; TCursor* cur = cursor(); while (!_EndPrintDitta) { for (int pagina=1; pagina <= QD_PAGINE; pagina++, next_page(pr)) { // pr.formlen(QD_FORMLEN); firma_dichiarante(); if (_PaginaCorrente == PRIMA) { pr.formlen(dic_form_len()); if (_modulaser) ClearFlagModulaser(); bool testata = TRUE; for (int righe=0; righe < QD1_RIGHE_PRIMA; righe++) { stampa = TRUE; // Stampa intestazione, solo sul primo foglio. if (testata) { (*cur) = PtrFis >= 0L ? PtrFis : 0L; const char tipo = cur->curr().get(QD1_TIPOA)[0]; TPrint_section& head = section('H', first_page); if (tipo == 'F') { const bool rit_acc = cur->curr(-14).get_bool("B0"); head.find_field(21).set(rit_acc ? "X" : ""); head.find_field(22).set(rit_acc ? "" : "X"); if (!rit_acc) StampatoRitenutaImposta = TRUE; } else { head.find_field(21).set(""); head.find_field(22).set(""); } stampa_testata(pr); testata = FALSE; } if (_finite_fis || StabilitaInesistenzaFis) break; // La prima volta si deve posizionare sul primo record di p.f. if (PtrFis<0L && !StabilitaInesistenzaFis) { bool Trovato = FALSE; while (!Trovato) { const long ditta = cur->curr().get_long(QD1_CODDITTA); if (ditta != codditta) break; const char tipo = cur->curr().get(QD1_TIPOA)[0]; if (tipo != 'G') { PtrFis = cur->pos(); Trovato = TRUE; break; } else ++(*cur); } StabilitaInesistenzaFis = !Trovato; } if (StabilitaInesistenzaFis) break; (*cur) = PtrFis; const char tipo = cur->curr().get(QD1_TIPOA)[0]; if (tipo != 'F') break; else { const bool rit_acc = cur->curr(-14).get_bool("B0"); if (righe > 0 && !rit_acc && !StampatoRitenutaImposta) break; CtrFis--; if (CtrFis == 0L) _finite_fis = TRUE; real perc_p = cur->curr().get_real(QD1_PERC); stampa = controlla_percentuale(cur,perc_p); if (stampa) set_body(pr, 'F'); else { leggi_importi(); righe--; } // La stampa e' finita se ho STAMPATO l'ultimo record LastRecord = cur->pos() >= _Items-1; _EndPrintDitta = LastRecord; if (!LastRecord) { ++(*cur); PtrFis = cur->pos(); LastRecord = cur->pos() >= _Items-1; } } } // for righe.. PtrFis = cur->pos(); } if (_PaginaCorrente == SECONDA) { // Reset del flag di pagina con posiz. if (_posiziona && _PaginaPosizionamento) _PaginaPosizionamento = FALSE; pr.formlen(dic_form_len()); bool testata = TRUE; for (int righe=0; righe < QD1_RIGHE_SECONDA; righe++) { stampa = TRUE; if (testata) { fill_page(pr, HEADER_D1_SECONDA); testata = FALSE; } if (_finite_fis || StabilitaInesistenzaFis) break; (*cur) = PtrFis; const char tipo = cur->curr().get(QD1_TIPOA)[0]; if (tipo != 'F') break; else { const bool rit_acc = cur->curr(-14).get_bool("B0"); if (!rit_acc && !StampatoRitenutaImposta) break; CtrFis--; if (CtrFis == 0L) _finite_fis = TRUE; real perc_p = cur->curr().get_real(QD1_PERC); stampa = controlla_percentuale(cur,perc_p); if (stampa) set_body(pr, 'F'); else { leggi_importi(); righe--; } LastRecord = cur->pos() >= _Items-1; _EndPrintDitta = LastRecord; if (!LastRecord) { ++(*cur); PtrFis = cur->pos(); LastRecord = cur->pos() >= _Items-1; } } } PtrFis = cur->pos(); } if (_PaginaCorrente == TERZA) { bool testata = TRUE; pr.formlen(dic_form_len()); for (int righe=0; righe < QD1_RIGHE_TERZA; righe++) { stampa = TRUE; if (testata) { fill_page(pr, HEADER_D1_TERZA); _CtrFisStampati = 0; // conta quelli che stampo sulla terza testata = FALSE; } if (_finite_fis || StabilitaInesistenzaFis) break; (*cur) = PtrFis; const char tipo = cur->curr().get(QD1_TIPOA)[0]; if (tipo != 'F') break; else { const bool rit_acc = cur->curr(-14).get_bool("B0"); if (!rit_acc && !StampatoRitenutaImposta) break; CtrFis--; if (CtrFis == 0L) _finite_fis = TRUE; real perc_p = cur->curr().get_real(QD1_PERC); stampa = controlla_percentuale(cur,perc_p); if (stampa) set_body(pr, 'F'); else { leggi_importi(); righe--; } LastRecord = cur->pos() >= _Items-1; _EndPrintDitta = LastRecord; _CtrFisStampati++; if (!LastRecord) { ++(*cur); PtrFis = cur->pos(); LastRecord = cur->pos() >= _Items-1; } } } PtrFis = cur->pos(); } if (_PaginaCorrente == QUARTA) { pr.formlen(dic_form_len()); azzera_totali(); bool testata = TRUE; for (int righe=0; righe < QD1_RIGHE_QUARTA; righe++) { stampa = TRUE; if (testata) { _CtrNoFisStampati = 0; // All'inizio salta le righe in alto fill_page(pr, HEADER_D1_QUARTA); testata = FALSE; } if (_finite_nofis || StabilitaInesistenzaNoFis) break; // La prima volta si deve posizionare sul primo record di p.g. if (PtrNoFis<0L && !StabilitaInesistenzaNoFis) { bool Trovato = FALSE; bool eof = FALSE; (*cur) = PtrFis-1 > 0L ? PtrFis-1 : 0L; // parti dall'inizio while (!Trovato && !eof) { eof = cur->pos() >= _Items-1; const long ditta = cur->curr().get_long(QD1_CODDITTA); if (ditta != codditta) break; const char tipo = cur->curr().get(QD1_TIPOA)[0]; if (tipo != 'F') { PtrNoFis = cur->pos(); Trovato = TRUE; break; } else ++(*cur); } StabilitaInesistenzaNoFis = !Trovato; } if (StabilitaInesistenzaNoFis) break; (*cur) = PtrNoFis; const char tipo = cur->curr().get(QD1_TIPOA)[0]; if (tipo != 'G') break; else { CtrNoFis--; if (CtrNoFis == 0L) _finite_nofis = TRUE; real perc_p = cur->curr().get_real(QD1_PERC); stampa = controlla_percentuale(cur,perc_p); if (stampa) set_body(pr, 'G'); else { leggi_importi(); righe--; } LastRecord = cur->pos() >= _Items-1; _EndPrintDitta = LastRecord; _CtrNoFisStampati++; if (!LastRecord) { ++(*cur); PtrNoFis = cur->pos(); LastRecord = cur->pos() >= _Items-1; } } } PtrNoFis = cur->pos(); firma_dichiarante(); } } // for pagina.. } // while !_EndPrintDitta close_print(); return TRUE; } class TStampaQuadroD1 : public TStampaQuadro { TQuadroD1* _form; TCursor* _cur; protected: virtual bool user_create(); virtual bool user_destroy(); virtual TDicForm* get_form() const { return _form; } virtual TCursor* get_cursor() const { return _cur; } public: TStampaQuadroD1(const char* quadro, char livel); virtual ~TStampaQuadroD1() { } }; TStampaQuadroD1::TStampaQuadroD1(const char* quadro, char liv) : TStampaQuadro(quadro, liv) {} bool TStampaQuadroD1::user_create() { _form = new TQuadroD1("77QD1", quadro()); TString sortkey(80); sortkey.format("CODDITTA|TIPOA|216@->RAGSOC|CODANAGR|CODCAUS|PERC", LF_QUAD1, LF_QUAD1); _cur = new TSorted_cursor(_form->TForm::relation(), sortkey); return TRUE; } bool TStampaQuadroD1::user_destroy() { delete _form; delete _cur; return TRUE; } ///////////////////////////////////////////////////////////////////////////////////////////// // // STAMPA QUADRO G // ///////////////////////////////////////////////////////////////////////////////////////////// class TStampaQuadroG : public TStampaQuadro { private: TQuadroG* _form_g; TDistintaG* _form_gd; TCursor* _cur_g, * _cur_gd; protected: virtual bool user_create(); virtual bool user_destroy(); virtual TDicForm* get_form() const { return _form_g; } virtual TCursor* get_cursor() const { return _cur_g; } virtual bool print_quadro(const int OffsetDitta, const bool modulaser); public: TStampaQuadroG(char livel) : TStampaQuadro("G", livel) { } }; bool TStampaQuadroG::user_create() { _form_g = new TQuadroG("77QG", quadro()); _form_gd = new TDistintaG("77QGD", quadro()); _cur_g = new TCursor(_form_g->TForm::relation()); TString sortkey(80); sortkey.format("CODDITTA|TIPOA|216@->RAGSOC|CODANAGR", LF_QUAGD, LF_QUAGD); _cur_gd = new TSorted_cursor(_form_gd->TForm::relation(), sortkey); _form_gd->set_num_foglio(1); return TRUE; } bool TStampaQuadroG::user_destroy() { delete _form_gd; delete _form_g; delete _cur_gd; delete _cur_g; return TRUE; } // _ditte e' fatto di righe siffatte: // codditta, flag 2 dichiarante, 1 normale, 0 estinto, num_fis, num_nofis, ultima_con_fis, ultima_con_nofis bool TStampaQuadroG::print_quadro(const int OffsetDitta, const bool modulaser) { int start=0, last=0; long items_g, items_gd; items_g = items_gd = 0L; // Setta formlen prima di printer.open per avere la lunghezza giusta nel caso di // stampa a video printer().formlen(QG_FORMLEN); bool ok = printer().open(); _form_g->set_cursor(_cur_g); _form_gd->set_cursor(_cur_gd); _form_g->set_modulaser(modulaser); _form_gd->set_modulaser(modulaser); _form_gd->azzera_totali(); // Dice se deve eseguire il posizionamento del foglio. // Se stampa piu' ditte va eseguito solo sulla prima // Occhio a non spostarlo nel ciclo. _form_g->set_posiziona(TRUE); if (OffsetDitta >= 0) { start = OffsetDitta; last = OffsetDitta; } else last = ditte().items() - 1; for (int i = start; i <= last; i++) { TString CoFiDic(20); TToken_string riga(ditte()[i]); const long codditta = atol(riga.get(0)); const TipoDitta tipo = (TipoDitta)riga.get_int(1); const long fis = riga.get_long(2); const long nofis = riga.get_long(3); const bool LastFis = (bool)riga.get_int(4); const bool LastNoFis = (bool)riga.get_int(5); // I gruppi dich-estinti hanno totali comuni // Si presume che nell'array vengano messi nell'ordine dich-estinti if (tipo == normale || tipo == dichiarante) _form_g->azzera_totali(); if (tipo == estinto) CoFiDic = riga.get(6); // Se e' un dichiarante i totali vanno sull'estinto in cui finiscono o le F o le G const bool StampaTotaliFis = tipo == normale || (tipo == estinto && LastFis); const bool StampaTotaliNoFis = tipo == normale || (tipo == estinto && LastNoFis); // Dice al form se e' questa ditta e' l'ultima con f. o g. _form_gd->can_print_tot_fis(StampaTotaliFis); _form_gd->can_print_tot_nofis(StampaTotaliNoFis); // Dice al form che tipo di ditta si stampa _form_g->set_tipo_ditta(tipo); // Numera i fogli a partire da 1 per ogni ditta normale e da 1 e di seguito negli estinti // per i sogg. dichiaranti if (tipo == normale || tipo == dichiarante) _form_g->set_num_foglio(1); // Se la ditta e' estinta dice al form il cod.fis. del dichiarante if (tipo == estinto) _form_g->set_cofi_dic(CoFiDic); // Dice al form che e' l'ultima ditta if (i == last) _form_gd->set_last_ditta(TRUE); items_g = _form_g->filtra(codditta); items_gd = _form_gd->filtra(codditta); // Dice al form quanto e' lunga la progress-bar _form_g->set_items_gd(items_g, items_gd); _form_g->print(codditta, fis, nofis); // La progind deve essere la stessa tra G e distinta... _form_gd->set_progind(_form_g->progind()); // Passa la progind al form gd ... _form_g->set_progind(NULL); // ... e la toglie dal form g _form_gd->print(codditta, fis, nofis); } printer().close(); return ok; } /////////////////////////////////////////////////////////////////////////////////////////// // // Quadro G-1 // /////////////////////////////////////////////////////////////////////////////////////////// HIDDEN const int QG1_FORMLEN = 72; HIDDEN const int QG1_PAGINE = 1; class TQuadroG1 : public TDicForm { private: long _items; void stampa_prospetto(TPrinter& pr); public: virtual bool print(const long codditta, const long NumFis=0L, const long NumNoFis=0L); //virtual bool print(const long codditta); TQuadroG1(const char* form, const char* quadro) : TDicForm(form, quadro) {} virtual ~TQuadroG1() {} }; bool TQuadroG1::print(const long codditta, const long NumFis, const long NumNoFis) { TCursor* cur = cursor(); TPrinter& pr = printer(); if (!InitPrint(codditta)) return FALSE; pr.formlen(QG1_FORMLEN); if (_modulaser) ClearFlagModulaser(); (*cur) = 0L; stampa_prospetto(pr); return TRUE; } void TQuadroG1::stampa_prospetto(TPrinter& pr) { TPrint_section& head = section('H', 1); const word rr = head.height()-1; TPrintrow& head_row = head.row(rr-1); // Setta il cod.fis. del dichiarante se necessario if (tipo_ditta() == estinto) { TForm_item& cfd = head.find_field(H_COFI_DIC); cfd.set(_cofi_dic); } TCursor* cur = cursor(); // Prospetto TRectype& r = cur->curr(); TToken_string p12(r.get("P12")); TToken_string p13(r.get("P13")); TToken_string p14(r.get("P14")); TToken_string p15(r.get("P15")); TToken_string p16(r.get("P16")); TToken_string p17(r.get("P17")); const int START_PROSP = 56; const int RIGHE_COL356 = 12; const int RIGHE_COL27 = 5; const int COL_PROSP = 5; // Colonne 2 e 7 for (int i = 0; i < RIGHE_COL27; i++) { const int fc2 = START_PROSP + i; TForm_item& c2 = head.find_field(fc2); c2.set(p12.get(i)); const int fc7 = fc2 + RIGHE_COL27 + 1; TForm_item& c7 = head.find_field(fc7); c7.set(p17.get(i)); } const int START_COL3 = 68; // Colonne 3 5 e 6 for (i = 0; i < RIGHE_COL356; i++) { const int fc3 = START_COL3 + i; TForm_item& c3 = head.find_field(fc3); c3.set(p13.get(i)); const int fc5 = fc3 + RIGHE_COL356 + 1; TForm_item& c5 = head.find_field(fc5); c5.set(p15.get(i)); const int fc6 = fc5 + RIGHE_COL356 + 1; TForm_item& c6 = head.find_field(fc6); c6.set(p16.get(i)); } // Righe da saltare nelle prime pag. dei moduli successivi al primo (che' son // senza le righe del posizionamento...) int HEADER_PRIMA_NOPOS = 3; head.update(); for (word j = 0; j <= rr; j++) { if (j==0) { if (_modulaser) { TPrintrow& r = head.row(j); if (!_GiaMessoStartDoc) put_modulaser(r, STARTDOC); put_modulaser(r, STARTDITTA); put_modulaser(r, STARTPAGE, 1); pr.print(r); _RigaCorr++; r.reset(); HEADER_PRIMA_NOPOS--; } if (!PaginaPosizionamento()) fill_page(pr, HEADER_PRIMA_NOPOS); } else { pr.print(head.row(j)); _RigaCorr++; } } } ///////////////////////////////////////////////////////////////////////////////////////////// // // STAMPA QUADRO G-1 // ///////////////////////////////////////////////////////////////////////////////////////////// class TStampaQuadroG1 : public TStampaQuadroD { private: TQuadroG1* _form; TRelation* _rel; TCursor* _cur; protected: virtual bool user_create(); virtual bool user_destroy(); virtual TDicForm* get_form() const { return _form; } virtual TCursor* get_cursor() const { return _cur; } virtual bool conta_tipi_per() const { return FALSE; } public: TStampaQuadroG1(char livel) : TStampaQuadroD("G1", livel) {} }; bool TStampaQuadroG1::user_create() { _form = new TQuadroG1("77QG1", quadro()); _rel = new TRelation(LF_QUAG1); _rel->add(LF_NDITTE, "CODDITTA=CODDITTA"); _rel->add(LF_ANAG, "TIPOA=TIPOA|CODANAGR=CODANAGR", 1, LF_NDITTE, 116); _rel->add(LF_ANAGFIS, "CODANAGR=CODANAGR", 1, LF_ANAG, 118); _rel->add(LF_COMUNI, "COM=COMNASC", 1, LF_ANAGFIS, 113); _rel->add(LF_COMUNI, "COM=COMRF(COMRES)", 1, LF_ANAG, 213); _cur = new TCursor(_rel); return TRUE; } bool TStampaQuadroG1::user_destroy() { delete _cur; delete _rel; delete _form; return TRUE; } /* // _ditte e' fatto di righe siffatte: // codditta, flag 2 dichiarante, 1 normale, 0 estinto, num_fis, num_nofis, ultima_con_fis, ultima_con_nofis bool TStampaQuadroG1::print_quadro(TString& quadro, const int OffsetDitta) { int start=0, last=0; // Setta formlen prima di printer.open per avere la lunghezza giusta nel caso di // stampa a video printer().formlen(QG_FORMLEN); bool ok = printer().open(); bool modulaser = _m->get_bool(F_MODULASER); _form->set_cursor(_rel, _cur); _form->set_modulaser(modulaser); // Dice se deve eseguire il posizionamento del foglio. // Se stampa piu' ditte va eseguito solo sulla prima // Occhio a non spostarlo nel ciclo. _form->set_posiziona(TRUE); if (OffsetDitta >= 0) { start = OffsetDitta; last = OffsetDitta; } else last = _ditte.items() - 1; for (int i = start; i <= last; i++) { TString CoFiDic(20); TToken_string riga(_ditte[i]); riga.separator('|'); const long codditta = atol(riga.get(0)); const TipoDitta tipo = (TipoDitta)riga.get_int(1); // I gruppi dich-estinti hanno totali comuni // Si presume che nell'array vengano messi nell'ordine dich-estinti if (tipo == normale || tipo == dichiarante) _form->azzera_totali(); if (tipo == estinto) CoFiDic = riga.get(6); // Dice al form che tipo di ditta si stampa _form->set_tipo_ditta(tipo); // Numera i fogli a partire da 1 per ogni ditta normale e da 1 e di seguito negli estinti // per i sogg. dichiaranti if (tipo == normale || tipo == dichiarante) _form->set_num_foglio(1); // Se la ditta e' estinta dice al form il cod.fis. del dichiarante if (tipo == estinto) _form->set_cofi_dic(CoFiDic); // Dice al form che e' l'ultima ditta if (i == last) _form->set_last_ditta(TRUE); _form->print(codditta); } printer().close(); return ok; } */ /* void TStampaQuadroG1::fill_estinti(const long CodDic) { int NumFisiche=0, NumNoFisiche=0; TString CodFiDic(20); // Salva il cod.fis. del dichiarante CodFiDic = cod_fis(CodDic); _ditte.add(CodDic, dichiarante); const int index_dich = _ditte.curr_index(); int index = index_dich; // Leggo gli estinti TLocalisamfile base(LF_BASE); base.setkey(2); base.zero(); base.put(BSE_CODDIC, (long)CodDic); TRectype dep(base.curr()); for (base.read(); !base.eof(); base.next()) { if (base.curr() > dep) break; // Scarta il record del quadro I "globale" del dichiarante const char tipoqua = base.get(BSE_TIPOQUA)[0]; if (tipoqua == COD_QUA_I_DIC) continue; const long DittaEstinta = base.get_long(BSE_CODDITTA); _ditte.add(DittaEstinta, estinto, 0L, 0L, FALSE, FALSE, CodFiDic); index++; } } */ /* void TStampaQuadroG1::print() { int NumFisiche=0, NumNoFisiche=0; _ditte.destroy(); // Pulisce l'array delle ditte if (_singola_ditta) { if (sogg_estinto(_codditta)) { warning_box("La ditta %ld e' un soggetto estinto", _codditta); return; } // Se e' un dichiarante va a prendere tutti i suoi estinti. bool dich = sogg_dic(_codditta); if (dich) fill_estinti(_codditta); else _ditte.add(_codditta, normale); } else // stampa ditte selezionate { // Costruisco un'array delle ditte da stampare. // Tolgo i sogg. estinti, e dopo un dichiarante metto tutti i suoi estinti. long codditta_prec = get_firm_770(); long codditta = 0L; int i=0; while ((codditta = _cnf->get_long(DITTE_SEL, _section, i++)) != 0L) { if (sogg_estinto(codditta)) continue; // Se e' un dichiarante va a prendere tutti i suoi estinti. bool dich = sogg_dic(codditta); if (dich) fill_estinti(codditta); else _ditte.add(codditta, normale); } set_firm_770(codditta_prec); } print_quadro(_quadro, -1); } */ /////////////////////////////////////////////////////////////////////////////////////////// // // Quadro F // /////////////////////////////////////////////////////////////////////////////////////////// HIDDEN const int QF_FORMLEN = 72; HIDDEN const int QF_PAGINE = 2; HIDDEN const int HEADER_SECONDA_F = 7; class TQuadroF : public TDicForm { private: real pa3t, pa4t, pa5t, pa6t, pa7t; // totali prosp. A real pb3t, pb4t, pc3t, pc4t, pd3t, pd4t; // totali prosp, B, C e D int _ptrA, _ptrB, _ptrC, _ptrD; // puntatori alle righe dei prospetti long _items; int stampa_prospetto_A(TPrinter& pr); int stampa_prospetto_B(TPrinter& pr); int stampa_prospetto_C(TPrinter& pr); int stampa_prospetto_D(TPrinter& pr); TRecord_array* _prosp_a, *_prosp_b, *_prosp_c, *_prosp_d; void azzera_contatori(); void aggiorna_totali(char tipoprosp, TRectype& r); void stampa_totali(char tipoprosp, TPrinter& pr); virtual bool ultima_pagina() const { return _PaginaCorrente==SECONDA; } public: virtual bool print(const long codditta, const long numfis=0L, const long numnofis=0L); virtual void inc_curr_page(); virtual void next_page(TPrinter& pr); TQuadroF(const char* form, const char* quadro) : TDicForm(form, quadro) {} virtual ~TQuadroF() {} }; void TQuadroF::azzera_contatori() { pa3t = pa4t = pa5t = pa6t = pa7t = ZERO; pb3t=pb4t=pc3t=pc4t=pd3t=pd4t = ZERO; // totali prosp, B, C e D _ptrA = _ptrB = _ptrC = _ptrD = 1; } void TQuadroF::stampa_totali(char tipoprosp, TPrinter& pr) { const int PA3_TOT = 104; const int PB3_TOT = 54; TPrint_section& sez = tipoprosp == 'A' ? section('H', 1) : section('B', 1); const int rr = sez.height()-1; int i = PA3_TOT, riga_tot=0; switch (tipoprosp) { case 'A': { riga_tot = 46; TForm_item& c = sez.find_field(i++); TString c3(pa3t.string()); c.set(c3); c = sez.find_field(i++); TString c4(pa4t.string()); c.set(c4); c = sez.find_field(i++); TString c5(pa5t.string()); c.set(c5); c = sez.find_field(i++); TString c6(pa6t.string()); c.set(c6); c = sez.find_field(i++); TString c7(pa7t.string()); c.set(c7); break; } case 'B': { i = PB3_TOT; riga_tot = 14; TForm_item& c = sez.find_field(i++); TString c3(pb3t.string()); c.set(c3); c = sez.find_field(i); TString c4(pb4t.string()); c.set(c4); break; } case 'C': { i = PB3_TOT+2; riga_tot = 20; TForm_item& c = sez.find_field(i++); TString c3(pc3t.string()); c.set(c3); c = sez.find_field(i); TString c4(pc4t.string()); c.set(c4); break; } case 'D': { i = PB3_TOT+4; riga_tot = 26; TForm_item& c = sez.find_field(i++); TString d3(pd3t.string()); c.set(d3); c = sez.find_field(i); TString d4(pd4t.string()); c.set(d4); break; } default: break; } sez.update(); pr.print(sez.row(riga_tot)); _RigaCorr++; if (usa_progind()) progind()->addstatus(1); fill_page(pr, -1); // formfeed "adattato" inc_curr_page(); } void TQuadroF::aggiorna_totali(char tipoprosp, TRectype& r) { real sogg,rope,acc,ecc,sal; switch (tipoprosp) { case 'A': sogg = r.get_real(QUF_SOGRIT); rope = r.get_real(QUF_ROPE); acc = r.get_real(QUF_ACCONTI); ecc = r.get_real(QUF_VERSECC); sal = r.get_real(QUF_VERSALDO); pa3t += sogg; pa4t += rope; pa5t += acc; pa6t += ecc; pa7t += sal; break; case 'B': sogg = r.get_real(QUF_SOGRIT); rope = r.get_real(QUF_ROPE); pb3t += sogg; pb4t += rope; break; case 'C': sogg = r.get_real(QUF_SOGRIT); rope = r.get_real(QUF_ROPE); pc3t += sogg; pc4t += rope; break; case 'D': sogg = r.get_real(QUF_SOGRIT); rope = r.get_real(QUF_ROPE); pd3t += sogg; pd4t += rope; break; default: break; } } void TQuadroF::next_page(TPrinter& pr) { PaginaQuadro PagCorr = curr_page(); // if (PagCorr = SECONDA) stampa_totali(pr); fill_page(pr, -1); // formfeed "adattato" inc_curr_page(); } void TQuadroF::inc_curr_page() { if (_PaginaCorrente == PRIMA) _PaginaCorrente = SECONDA; else if (_PaginaCorrente == SECONDA) _PaginaCorrente = PRIMA; } bool TQuadroF::print(const long codditta, const long numfis, const long numnofis) { bool EndPrint=FALSE, End_A=FALSE, End_B=FALSE, End_C=FALSE, End_D=FALSE; int residui_A=0, residui_B=0, residui_C=0, residui_D=0; TCursor* cur = cursor(); TPrinter& pr = printer(); if (!InitPrint(codditta)) return FALSE; azzera_contatori(); TLocalisamfile& rf = cur->file(LF_RIGHEF); TRectype dep(rf.curr()); dep.zero(); dep.put("CODDITTA", _codditta); dep.put("TIPOPRO", "A"); _prosp_a = new TRecord_array(dep, "NPROG"); dep.put("TIPOPRO", "B"); _prosp_b = new TRecord_array(dep, "NPROG"); dep.put("TIPOPRO", "C"); _prosp_c = new TRecord_array(dep, "NPROG"); dep.put("TIPOPRO", "D"); _prosp_d = new TRecord_array(dep, "NPROG"); pr.formlen(QG1_FORMLEN); while (!EndPrint) { for (int pagina=1; pagina <= QF_PAGINE; pagina++, next_page(pr)) { if (_PaginaCorrente == PRIMA) { if (_modulaser) ClearFlagModulaser(); if (End_A) break; (*cur) = 0L; residui_A = stampa_prospetto_A(pr); End_A = (residui_A == 0); if (End_A) stampa_totali('A', pr); _EndPrintDitta=EndPrint = End_A && End_B && End_C && End_D; } if (_PaginaCorrente == SECONDA) { // Reset del flag di pagina con posiz. if (_posiziona && _PaginaPosizionamento) _PaginaPosizionamento = FALSE; if (End_B && End_C && End_D) break; fill_page(pr, HEADER_SECONDA_F); residui_B = stampa_prospetto_B(pr); End_B = (residui_B == 0); if (End_B) stampa_totali('B', pr); residui_C = stampa_prospetto_C(pr); End_C = (residui_C == 0); if (End_C) stampa_totali('C', pr); residui_D = stampa_prospetto_D(pr); End_D = (residui_D == 0); if (End_D) stampa_totali('D', pr); _EndPrintDitta=EndPrint = End_A && End_B && End_C && End_D; } } // for pagina.. } // EndPrint() close_print(); return TRUE; } const int F_DESC_CAUS = 50; const int RIGHE_PROSP = 3; int TQuadroF::stampa_prospetto_C(TPrinter& pr) { TPrint_section& sez = section('B', 1); const int rr = sez.height()-1; const int START_C = 16; const int last_c = _prosp_c->last_row(); for (int i=0; i < RIGHE_PROSP; _ptrC++, i++) { if (_ptrC > last_c) break; TRectype& r = _prosp_c->row(_ptrC, TRUE); aggiorna_totali('C', r); TString16 codcau(r.get(QUF_CODCAUS)); TString descr_cau(get_desc_cau(codcau)); TString16 aliq (r.get(QUF_ALIQUOTA)); TString sogg (r.get(QUF_SOGRIT)); TString rope (r.get(QUF_ROPE)); const int fc0 = START_C + _ptrC - 1; TString16 nord; nord << _ptrC; TForm_item& c0 = sez.find_field(fc0); c0.set(nord); const int fc1 = fc0 + RIGHE_PROSP; TForm_item& c1 = sez.find_field(fc1); c1.set(descr_cau); const int fc2 = fc1 + RIGHE_PROSP; TForm_item& c2 = sez.find_field(fc2); c2.set(aliq); const int fc3 = fc2 + RIGHE_PROSP; TForm_item& c3 = sez.find_field(fc3); c3.set(sogg); const int fc4 = fc3 + RIGHE_PROSP; TForm_item& c4 = sez.find_field(fc4); c4.set(rope); } const int res_C = last_c - _ptrC; return res_C < 0 ? 0 : res_C; } int TQuadroF::stampa_prospetto_D(TPrinter& pr) { TPrint_section& sez = section('B', 1); const int rr = sez.height()-1; const int START_D = 31; const int last_d = _prosp_d->last_row(); for (int i=0; i < RIGHE_PROSP; _ptrD++, i++) { if (_ptrD > last_d) break; TRectype& r = _prosp_d->row(_ptrD, TRUE); aggiorna_totali('D', r); TString16 codcau(r.get(QUF_CODCAUS)); TString descr_cau(get_desc_cau(codcau)); TString16 aliq (r.get(QUF_ALIQUOTA)); TString sogg (r.get(QUF_SOGRIT)); TString rope (r.get(QUF_ROPE)); const int fc0 = START_D + _ptrD - 1; TString16 nord; nord << _ptrD; TForm_item& c0 = sez.find_field(fc0); c0.set(nord); const int fc1 = fc0 + RIGHE_PROSP; TForm_item& c1 = sez.find_field(fc1); c1.set(descr_cau); const int fc2 = fc1 + RIGHE_PROSP; TForm_item& c2 = sez.find_field(fc2); c2.set(aliq); const int fc3 = fc2 + RIGHE_PROSP; TForm_item& c3 = sez.find_field(fc3); c3.set(sogg); const int fc4 = fc3 + RIGHE_PROSP; TForm_item& c4 = sez.find_field(fc4); c4.set(rope); } sez.update(); for (i=0; i < rr; i++) { pr.print(sez.row(i)); _RigaCorr++; } if (usa_progind()) progind()->addstatus(1); const int res_D = last_d - _ptrD; return res_D < 0 ? 0 : res_D; } int TQuadroF::stampa_prospetto_B(TPrinter& pr) { TPrint_section& sez = section('B', 1); const int rr = sez.height()-1; const int START_B = 1; const int last_b = _prosp_b->last_row(); for (int i=0; i < RIGHE_PROSP; _ptrB++, i++) { if (_ptrB > last_b) break; TRectype& r = _prosp_b->row(_ptrB, TRUE); aggiorna_totali('B', r); TString dep(50); dep = r.get(QUF_CODCAUS); TString descr_cau(get_desc_cau(dep)); TString16 aliq (r.get(QUF_ALIQUOTA)); TString sogg (r.get(QUF_SOGRIT)); TString rope (r.get(QUF_ROPE)); const int fc0 = START_B + _ptrB - 1; TString16 nord; nord << _ptrB; TForm_item& c0 = sez.find_field(fc0); c0.set(nord); const int fc1 = fc0 + RIGHE_PROSP; TForm_item& c1 = sez.find_field(fc1); c1.set(descr_cau); const int fc2 = fc1 + RIGHE_PROSP; TForm_item& c2 = sez.find_field(fc2); c2.set(aliq); const int fc3 = fc2 + RIGHE_PROSP; TForm_item& c3 = sez.find_field(fc3); c3.set(sogg); const int fc4 = fc3 + RIGHE_PROSP; TForm_item& c4 = sez.find_field(fc4); c4.set(rope); } // TBI setta totali e descr.causale F TString16 fcau(cursor()->curr(LF_QUAF).get(QUF_FCAUS)); TString descr_cau(get_desc_cau(fcau)); TForm_item& fd = sez.find_field(F_DESC_CAUS); fd.set(descr_cau); const int res_B = last_b - _ptrB; return res_B < 0 ? 0 : res_B; } int TQuadroF::stampa_prospetto_A(TPrinter& pr) { TPrint_section& head = section('H', 1); const word rr = head.height()-1; TPrintrow& head_row = head.row(rr-1); // Setta il cod.fis. del dichiarante se necessario if (tipo_ditta() == estinto) { TForm_item& cfd = head.find_field(H_COFI_DIC); cfd.set(_cofi_dic); } TCursor* cur = cursor(); const int START_PROSP = 56; const int RIGHE_PROSP = 6; const int COL_PROSP = 8; const int last_a = _prosp_a->last_row(); for (int i=0; i < RIGHE_PROSP ; _ptrA++, i++) { if (_ptrA > last_a) break; TRectype& r = _prosp_a->row(_ptrA, TRUE); aggiorna_totali('A', r); TString16 codcau(r.get(QUF_CODCAUS)); TString descr_cau(get_desc_cau(codcau)); TString16 aliq (r.get(QUF_ALIQUOTA)); TString sogg (r.get(QUF_SOGRIT)); TString rope (r.get(QUF_ROPE)); TString acc(r.get(QUF_ACCONTI)); TString ecc(r.get(QUF_VERSECC)); TString sal(r.get(QUF_VERSALDO)); const int fc0 = START_PROSP + _ptrA - 1; TString16 nord; nord << _ptrA; TForm_item& c0 = head.find_field(fc0); c0.set(nord); const int fc1 = fc0 + RIGHE_PROSP; TForm_item& c1 = head.find_field(fc1); c1.set(descr_cau); const int fc2 = fc1 + RIGHE_PROSP; TForm_item& c2 = head.find_field(fc2); c2.set(aliq); const int fc3 = fc2 + RIGHE_PROSP; TForm_item& c3 = head.find_field(fc3); c3.set(sogg); const int fc4 = fc3 + RIGHE_PROSP; TForm_item& c4 = head.find_field(fc4); c4.set(rope); const int fc5 = fc4 + RIGHE_PROSP; TForm_item& c5 = head.find_field(fc5); c5.set(acc); const int fc6 = fc5 + RIGHE_PROSP; TForm_item& c6 = head.find_field(fc6); c6.set(ecc); const int fc7 = fc6 + RIGHE_PROSP; TForm_item& c7 = head.find_field(fc7); c7.set(sal); } // Righe da saltare nelle prime pag. dei moduli successivi al primo (che' son // senza le righe del posizionamento...) int HEADER_PRIMA_NOPOS = 3; head.update(); for (word j = 0; j <= rr; j++) { if (j==0) { if (_modulaser) { TPrintrow& r = head.row(j); if (!_GiaMessoStartDoc) put_modulaser(r, STARTDOC); put_modulaser(r, STARTDITTA); put_modulaser(r, STARTPAGE, 1); pr.print(r); _RigaCorr++; r.reset(); HEADER_PRIMA_NOPOS--; } if (!PaginaPosizionamento()) fill_page(pr, HEADER_PRIMA_NOPOS); } else { pr.print(head.row(j)); _RigaCorr++; } } const int res = last_a - _ptrA; return res < 0 ? 0 : res; } ///////////////////////////////////////////////////////////////////////////////////////////// // // STAMPA QUADRO F // ///////////////////////////////////////////////////////////////////////////////////////////// class TStampaQuadroF : public TStampaQuadro { private: TQuadroF* _form; TRelation* _rel; TCursor* _cur; protected: virtual bool conta_tipi_per() const { return FALSE; } virtual TDicForm* get_form() const { return _form; } virtual TCursor* get_cursor() const { return _cur; } virtual bool user_create(); virtual bool user_destroy(); public: TStampaQuadroF(char livel) : TStampaQuadro("F", livel) { } }; bool TStampaQuadroF::user_create() { _form = new TQuadroF("77QF", quadro()); _rel = new TRelation(LF_QUAF); _rel->add(LF_RIGHEF, "CODDITTA=CODDITTA"); _rel->add(LF_NDITTE, "CODDITTA=CODDITTA", 1, LF_QUAF); _rel->add(LF_ANAG, "TIPOA=TIPOA|CODANAGR=CODANAGR", 1, LF_NDITTE, 116); _rel->add(LF_ANAGFIS, "CODANAGR=CODANAGR", 1, LF_ANAG, 118); _rel->add(LF_COMUNI, "COM=COMNASC", 1, LF_ANAGFIS, 113); _rel->add(LF_COMUNI, "COM=COMRF(COMRES)", 1, LF_ANAG, 213); _cur = new TCursor(_rel); return TRUE; } bool TStampaQuadroF::user_destroy() { delete _cur; delete _rel; delete _form; return TRUE; } ///////////////////////////////////////////////////////////////////////////////// // Busta ///////////////////////////////////////////////////////////////////////////////// class TBusta : public TDicForm { protected: virtual bool print(const long codditta, const long, const long); virtual int prima_riga(PaginaQuadro p) const; public: TBusta(const char* form, const char* quadro) : TDicForm(form, quadro) { } virtual ~TBusta() { } }; bool get_alleg_730(const long codditta) { TLocalisamfile base(LF_BASE); base.zero(); base.put("CODDITTA",(long)codditta); if (base.read()==NOERR) { const long allegA=base.get_long("N730ALLA"); const long allegA2=base.get_long("N730ALLA2"); return allegA || allegA2; } else return FALSE; } HIDDEN const int BUSTA_CON_POSIZ = 53; HIDDEN const int BUSTA_SENZA_POSIZ = 56; int TBusta::prima_riga(PaginaQuadro p) const { return HEADER_PRIMA_NOPOS-1; } bool TBusta::print(const long codditta, const long, const long) { const bool ok = InitPrint(codditta); if (ok) { // Calcola identificatore del quadretto corrispondente al quadro L TForm_item& dietor = find_field('B', odd_page, 740); const int anno = anno_770(); const bool elle = esiste_record_L(codditta, anno); dietor.set(elle ? "X" : ""); TForm_item& all730 = find_field('B', odd_page, 20); const bool bAlleg730 = get_alleg_730(codditta); all730.set(bAlleg730 ? "X" : ""); TPrinter& pr=printer(); TPrint_section& body = section('B', odd_page); const int body_righe = body.height(); TCursor* cur=cursor(); bool finito=FALSE; (*cur)=0L; pr.formlen(BUSTA_CON_POSIZ); if (!_PaginaPosizionamento) jump_to_line(pr,prima_riga(PRIMA)); while (!finito) { body.reset(); body.update(); for (int i=0; i < body_righe; i++) { pr.print(body.row(i)); _RigaCorr++; } if (usa_progind()) progind()->addstatus(1); ++(*cur); finito= cur->pos() >= cur->items()-1; pr.formlen(BUSTA_SENZA_POSIZ); _PaginaPosizionamento=FALSE; } // TForm::print(0); } return ok; } class TStampaBusta : public TStampaQuadro { TDicForm* _form; protected: // TStampaQuadro virtual bool user_create(); virtual bool user_destroy(); virtual bool conta_tipi_per() const { return FALSE; } virtual TDicForm* get_form() const { return _form; } virtual TCursor* get_cursor() const { return _form->TForm::cursor(); } virtual bool print_quadro(const int OffsetDitta, const bool modulaser); public: TStampaBusta(const char* quadro, char livel); virtual ~TStampaBusta() { } }; TStampaBusta::TStampaBusta(const char* quadro, char livel) : TStampaQuadro(quadro, livel), _form(NULL) { set_taitol("Stampa buste"); } bool TStampaBusta::user_create() { _form = new TBusta("77Busta", quadro()); return TRUE; } bool TStampaBusta::user_destroy() { delete _form; _form = NULL; return TRUE; } bool TStampaBusta::print_quadro(const int OffsetDitta, const bool modulaser) { TDicForm* ff = get_form(); ff->set_cursor(get_cursor()); // Setta formlen prima di printer.open per avere la lunghezza giusta nel caso di stampa a video printer().formlen(ff->height()); bool ok = printer().open(); ff->set_modulaser(modulaser); ff->set_arrange(FALSE); ff->set_posiziona(TRUE); int start = 0, last = 0; if (OffsetDitta >= 0) { start = OffsetDitta; last = OffsetDitta; } else last = ditte().items() - 1; for (int i = start; i <= last; i++) { TToken_string& riga = ditte()[i]; const long codditta = riga.get_long(0); const TipoDitta tipo = (TipoDitta)riga.get_int(); if (tipo != estinto) ff->print(codditta, 0, 0); } printer().close(); return ok; } /////////////////////////////////////////////////////////////////////////////////////////// // // BASE // /////////////////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////// // // MAIN // // Uso: // 772mod -4 [QUADRO] [ LIVELLO {S|D} ] // ///////////////////////////////////////////////////////////////////////////////// int stampa_quadro(int argc, char* argv[]) { if (argc >= 4) { const TFixed_string quadro(argv[2]); const char livello = *argv[3]; TStampaQuadro* app = NULL; if ( quadro == "C" ) { app = new TStampaQuadroC(quadro, livello); } else if ( quadro == "D" ) { app = new TStampaQuadroD(quadro, livello); } else if (quadro == "D1") { app = new TStampaQuadroD1(quadro, livello); } else if (quadro[0] == 'A') { switch (quadro[1] - '0') { case 1: app = new TStampaQuadroA1(quadro, livello); break; case 2: app = new TStampaQuadroA2(quadro, livello); break; case 3: app = new TStampaQuadroA3(quadro, livello); break; default: app = new TStampaQuadroA(quadro, livello); break; } } else if (quadro[0] == 'B' && quadro[1] != 'a') { switch (toupper(quadro[1])) { case 'U': app = new TStampaBusta(quadro, livello); break; default : app = new TStampaQuadroB(quadro, livello); break; } } else if (quadro == "F") { app = new TStampaQuadroF(livello); } else if (quadro == "G") { app = new TStampaQuadroG(livello); } else if (quadro == "G1") { app = new TStampaQuadroG1(livello); } else if (quadro == "Base") { app = new TStampaBase(livello); } else if (quadro == "H") { app = new TStampaQuadroH(quadro, livello); } else if (quadro == "L") { app = new TStampaQuadroAggL(quadro, livello); } if (app != NULL) { app->run(argc, argv, app->taitol()); delete app; } } return 0; }