// -------------------------------------------------------------------------- // Scadenzario // fv 24/8/94 // -------------------------------------------------------------------------- #include #include "cg2102.h" #include "cg2100.h" #include "cg21sld.h" #include "pagament.h" #include #include #include bool TPrimanota_application::pag_notify(int r, KEY k) { TPagamento& pag = app().pagamento(); TSheet_field& ps = app().pags(); TMask* msk = &(app().curr_mask()); TString_array& rws = app().pag_rows(); int rdiff = atoi(msk->get(FS_RDIFFER)); // ts contiene la vecchia riga, ns la nuova TToken_string ts(36), ns(36); bool doit = TRUE, m_imp = FALSE, m_perc = FALSE, m_pag = FALSE; bool m_scad = FALSE, m_tipo = FALSE, mod = FALSE; word ahiahi = P_OK; TString news(15), newi(15), newp(15), newt(2); bool recalc = msk->get_bool(FS_RECALC); bool mcomm = msk->get_bool(FS_MCOMM); switch (k) { case K_SPACE: break; case K_ENTER: ns = ps.row(r); ts = rws.row(r); news = ns.get(0); newp = ns.get(1); newi = ns.get(2); newt = ns.get(3); // qui viene il bello, si fa per dire if (news != ts.get(0)) // modificata data scadenza { mod = m_scad = TRUE; } if (newp != ts.get(1)) // modificata percentuale { mod = m_perc = TRUE; } if (newi != ts.get(2)) // modificato importo { // se si modifica la percentuale l'importo non viene cagato if ((recalc && !m_perc) || (!recalc)) { mod = m_imp = TRUE; } } if (newt != ts.get(3)) // modificato tipo pagamento { mod = m_tipo = TRUE; } break; case K_DEL: case K_INS: doit = FALSE; break; default: break; } // settato da recalc_rate se occorre ridefinire lo sheet // aggiungendo o togliendo righe bool need_recalc = FALSE; if (k == K_ENTER) { if (mod && recalc) { // ricalcola sheet come sai fare tu ahiahi = pag.recalc_rate(r, m_perc, ((m_perc || m_imp) ? (m_perc ? (const char*)newp : (const char*)newi) : NULL), (m_scad ? (const char*)news : NULL), (m_tipo ? (const char*)newt : NULL), rdiff, mcomm, need_recalc); // see if rdiff changed msk->set(FS_RDIFFER, pag.rate_differenziate() ? "1" : "2"); } if (!recalc) { ahiahi = P_OK; // put data as they are TToken_string& trw = pag.rata(r); TToken_string srw = trw; if (m_scad) trw.add(news,3); if (m_perc) trw.add(newp,1); if (m_imp) trw.add(newi,4); if (m_tipo) trw.add(newt,2); // validate the payment if ((ahiahi = pag.validate()) != P_OK) pag.rata(r) = srw; } if (ahiahi) // any error? Rimetti le righe com'erano prima { beep(); // se gli errori sono voluti, spiegali if (!recalc) { TString256 s; pag.strerr(ahiahi,s); warning_box(s); } ps.row(r) = rws.row(r); ps.force_update(r); } else if (recalc && mod && need_recalc) { // ridefinisci lo sheet sulla base delle nuove rate pag.set_sheet(ps); ps.force_update(); rws = ps.rows_array(); } } return doit; } bool TPrimanota_application::codpag_handler(TMask_field& f, KEY key) { TMask& m = f.mask(); if (key == K_TAB && (f.focusdirty() || !m.is_running()) && app().is_saldaconto()) { const TString16 dt(m.get(F_DATAREG)); app().set_pagamento(f.get(), dt); app().set_scadenze(m); } return TRUE; } void TPrimanota_application::set_pagamento(const char* c, const char* d) { if (_pag != NULL) delete _pag; _pag = new TPagamento(c,d); } void TPrimanota_application::set_scadenze(TMask& m) { const real imponibile(m.get(F_IMPONIBILI)); const real imposta(m.get(F_IMPOSTE)); const real spese(0.0); TPagamento& pag = pagamento(); if (pag.is_new()) { m.disable_page(2); return; } else m.enable_page(2); m.set(FS_RDIFFER, pag.rate_differenziate() ? "1" : "2"); m.set(FS_NAMEPAG, pag.name()); m.set(FS_TIPOPR, pag.desc_tpr()); m.set(FS_MCOMM, pag.mese_commerciale() ? "X" : ""); m.set(FS_RECALC, "X", TRUE); pag.set_total(imponibile, imposta, spese); pag.set_rate_auto(); bool new_part = TRUE; TSheet_field& ps = (TSheet_field&)m.field(FS_RATESHEET); // prepara lo sheet pag.set_sheet(ps); _pag_rows = ps.rows_array(); // se la prima rata e' fissa non si tocca if (pag.tipo_prima_rata() > 0) { ps.disable_cell(0,0); ps.disable_cell(0,1); ps.disable_cell(0,2); ps.disable_cell(0,3); } } bool TPrimanota_application::read_scadenze(TMask& m) { // should never happen but it doesn't hurt if (_rel->cg(0).empty()) return FALSE; const real imponibile(m.get(F_IMPONIBILI)); const real imposta(m.get(F_IMPOSTE)); const real spese(0.0); TSheet_field& ps = (TSheet_field&)m.field(FS_RATESHEET); m.set(FS_RECALC, "X"); TPagamento& pag = pagamento(); pag.set_total(imponibile, imposta, spese); TLocalisamfile partita (LF_PARTITE); TLocalisamfile scadenza(LF_SCADENZE); const TRectype& testa = _rel->lfile().curr(); const long nreg = testa.get_long("NUMREG"); const TString16 ndoc(testa.get("NUMDOC")); const int tmov = testa.get_int("TIPOMOV"); const TDate ddoc(testa.get_date("DATADOC")); const TDate dreg(testa.get_date("DATAREG")); const TString16 reg (testa.get("REG")); const long protiva = testa.get_long("PROTIVA"); const TString16 codcaus(testa.get("CODCAUS")); const TString16 codval (testa.get("CODVAL")); const real cambio(testa.get("CAMBIO")); const TString16 numpart(m.get(F_NUMRIF)); const int anno = m.get_int(F_ANNORIF); const TRectype& prima = _rel->cg(0); const char sezione = prima.get_char("SEZIONE"); // Dare/Avere const char tipocf = prima.get_char("TIPOC"); // Cliente || Fornitore || Uncazzo const int gruppo = (tipocf == 'C' || tipocf == 'F') ? 0 : prima.get_int("GRUPPO"); const int conto = (tipocf == 'C' || tipocf == 'F') ? 0 : prima.get_int("CONTO"); const long sottoconto = prima.get_long("SOTTOCONTO"); const int nriga = 1; const int numrig = 1; partita.put(PART_ANNO, anno); partita.put(PART_NUMPART, numpart); partita.put(PART_NRIGA, nriga); bool fromscratch = FALSE; if (partita.read() == NOERR) { // se si e' specificato un codice pagamento diverso si rifa' da capo if (pag.code() != partita.get("CODPAG")) fromscratch = TRUE; // se invece la maschera contiene importi diversi da quelli // registrati si passa la palla al culano else if (imponibile != partita.get_real(PART_IMPORTO) || imposta != partita.get_real(PART_IMPOSTA) || spese != partita.get_real(PART_SPESE)) { fromscratch = !yesno_box("Gli importi totali delle scadenze sono stati modificati rispetto" " all'ultima registrazione. Si desidera mantenere" " comunque la rateazione precedente"); // nel caso, of course, si disabilitano gli automatismi if(!fromscratch) m.field(FS_RECALC).set(""); } if (fromscratch) pag.set_rate_auto(); else { pag.zap_rate(); for (int i = 0; ; i++) { // cerca rata scadenza.zero(); scadenza.put(PART_ANNO, anno); scadenza.put(PART_NUMPART, numpart); scadenza.put(PART_NRATA, i+1); if (scadenza.read() == NOERR) { const real importo = scadenza.get(SCAD_IMPORTO); const TDate scad = scadenza.get(SCAD_DATASCAD); const int tipop = scadenza.get_int(SCAD_TIPOPAG); const bool paid = scadenza.get_bool(SCAD_PAGATA); const TString16 ulc = scadenza.get(SCAD_ULTCLASS); pag.set_rata(i, importo, scad, tipop, ulc, paid); } else break; } // for } //else } else return FALSE; pag.set_sheet(ps); _pag_rows = ps.rows_array(); // se la prima rata e' fissa non si tocca if (pag.tipo_prima_rata() > 0) ps.disable_cell(0,-1); return TRUE; } void TPrimanota_application::write_scadenze(const TMask& m) { real imponibile(0.0); real imposta(0.0); real spese(0.0); // should never happen but it doesn't hurt CHECK(!_rel->cg(0).empty(), "Missing first line"); TLocalisamfile partita (LF_PARTITE); TLocalisamfile scadenza(LF_SCADENZE); TRectype& r = _rel->lfile().curr(); const long nreg = r.get_long("NUMREG"); const TString16 ndoc(r.get("NUMDOC")); const int tmov = r.get_int("TIPOMOV"); const TDate ddoc(r.get_date("DATADOC")); const TDate dreg(r.get_date("DATAREG")); const TString16 reg (r.get("REG")); const TString80 desc(r.get("DESCR")); const long protiva = r.get_long("PROTIVA"); const TString16 codcaus(r.get("CODCAUS")); const TString16 codval (r.get("CODVAL")); const real cambio (r.get("CAMBIO")); const TString16 numpart = m.get(F_NUMRIF); const int anno = m.get_int(F_ANNORIF); CHECK(anno > 1900, "Anno partita non valido"); char sezione = _rel->cg(0).get_char("SEZIONE"); // Dare/Avere char tipocf = _rel->cg(0).get_char("TIPOC"); // Cliente || Fornitore || Uncazzo int gruppo = (tipocf == 'C' || tipocf == 'F') ? 0 : _rel->cg(0).get_char("GRUPPO"); int conto = (tipocf == 'C' || tipocf == 'F') ? 0 : _rel->cg(0).get_char("CONTO"); long sottoconto = _rel->cg(0).get_long("SOTTOCONTO"); int nriga = 1; int numrig = 1; partita.put(PART_ANNO, anno); partita.put(PART_NUMPART, numpart); partita.put(PART_NRIGA, nriga); bool fromscratch = FALSE, new_part = TRUE; TPagamento& pag = pagamento(); if (partita.read() == NOERR) { // se si e' specificato un codice pagamento diverso si rifa' da capo if (pag.code() != partita.get(PART_CODPAG)) fromscratch = TRUE; new_part = FALSE; } // riaggiusta partite e scadenze if (new_part) { partita.zero(); partita.put(PART_TIPOCF, tipocf); partita.put(PART_GRUPPO, gruppo); partita.put(PART_CONTO, conto); partita.put(PART_SOTTOCONTO, sottoconto); partita.put(PART_ANNO, anno); partita.put(PART_NUMPART, numpart); partita.put(PART_NRIGA, nriga); } // put data on partita partita.put("TIPOMOV",tmov); partita.put("NREG", nreg); partita.put("DATAREG",dreg); partita.put("DATADOC",ddoc); partita.put("NUMDOC", ndoc); partita.put("REG", reg); partita.put("DESCR", desc); partita.put("PROTIVA",protiva); partita.put("CODCAUS",codcaus); partita.put("SEZ", sezione); partita.put("CODPAG", pag.code()); partita.put("CODVAL", codval); partita.put("CAMBIO", cambio); partita.put("IMPORTO",pag.imponibile()); partita.put("IMPOSTA",pag.imposta()); partita.put("SPESE", pag.spese()); partita.put("NUMRIG", numrig); if (new_part) partita.write(); else partita.rewrite(); bool new_scad = FALSE; for (int i = 0; i < pag.n_rate(); i++) { new_scad = FALSE; scadenza.zero(); scadenza.put("ANNO", anno); scadenza.put("NUMPART", numpart); scadenza.put("NRATA", i+1); if (scadenza.read() != NOERR) { new_scad = TRUE; scadenza.zero(); scadenza.put(SCAD_TIPOCF, tipocf); scadenza.put(SCAD_GRUPPO, gruppo); scadenza.put(SCAD_CONTO, conto); scadenza.put(SCAD_SOTTOCONTO, sottoconto); scadenza.put(SCAD_ANNO, anno); scadenza.put(SCAD_NUMPART, numpart); scadenza.put(SCAD_NRATA, i+1); } // set everything scadenza.put("CODPAG", pag.code()); scadenza.put("TIPOPAG", pag.tipo_rata(i)); scadenza.put("ULTCLASS", pag.ulc_rata(i)); scadenza.put("IMPORTO", pag.tpay_rata(i)); scadenza.put("DATASCAD", pag.data_rata(i)); scadenza.put("PAGATA", pag.ratapagata(i)); if (new_scad) scadenza.write(); else scadenza.rewrite(); } // elimina eventuali altre scadenze oltre l'ultima registrata for (; !new_scad ; i++) { scadenza.zero(); scadenza.put(SCAD_ANNO, anno); scadenza.put(SCAD_NUMPART, numpart); scadenza.put(SCAD_NRATA, i+1); if (scadenza.read() == NOERR) scadenza.remove(); else new_scad = TRUE; } } /////////////////////////////////////////////////////////// // Sheet partite /////////////////////////////////////////////////////////// bool TPrimanota_application::edit_partite(int riga) { TToken_string& cgr = cgs().row(riga); const TBill b(cgr, 2, 0x3); // Legge il conto della riga selezionata if (!b.ok()) return FALSE; begin_wait(); TString caption("Partite aperte del conto "); caption << b.gruppo() << ' ' << b.conto() << ' ' << b.sottoconto(); TArray_sheet a(-1, -1, 0, 0, caption, "Anno|Numero@7|Dare@15R|Avere@15R|Descrizione@50", 0x8); TLocalisamfile partita(LF_PARTITE); partita.setkey(2); // Chiave per conto partita.zero(); if (b.tipo() > ' ') // Ignora gruppo e conto dei clifo { partita.put(PART_TIPOCF, b.tipo()); partita.put(PART_SOTTOCONTO, b.sottoconto()); } else b.put(partita.curr()); // Scrive completamente i conti normali const TRectype recpar(partita.curr());// Record campione int ult, anno; // Anno ultima partita TString16 last, num; // Ultimo numero partita e numero corrente long nreg; TString desc; // Descrizione prima partita del gruppo TImporto saldo; // Saldo ultima parita TToken_string r(80); const long curreg = curr_mask().get_long(F_NUMREG); // Numero registrazione for (int err = partita.read(_isgteq); err == NOERR && partita.curr() == recpar; err = partita.next()) { num = partita.get(PART_NUMPART); anno = partita.get_int(PART_ANNO); nreg = partita.get_long(PART_NREG); if (num == last && anno == ult) // Se la partita e' la stessa ... { const TImporto i(partita.get_char(PART_SEZ), partita.get_real(PART_IMPORTO)); saldo += i; // ... incrementa totale } else { if (!saldo.is_zero() || nreg == curreg) // Se il saldo non e' nullo allora e' aperta { r.cut(0); r.add(ult); r.add(last); saldo.add_to(r, 2); r.add(desc); a.add(r); // Aggiunge partita alla lista } ult = anno; last = num; desc = partita.get(PART_DESCR); saldo.set(partita.get_char(PART_SEZ), partita.get_real(PART_IMPORTO)); } } if (!saldo.is_zero() || nreg == curreg) // Aggiunge ultima partita se aperta { r.cut(0); r.add(ult); r.add(last); saldo.add_to(r, 2); r.add(desc); a.add(r); } end_wait(); bool dirty = FALSE; KEY k = a.items() > 0 ? K_ENTER : K_ESC; // Esce se non ci sono righe while (k == K_ENTER) { k = a.run(); if (k == K_ENTER) { const int anno = a.row().get_int(0); const TString16 num = a.row().get(1); dirty |= edit_scadenze(anno, num); // Edita pagamenti } } return dirty; } int TPrimanota_application::nuovo_pagamento(TPartita& partita, int rata, int rmov, TRectype& part) { CHECKD(rata >= 1 && rata <= partita.rate(), "Rata errata ", rata); CHECKD(!partita.rata_pagata(rata), "Rata pagata ", rata); const int nriga = partita.righe(); CHECKD(nriga > 0, "Riga partita errata ", nriga); part = partita.riga(1); // PART_ANNO viene preso dalla partita base // PART_NUMPART viene preso dalla partita base part.put(PART_NRIGA, nriga+1); // Riga di partita part.put(PART_TIPOMOV, causale().tipomov()); // Dati causale corrente part.put(PART_CODCAUS, causale().codice()); part.put(PART_NREG, curr_mask().get(F_NUMREG)); // Numero operazione part.put(PART_NUMRIG, rmov); // Riga su cui ho cliccato // Copia dati movimento corrente part.put(PART_DATAREG, curr_mask().get(F_DATAREG)); part.put(PART_DATADOC, curr_mask().get(F_DATADOC)); part.put(PART_NUMDOC, curr_mask().get(F_NUMDOC)); part.put(PART_DESCR, curr_mask().get(F_DESCR)); part.zero(PART_REG); part.zero(PART_PROTIVA); part.put(PART_SEZ, (partita.totale().sezione() == 'D') ? 'A' : 'D'); part.zero(PART_IMPORTO); // Azzera importi vari part.zero(PART_IMPOSTA); part.zero(PART_SPESE); part.zero(PART_CODVAL); part.zero(PART_CAMBIO); part.zero(PART_IMPORTOVAL); part.zero(PART_DATACAM); TString80 tmp; const TRectype& scadenza = partita.rata(rata); tmp = scadenza.get(SCAD_CODPAG); part.put(PART_CODPAG, tmp); tmp = scadenza.get(SCAD_TIPOPAG); part.put(PART_TIPOPAG, tmp); int caus = 2; // Calcola riga causale per la contropartita in base al tipo pagamento switch (atoi(tmp)) { case 2: // Tratta case 7: // Tratta accettata caus = 3; break; case 3: // Ricevuta bancaria caus = 4; break; case 4: // Cessione caus = 5; break; case 5: // Paghero' caus = 6; break; case 6: // Fattura di credito caus = 7; break; case 1: // Rimessa case 8: // Rapporti interbancari diretti case 9: // Bonifico default: caus = 2; break; } TBill bill; causale().bill(caus, bill); // Legge conto contropartita if (bill.empty()) causale().bill(caus = 1, bill); bill.put(part, TRUE); // PART_TIPOC viene preso dalla partita base // PART_GRUPPO viene preso dalla partita base // PART_CONTO viene preso dalla partita base // PART_SOTTOCONTO viene preso dalla partita base bill.get(part); // Legge conto principale if (bill.tipo() > ' ') // Se cliente o fornitore cerca sua banca { TRelation cliforel(LF_CLIFO); cliforel.add(LF_CFVEN, "TIPOCF=TIPOCF|CODCF=CODCF"); TRectype& clifo = cliforel.lfile().curr(); clifo.put(CLI_TIPOCF, bill.tipo()); clifo.put(CLI_CODCF, bill.codclifo()); const int err = cliforel.read(); CHECK(err == NOERR, "Chiss'e' fregato il clifo"); tmp = clifo.get(CLI_CODABI); part.put(PART_CODABI, tmp); tmp = clifo.get(CLI_CODCAB); part.put(PART_CODCAB, tmp); tmp = cliforel.lfile(LF_CFVEN).get(CLI_CODAG); part.put(PART_CODAG, tmp); } else { part.zero(PART_CODABI); part.zero(PART_CODCAB); part.zero(PART_CODAG); } part.zero(PART_IMPTOTPAG); part.zero(PART_SALACC); part.zero(PART_RITENUTE); part.zero(PART_DATARIFPAG); part.zero(PART_NUMRIFPAG); part.zero(PART_CHIUSA); tmp = scadenza.get(SCAD_NRATA); part.put(PART_NRATA, tmp); tmp = scadenza.get(SCAD_CODABIPR); part.put(PART_CODABIPR, tmp); tmp = scadenza.get(SCAD_CODCABPR); part.put(PART_CODCABPR, tmp); return nriga+1; } // Edit scadenze relative all'anno/numero partita specificati bool TPrimanota_application::edit_scadenze(int anno, const char* num) { TString caption; caption.format("Pagamenti della partita %s dell'anno %d", num, anno); TArray_sheet a(-1, -1, 0, 0, caption, "Rata|Data@10|Dare@15R|Avere@15R|Descrizione@50|Riga", 0x8); TPartita& partita = _partite.partita(anno, num); const long curreg = curr_mask().get_long(F_NUMREG); // Numero registrazione corrente const int currig = cgs().selected()+1; // Numero riga corrente TToken_string r(80); // Work string KEY k = K_ENTER; bool dirty = TRUE, one_dirty = FALSE; while (k == K_ENTER) { if (dirty) { const TString desc(partita.descrizione()); a.destroy(); long nr; const char sez_par = partita.riga(1).get_char(PART_SEZ); for (int s = 1; s <= partita.rate(); s++) { const TRectype& rata = partita.rata(s); r.cut(0); r.add(rata.get(SCAD_NRATA)); r.add(rata.get(SCAD_DATASCAD)); if (sez_par == 'A') { r.add(rata.get(SCAD_IMPORTO)); r.add(""); } else { r.add(""); r.add(rata.get(SCAD_IMPORTO)); } r.add(desc); r.add("S"); nr = a.add(r); if (partita.rata_pagata(s)) a.disable(nr); for (int p = 1; p <= partita.righe(); p++) { const TRectype& paga = partita.riga(p); if (paga.get_int(PART_NRATA) == s) { r.cut(0); r.add(s); r.add(paga.get(PART_DATAREG)); const char sez = paga.get_char(PART_SEZ); if (sez == 'D') { r.add(paga.get(PART_IMPORTO)); r.add(""); } else { r.add(paga.get(PART_IMPORTO)); r.add(""); } r.add(paga.get(PART_DESCR)); r.add(paga.get(PART_NRIGA)); nr = a.add(r); if (paga.get_long(PART_NREG) != curreg || paga.get_int(PART_NUMRIG) != currig) a.disable(nr); } } } } k = a.run(); if (k == K_ENTER) { const int rata = a.row().get_int(0); int nrig = a.row().get_int(5); // Numero riga pagamento corrente TRectype part(LF_PARTITE); if (nrig == 0) // Se ho cliccato su una scadenza ... nrig = nuovo_pagamento(partita, rata, currig, part); else part = partita.riga(nrig); dirty = edit_pagamento(partita, part); one_dirty |= dirty; } // if k == K_ENTER } // while k == K_ENTER return one_dirty; } static bool importopag_handler(TMask_field& f, KEY k) { if (k == K_F8) { TMask& m = f.mask(); f.set(m.get(S_IMPORTO)); k = K_TAB; } if (f.to_check(k)) { TMask& m = f.mask(); real i(f.get()); const real tot(m.get(S_IMPORTO)); if (i > tot) { warning_box("Non e' possibile inserire un importo superiore a ", tot.string(".")); i = tot; f.set(i.string()); } if (i == tot) m.set(S_SALDOACC, "S"); } return TRUE; } bool TPrimanota_application::edit_pagamento(TPartita& p, TRectype& part) { TMask m("cg2100s"); m.set_handler(S_IMPORTOPAG, importopag_handler); TRelation rel(LF_PARTITE); // Working relation TLocalisamfile& partita = rel.lfile(); partita.curr() = part; m.autoload(&rel); // Load current record on mask const TRectype& parbas = p.riga(1); const int rata = part.get_int(PART_NRATA); const TRectype& scaden = p.rata(rata); const real dapagare(scaden.get(SCAD_IMPORTO)); const real pagato(scaden.get(SCAD_IMPORTOPAG)); const real residuo = dapagare - pagato; // Dati del documento (fattura) che ha generato la scadenza m.set(S_NUMDOC, parbas.get(PART_NUMDOC)); // Numero documento m.set(S_DATADOC, parbas.get(PART_DATADOC)); // Data documento m.set(S_NUMPROT, parbas.get(PART_PROTIVA)); // Protocollo IVA m.set(S_DESCR, parbas.get(PART_DESCR)); // Descrizione documento // Dati della scadenza che ha generato la partita m.set(S_RESIDUO, residuo.string()); // Residuo da pagare m.set(S_DATASCAD, scaden.get(SCAD_DATASCAD)); // Data della scadenza m.set(S_IMPORTO, dapagare.string()); // Importo della rata m.set(S_IMPORTOVAL, scaden.get(SCAD_IMPORTOVAL)); // " in valuta m.set(S_RATA, scaden.get(SCAD_NRATA)); const char sez = part.get_char(PART_SEZ); // Sezione importo e rituenute const char controsez = sez == 'D' ? 'A' : 'D'; // Sezione opposta (contropartita) // Memorizza importi prima di eventuali variazioni const real old_importo(part.get(PART_IMPORTO)); const real old_ritenute(part.get(PART_RITENUTE)); const TBill old_conto(m.get_int(S_GRUPPO), m.get_int(S_CONTO), m.get_long(S_SOTTOCONTO)); const int old_riga = old_conto.ok() ? bill2pos(old_conto, 'I') : -1; const KEY key = m.run(); if (key == K_ENTER || key == K_DEL) { if (key == K_DEL) { m.reset(S_IMPORTOPAG); m.reset(S_RITENUTE); } m.autosave(&rel); part = partita.curr(); if (old_riga >= 0) sub_cgs_imp(old_riga, old_importo); // Importo della contropartita const TImporto new_importo(controsez, part.get_real(PART_IMPORTO)); if (!new_importo.is_zero()) { TBill new_conto; new_conto.get(part, TRUE); const int riga = bill2pos(new_conto, 'I'); if (riga < 0) set_cgs_row(riga, new_importo, new_conto, part.get(PART_DESCR), 'I'); else add_cgs_imp(riga, new_importo); } const real rit(part.get(PART_RITENUTE)); const TImporto grow_ritenute(controsez, rit-old_ritenute); // Variazione ritenute fiscali if (!grow_ritenute.is_zero()) { const riga = type2pos('F'); if (riga < 0) { TBill conto_rit; causale().bill(11, conto_rit); set_cgs_row(riga, grow_ritenute, conto_rit, "", 'F'); } else add_cgs_imp(riga, grow_ritenute); } if (key == K_ENTER) p.add_riga(part); else p.remove_riga(part); } return key != K_ESC; } bool TPrimanota_application::notify_cgline_deletion(TPartita& partita, long nreg, int numrig) { bool found = FALSE; const int riga_ritenute = type2pos('F'); for (int r = partita.righe(); r > 0; r--) { TRectype pag(partita.riga(r)); const long reg = pag.get_long(PART_NREG); if (reg == nreg) // Se la registrazione corrisponde { if (numrig > 0) { const int num = pag.get_int(PART_NUMRIG); if (num == numrig) // Se anche la riga corrisponde { const real ritenute(pag.get(PART_RITENUTE)); if (!ritenute.is_zero()) { if (riga_ritenute >= 0) sub_cgs_imp(riga_ritenute, ritenute); else error_box("Non esiste la riga delle ritenute di un pagamento della riga %d", numrig); } const real importo(pag.get(PART_IMPORTO)); if (!importo.is_zero()) { TBill contro; contro.get(pag); const int riga_contro = bill2pos(contro, 'I'); if (riga_contro >= 0) sub_cgs_imp(riga_contro, importo); else error_box("Non esiste la riga dell'importo di un pagamento della riga %d", numrig); } partita.remove_riga(pag); found = TRUE; } else { const int n = pag.get_int(PART_NUMRIG); pag.put(PART_NUMRIG, n-1); partita.add_riga(pag); } } else // numrig == 0 { partita.remove_riga(pag); // Cancellazione pura e semplice found = TRUE; // usata solo da ::remove } } // if reg == numreg } return found; } bool TPrimanota_application::notify_cgline_deletion(int numrig) { bool found = FALSE; const long nreg = curr_mask().get_long(F_NUMREG); _partite.add_reg_num(nreg, 0); for (TPartita* game = _partite.first(); game; game = _partite.next()) found |= notify_cgline_deletion(*game, nreg, numrig); return found; }