campo-sirio/cg/cg2104.cpp

// --------------------------------------------------------------------------
// Scadenzario
// fv 24/8/94
// --------------------------------------------------------------------------

#include <sheet.h>
#include "pagament.h"

#include "cg2102.h"
#include "cg2100.h"
#include "cg21sld.h"
#include "cg2100p.h"

#include <clifo.h>
#include <partite.h>
#include <scadenze.h>

bool TPrimanota_application::pag_notify(TSheet_field&, 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");
  const 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(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_NRIGA,      nriga);
    scadenza.put(SCAD_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_NRIGA,      nriga);
      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
///////////////////////////////////////////////////////////

HIDDEN void add_importo(TToken_string& s, const TImporto& i)
{
  if (i.is_zero())
    s.add("");  
  else  
  {
    s.add(i.valore().string());
    s << ' ' << i.sezione();
  }
} 

HIDDEN bool partite_notify(TSheet_field& partite, int r, KEY k)
{
  if (k == K_TAB)
  {           
    TMask& m = partite.mask();
    TSheet_field& scadenze = (TSheet_field&)m.field(P_SCADENZE);
    scadenze.destroy();
    
    const TBill zio(m.get_int(P_GRUPPO), m.get_int(P_CONTO), 
                    m.get_long(P_SOTTOCONTO), m.get(P_TIPOC)[0]);
    TToken_string& row = partite.row(r);
    const int anno = row.get_int(0);
    const TString16 num = row.get();
    m.set(P_ANNO, anno);                   // Aggiorna campi di ricerca
    m.set(P_NUMERO, num);
    
    TPartita game(zio, anno, num);   
    TRecord_array& p = game.rows_array();
    const int lastr = p.last_row();
    for (int r = p.first_row(); r <= lastr; r++) if (p.exist(r))
    {
      const TRiga_partite& riga = game.riga(r);
      for (int ra = 1; ra <= riga.rate(); ra++)
      {
        const TRiga_scadenze& scad = riga.rata(ra);
        TToken_string& row = scadenze.row(-1);
        row.add(ra);
        row.add(riga.get(PART_DATADOC)); 
        row.add(riga.get(PART_NREG));
        row.add(riga.get(PART_DATAREG));
        row.add(scad.get(SCAD_DATASCAD)); 
        row.add(scad.get(SCAD_IMPORTO));
        row.add(scad.get(SCAD_IMPORTOVAL));
        row.add(riga.get(PART_DESCR));
        row.add(riga.get(PART_NUMDOC)); 
        row.add(riga.get(PART_PROTIVA)); 

        const TRecord_array& ap = scad.rows_array();
        const int lastp = ap.last_row();
        for (int pa = ap.first_row(); pa < lastp; pa++) if (ap.exist(pa))
        {
          const TRectype& pag = ap.row(pa);
        
          TToken_string& row = scadenze.row(-1);
          row.add("");
          row.add(riga.get(PART_DATADOC)); 
          row.add(riga.get(PART_DATAREG));
          row.add(scad.get(SCAD_DATASCAD)); 
          row.add(pag.get_real(SCAD_IMPORTO).string(0, 0));
          row.add(pag.get_real(SCAD_IMPORTOVAL).string(0, 2));
          row.add(riga.get(PART_DESCR));
          row.add(riga.get(PART_NUMDOC)); 
          row.add(riga.get(PART_PROTIVA)); 
        }
      }
    }
    scadenze.force_update();
  }
  
  return TRUE;
}

HIDDEN bool numpart_handler(TMask_field& f, KEY k)
{
  if (k == K_TAB && f.dirty())
  {                  
    const TMask& m = f.mask();
    const int anno = m.get_int(P_ANNO);
    const TString16 num = f.get();
    if (anno > 0 && num.not_empty())
    {
      TSheet_field& sheet = (TSheet_field&)m.field(P_PARTITE);
      for (int i = 0; i < sheet.items(); i++)
      {
        TToken_string& row = sheet.row(i);
        if (anno == row.get_int(0))            // Se corrisponde l'anno e ...
          if (num == row.get())                // corrisponde il numero partita ...
          {
            sheet.select(i);                   // Seleziona la partita
            partite_notify(sheet, i, K_TAB);   // ed esplodi le sue righe
            break;
          }
      }
      if (i >= sheet.items())
        f.warning_box("Partita inesistente");
    }
  }
  return TRUE;
}

HIDDEN bool annopart_handler(TMask_field& f, KEY k)
{
  if (k == K_TAB && f.dirty() && f.get().not_empty())
  {
    TMask_field& n = f.mask().field(P_NUMERO);
    n.set_dirty();
    numpart_handler(f, k);
  }
  return TRUE;
}


HIDDEN bool scambio_handler(TMask_field& f, KEY k)
{ 
  const TMask& m = f.mask();
  if (k == K_SPACE && m.is_running())
  {           
    const TSheet_field& sheet = (TSheet_field&)m.field(P_SCADENZE);
    sheet.swap_columns(103, 109); 
    sheet.swap_columns(104, 110);
  }
  return TRUE;
}

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();
  
  TMask mask("cg2100p");                // Inizializzazione maschera di selezione partite
  
  const char tipocf[2] = { b.tipo(), '\0' };
  mask.set(P_TIPOC,      tipocf);
  mask.set(P_GRUPPO,     b.gruppo());
  mask.set(P_CONTO,      b.conto());
  mask.set(P_SOTTOCONTO, b.sottoconto());
  mask.set(P_DESCR,      ((TBill&)b).descrizione());
  
  mask.set_handler(P_ANNO, annopart_handler);
  mask.set_handler(P_NUMERO, numpart_handler);
  mask.set_handler(P_SCAMBIO, scambio_handler);
  
  TSheet_field& sheet = (TSheet_field&)mask.field(P_PARTITE);
  sheet.set_notify(partite_notify);
  TString_array& a = sheet.rows_array(); 

  TLocalisamfile partita(LF_PARTITE);
  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 filter(partita.curr());// Record campione

  int ult, anno;                        // Anno ultima partita
  TString16 last, num;                  // Ultimo numero partita e numero corrente         
  TString desc;                         // Descrizione prima partita del gruppo
  TString16 numdoc;
  TString16 datadoc;
  
  TImporto saldo;                       // Saldo ultima parita
  TImporto documenti;                   // Documenti ultima parita
  TImporto pagamenti;                   // Pagamenti ultima parita
  TImporto importi;                     // Altri importi 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() == filter; err = partita.next())
  {
    anno = partita.get_int(PART_ANNO);
    num = partita.get(PART_NUMPART);
    
    const int tipomov = partita.get_int(PART_TIPOMOV);
    if (num == last && anno == ult)     // Se la partita e' la stessa ...
    {               
      const TImporto i(partita.get_char(PART_SEZ), partita.get_real(PART_IMPORTO));
      switch (tipomov)
      {
        case 1:
        case 2:
          documenti += i;
          break;
        case 3: 
          pagamenti += i;
          break;
        default:
          importi += i;
          break;
      }    
      saldo += i;                       // ... incrementa totale
    }
    else
    {           
      if (!saldo.is_zero())             // Se il saldo non e' nullo allora e' aperta
      {
        r.cut(0);
        r.add(ult); 
        r.add(last); 
        r.add(datadoc);
        r.add(numdoc);
        add_importo(r, saldo);
        add_importo(r, documenti);
        add_importo(r, pagamenti);
        add_importo(r, importi);
        r.add(desc); 
        a.add(r);                               // Aggiunge partita alla lista
      }
      ult     = anno;
      last    = num;
      numdoc  = partita.get(PART_NUMDOC);
      datadoc = partita.get(PART_DATADOC);
      desc    = partita.get(PART_DESCR);
      
      saldo.set(partita.get_char(PART_SEZ), partita.get_real(PART_IMPORTO));
      switch (tipomov)
      {
        case 1:
        case 2:
          documenti = saldo;
          pagamenti.set('D', ZERO);
          importi.set('D', ZERO);
          break;
        case 3: 
          pagamenti = saldo;
          documenti.set('D', ZERO);
          importi.set('D', ZERO);
          break;
        default:
          importi = saldo;
          documenti.set('D', ZERO);
          pagamenti.set('D', ZERO);
          break;
      }    
    }
  }
  
  if (!saldo.is_zero())                         // Aggiunge ultima partita se aperta
  {
    r.cut(0);
    r.add(ult); 
    r.add(last); 
    r.add(datadoc);
    r.add(numdoc);
    add_importo(r, saldo);
    add_importo(r, documenti);
    add_importo(r, pagamenti);
    add_importo(r, importi);
    r.add(desc); 
    a.add(r);
  }
  
  end_wait();
  
  if (a.items() > 0)
  {
    sheet.force_update();
    mask.run();
  }  
  
  return TRUE;
}


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;
*/
  return 1;  
}


// Edit scadenze relative all'anno/numero partita specificati 
bool TPrimanota_application::edit_scadenze(const TBill& clifo, 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(clifo, anno, num);                           

  const long curreg = curr_mask().get_long(F_NUMREG);	// Numero registrazione corrente
  const int currig = cgs().selected()+1;              // Numero riga corrente
  
  return FALSE;  
}


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;
*/
  return FALSE;  
}

bool TPrimanota_application::notify_cgline_deletion(TPartita& partita, long nreg, int numrig)
{
  bool found = FALSE;
  const int riga_ritenute = type2pos('F');

  for (int r = 1; 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;
}