#include <defmask.h>          // Serve per DLG_NEWREC

#include "cg2100p.h"          // Campi maschere partite e pagamenti

#ifdef __EXTRA__
#include "saldacon.h"
#include "sc0100p.h"
#else
#include "cg2100.h"           // Campi maschere prima nota
#include "cg2102.h"           // Applicazione di prima nota
#endif

#include <causali.h>          // Archivio causali
#include <clifo.h>            // Archivio clienti/fornitori
#include <mov.h>              // Archivio movimenti di prima nota
#include <pagsca.h>           // Archivio pagamenti
#include <partite.h>          // Archivio partite
#include <scadenze.h>         // Archivio scadenze

///////////////////////////////////////////////////////////
// Definizione Maschera partite
///////////////////////////////////////////////////////////

class TGame_mask : public TMask
{                       
  const TBill _conto;          // Conto fisso del cliente/fornitore
  long _numreg;                // Numero movimento contabile
  int  _numrig;                // Riga contabile corrente (prima = 1!)
  TImporto _importo;           // Importo su riga contabile
  TImporto _residuo, _resval;  // Residuo della riga contabile
  int _riga_partite;           // Riga corrente delle partite
  bool _changed;               // Flag di modifica partite
  bool _valfirst;              // La colonna della valuta precede le lire
  
  TDecoder _causali;           // Decodificatore delle causali
  
protected:
  static bool annopart_handler(TMask_field& f, KEY k);
  static bool numpart_handler(TMask_field& f, KEY k);
  static bool partite_notify(TSheet_field& partite, int r, KEY k);
  static bool scadenze_notify(TSheet_field& partite, int r, KEY k);
  static bool show_all_handler(TMask_field& f, KEY k);
  static bool edit_scadenza_handler(TMask_field& f, KEY k);
  static bool nuovo_handler(TMask_field& f, KEY k);
  static bool cambio_handler(TMask_field& f, KEY k);

  void add_importo(TToken_string& s, const TImporto& i, bool val = FALSE, int pos = -1);
  void add_descrizione(TToken_string& s, const TRiga_partite& riga, int pos = -1);
  TImporto get_importo(TToken_string& s, int pos) const;
  
  void fill_partite();
  
  void aggiorna_residuo();

  int update_partita(const TRectype& game, const TImporto& s, const TImporto& d,
                     const TImporto& p, const TImporto& i, int prow);
  int update_partita(const TPartita& game, int prow);
  int update_partita(const TRectype& game, int prow);

  void update_saldo_clifo();
  int nuova_riga(TPartita& partita, tipo_movimento tm) const;
  int nuovo_pagamento(TPartita& partita, int nriga, int rata, tipo_movimento tm) const;
  bool edit_pagamento(TPartita& p, int nriga, int nrata, int nrigp) const;

  char calcola_sezione(tipo_movimento tm = tm_pagamento) const;
  long number_distance(const char* key, const char* num) const;
  bool same_number(const char* key, const char* num) const;
  void append_conto(TString& s) const;
  
#ifdef __EXTRA__  
  bool edit_fattura(TPartita& p, int nriga);
  bool prima_nota(const long nreg);
#endif

  const TRiga_partite* cerca_prima_riga() const;
  void aggiorna_valuta(const TValuta& val);
  void aggiorna_sorelle(const TRiga_partite& part) const;
  
public:
  TSheet_field& partite() const { return (TSheet_field&)field(P_PARTITE); }
  TSheet_field& scadenze() const { return (TSheet_field&)field(P_SCADENZE); }
  const TBill& conto() const { return _conto; }
  
  const TImporto& residuo(bool val) const { return val ? _resval : _residuo; }
  bool changed() const { return _changed; }

  TGame_mask(const TBill& bill, long numreg, int riga);
  virtual ~TGame_mask() {}
};



///////////////////////////////////////////////////////////
// Maschera pagamenti
///////////////////////////////////////////////////////////

class TPay_mask : public TMask
{ 
  TDate _datadoc;                         
  real _da_pagare, _pagabile;
  const TGame_mask& _parent;
  
  tipo_movimento _tipomov;
  
  TDecoder _causale;   
  bool _assigned;
  bool _can_solder;
  
protected:
  static bool importo_handler(TMask_field& f, KEY k);
  static bool importolire_handler(TMask_field& f, KEY k);
  static bool saldo_handler(TMask_field& f, KEY k);
  static bool datapag_handler(TMask_field& f, KEY k);
  static bool conto_handler(TMask_field& f, KEY k);
  static bool descr_handler(TMask_field& f, KEY k);
  void gioca_cambi(int force = 0x0);
  
  static bool sottoconto_handler(TMask_field& f, KEY k);
#ifdef __EXTRA__  
  static bool datareg_handler(TMask_field& f, KEY k);
  static bool datadoc_handler(TMask_field& f, KEY k);
  static bool numdoc_handler(TMask_field& f, KEY k);
  static bool sezione_handler(TMask_field& f, KEY k);
#endif  

public:
  void set_pag(const TRectype& oldpag, const TRiga_scadenze& scad, const TImporto& importo);
  void get_pag(TRectype& oldpag, TRectype& somma) const;
  
  bool assigned() const { return _assigned; }
  bool unassigned() const { return !_assigned; }
  tipo_movimento tipo() const { return _tipomov; }
  
  void attiva_valuta(bool on);

  TPay_mask(const TGame_mask& parent, int mode);
  virtual ~TPay_mask();
};

#ifdef __EXTRA__         
const char* const PAYMASK = "sc0100b";
#else
const char* const PAYMASK = "cg2100s";
#endif           

TPay_mask::TPay_mask(const TGame_mask& parent, int mod) 
         : TMask(PAYMASK), _parent(parent), 
           _causale(LF_CAUSALI, CAU_CODCAUS, CAU_DESCR)
{ 
  set_mode(mod);
  enable(DLG_DELREC, edit_mode());
  set_handler(S_SOTTOCONTO, sottoconto_handler);
  
#ifdef __EXTRA__
  xvt_statbar_set(mod == MODE_MOD ? "Modifica" : "Inserimento", TRUE);

  hide(E_CODPAG); hide(E_DESPAG);  
  set_handler(E_DATAREG, datareg_handler);
  set_handler(E_DATADOC, datadoc_handler);
  set_handler(E_NUMDOC, numdoc_handler);
  set_handler(E_SEZIONE, sezione_handler);
  set_handler(E_TOTALE, TSaldaconto_app::totale_handler);
  if (app().gestione_valuta())
  {            
    show(-3);  
    set_handler(E_TOTDOCVAL,  TSaldaconto_app::totval_handler);
    set_handler(E_VALUTA,     TSaldaconto_app::valuta_handler);
    set_handler(E_DATACAMBIO, TSaldaconto_app::datacambio_handler);
    set_handler(E_CAMBIO,     TSaldaconto_app::cambio_handler);
  }
  else
    hide(-3);  

  hide(S_RESIDUOPAG);
  hide(-2); // I campi relativi alla contropartita non vengono gestiti
  hide(E_IMPOSTE);
                                                                      
  set_handler(E_DESCR, descr_handler);
  set_handler(S_DESCAGG, descr_handler);
                                                                      
  const char a = TPartita::allineamento_richiesto(parent.conto().tipo());
  field(E_NUMRIF).set_justify(a == 'R');

  disable(E_ANNORIF);
  disable(E_NUMRIF);
#endif
} 

TPay_mask::~TPay_mask() 
{
#ifdef __EXTRA__
  xvt_statbar_set("Estratto conto", TRUE);
#endif  
}

void TPay_mask::attiva_valuta(bool in_valuta)
{
  if (in_valuta)
  {
    set_handler(S_IMPORTOVAL, importo_handler); 
    set_handler(S_IMPORTO, importolire_handler); 
  }
  else  
    set_handler(S_IMPORTO, importo_handler); 
    
  enable(S_RITENUTE, !in_valuta);       // dis/abilita ritenute
  enable(S_IMPORTOVAL, in_valuta);
  
  if (in_valuta) 
  {
    reset(S_RITENUTE);
  }
  else
  {
    reset(S_IMPORTOVAL_SCAD);
    reset(S_IMPORTOVAL);
  }  
}

void TPay_mask::set_pag(const TRectype& oldpag, const TRiga_scadenze& scad, 
                        const TImporto& residuo)
{                   
  const TPartita& p = scad.partita();
  const int nrigp = oldpag.get_int(PAGSCA_NRIGP);
  const TRiga_partite& sum = p.riga(nrigp);
  _assigned = oldpag.get_int(PAGSCA_NRIGA) != TPartita::UNASSIGNED;
  _tipomov = (tipo_movimento)sum.get_int(PART_TIPOMOV);
  
  const TRiga_partite& fatt = _assigned ? scad.riga() : sum;

  TRelation rel(LF_PAGSCA);                // Working relation
  rel.add(LF_PARTITE, "ANNO=ANNO|NUMPART=NUMPART");
  rel.curr() = oldpag;
  rel.curr(LF_PARTITE) = sum;
  autoload(rel);                          // Load current record on mask
  
  TMask_field& group = field(S_RATA);
  TString prompt(80);
  
  const TBill& k = p.conto();
  switch (k.tipo())
  {
  case 'C': prompt << "Cliente"; break;
  case 'F': prompt << "Fornitore"; break;
  default : prompt << "Conto " << k.gruppo() << ' ' << k.conto(); break;
  }
  prompt << ' ' << k.sottoconto() << ' ';
  prompt << "Partita:" << p.anno() << ' ' << p.numero()
         << " Riga:" << oldpag.get_int(PAGSCA_NRIGA) 
         << " Rata:" << oldpag.get_int(PAGSCA_NRATA);
  if (assigned())       
    prompt << " del " << scad.get_date(SCAD_DATASCAD).string();
#ifndef __EXTRA__    
  else
    prompt << " del " << sum.get_date(PART_DATAPAG).string();
#endif    
  group.set_prompt(prompt);

  set(S_NUMDOC,  fatt.get(PART_NUMDOC));             // Numero documento
  set(S_DATADOC, fatt.get(PART_DATADOC));            // Data documento
  set(S_NUMPROT, fatt.get(PART_PROTIVA));            // Protocollo IVA

  TString desfat = fatt.get(PART_DESCR);             // Descrizione fattura
  if (desfat.empty())                                // Se e' vuota ...
  {
    desfat = fatt.get(PART_CODCAUS);
    desfat = _causale.decode(desfat);                // ... usa descrizione causale
  }
  set(S_DESCR, desfat);                              

  const bool in_valuta = fatt.in_valuta();
  const char sez_fat = fatt.sezione();
  set(S_SEZIONE_SCAD, sez_fat == 'A' ? "A" : "D"); // Sezione della riga
  if (assigned())
  {
    set(S_IMPORTO_SCAD, scad.get(SCAD_IMPORTO));         // Importo della rata
    if (in_valuta)
      set(S_IMPORTOVAL_SCAD, scad.get(SCAD_IMPORTOVAL)); // Importo in valuta 
    TImporto res_rat = scad.residuo(in_valuta);  
    res_rat.normalize(sez_fat);  
    _da_pagare = res_rat.valore();       // Calcola residuo in valuta

    TReal_field& res = (TReal_field&)field(S_RESIDUORATA);
    res.set_decimals(in_valuta ? 3 : 0);
    if (get(S_SALDOACC)[0] != 'S')
      res.set(_da_pagare.string());
  }
  else                
  {
    hide(S_RESIDUORATA);        // Se non assegnato nascondi residuo rata
    _da_pagare = ZERO;
  }
  
  attiva_valuta(in_valuta);
  set_handler(S_SALDOACC, saldo_handler);
  
  real oldimp = oldpag.get_real(in_valuta ? PAGSCA_IMPORTOVAL : PAGSCA_IMPORTO);   
  if (!in_valuta)
    oldimp += oldpag.get_real(PAGSCA_RITENUTE);   
  
  // Ricorda l'importo da pagare
  _da_pagare += oldimp;
  
#ifndef __EXTRA__
  _pagabile = _parent.residuo(in_valuta).valore();

  TReal_field& resp = (TReal_field&)field(S_RESIDUOPAG);
  resp.set_decimals(in_valuta ? 3 : 0);
  resp.set(_pagabile.string());
  
  _pagabile += oldimp;
#endif
  
  // Il flag di saldo/acconto e' attivo solo se non ci sono acconti, cioe':
  // pagamento non assegnato o con data documento antecedente quella della fattura
  _can_solder = _assigned;
  if (_can_solder)
  {                            
    const tipo_movimento tm = sum.tipo();
    _can_solder = !(tm == tm_nota_credito || tm == tm_insoluto);
    if (_can_solder)
    {
      const TDate datasca(fatt.get(PART_DATADOC)); 
      const TDate datapag(sum.get(PART_DATADOC));
      _can_solder = datapag >= datasca;
    }  
  }

  // Mostra saldo solo se non e' ne' un acconto, ne' una nota di credito
  enable(S_SALDOACC, _can_solder);  

#ifdef __EXTRA__                          
  enable(E_SEZIONE, oldpag.get_char(PAGSCA_ACCSAL) != 'S');

  // La valuta puo' essere cambiata solo su partite nuove
  const bool on = p.first() == p.last();
  enable(E_VALUTA, on);
//  show(-3, in_valuta);          // Attiva campi relativi alla valuta
#else
  set_handler(S_GRUPPO, conto_handler);
  set_handler(S_CONTO, conto_handler);
  const bool mostra_conto = !sum.is_nota_credito();          
  show(-2, mostra_conto);       // mostra/nasconde conto contropartita
  show(-3, in_valuta);          // Attiva campi relativi alla valuta
#endif  

// Gestione data-pagamento: non puo' precedere la data del documento
  _datadoc = sum.get_date(PART_DATADOC);
  set_handler(S_DATAPAG, datapag_handler); 

  const bool mostra_ritenute = !sum.is_nota_credito();
  show(S_RITENUTE, mostra_ritenute);
} 

void TPay_mask::get_pag(TRectype& newpag, TRectype& sum) const
{
  TRelation rel(LF_PAGSCA);                // Working relation
  rel.add(LF_PARTITE, "ANNO=ANNO|NUMPART=NUMPART");
  rel.curr() = newpag;       
  rel.curr(LF_PARTITE) = sum;
  autosave(rel);                          // Load current record from mask
  newpag = rel.curr();
  sum = rel.curr(LF_PARTITE);
}     

// Riempie i campi valuta a zero in base agli altri
void TPay_mask::gioca_cambi(int force)
{               
  const real totale = get(S_IMPORTO);
  const real totval = get(S_IMPORTOVAL);

#ifdef __EXTRA__
  const TValuta cambio(*this, E_VALUTA, E_DATACAMBIO, E_CAMBIO);
#else  
  const TValuta cambio(_parent, P_VALUTA, P_DATACAMBIO, P_CAMBIO);
#endif  

  if ( (force == 0x1 || totale.is_zero()) && !(totval.is_zero() || cambio.in_lire()) )
  {
    const real new_totale = cambio.val2lit(totval);
    if (new_totale != totale)
      set(S_IMPORTO, new_totale, TRUE);
  } 
  
  if ( (force == 0x2 || totval.is_zero()) && !(totale.is_zero() || cambio.in_lire()))
  {
    const real new_totval = cambio.lit2val(totale);
    if (new_totval != totval)
      set(S_IMPORTOVAL, new_totval, TRUE);
  } 

#ifdef __EXTRA__  
  if ( (force == 0x4 || cambio.in_lire()) && !(totale.is_zero() || totval.is_zero()))
  {
    real new_cambio = totale / totval; new_cambio.round(5);
    if (new_cambio != cambio.cambio())
      set(E_CAMBIO, new_cambio, TRUE);
  } 
#endif  
}


bool TPay_mask::importo_handler(TMask_field& f, KEY k)
{
  TPay_mask& m = (TPay_mask&)f.mask();         

  if (k == K_F8)
  {        
    real imp;
#ifdef __EXTRA__
    const bool in_valuta = m.field(S_IMPORTOVAL).active();
    m._pagabile = m.get_real(in_valuta ? E_TOTDOCVAL : E_TOTALE);
    if (m._assigned)
      imp = fnc_min(m._da_pagare, m._pagabile);
    else
      imp = m._pagabile;
#else
    if (m.field(S_RESIDUORATA).shown() && m.field(S_RESIDUOPAG).shown())
      imp = fnc_min(m._da_pagare, m._pagabile);
    else
      imp = m.field(S_RESIDUORATA).shown() ? m._da_pagare : m._pagabile;
#endif
      
    if (m.field(S_RITENUTE).active())
      imp -= real(m.get(S_RITENUTE));
    
    f.set(imp.string());           
    k = K_TAB;
  }           
  
  if (k == K_TAB && f.focusdirty())
  {            
    const bool in_valuta = m.field(S_IMPORTOVAL).active();
    if (in_valuta)
      m.gioca_cambi();
  
    real i(f.get());
    if (m.field(S_RITENUTE).active())
      i += real(m.get(S_RITENUTE));
    
    TMask_field& sa = m.field(S_SALDOACC);
    if (m._can_solder && m.mode() == NO_MODE)
    {                      
      if (i >= m._da_pagare)
        sa.set("S");
/*
      Eliminato perche' rende ingestibili due pagamenti in valuta a saldo  
      if (in_valuta) sa.enable(i != m._da_pagare);
*/      
    }  
    
    if (sa.get()[0] != 'S')
    {
      real residuo = m._da_pagare;
      if (m.tipo() == tm_insoluto)
        residuo += i;
      else  
        residuo -= i;
      m.set(S_RESIDUORATA, residuo);
    }
    else
      m.reset(S_RESIDUORATA);
      
    const real residuopag(m._pagabile - i);
    m.set(S_RESIDUOPAG, residuopag);
  } 
  
  return TRUE;
}

bool TPay_mask::importolire_handler(TMask_field& f, KEY k)
{               
  TPay_mask& m = (TPay_mask&)f.mask();         

  if (k == K_F8)
  {
#ifdef __EXTRA__
    if (m.unassigned())
      f.set(m.get(E_TOTALE));
    else  
#endif  
    m.send_key(k, S_IMPORTOVAL);
  }
    
  if (f.to_check(k))
    m.gioca_cambi();
  return TRUE;
}

bool TPay_mask::saldo_handler(TMask_field& f, KEY k)
{
  if (k == K_SPACE)
  {           
    TMask& m = f.mask();
    m.set_mode(MODE_QUERY);
    TMask_field& imp =  m.field(m.field(S_IMPORTOVAL).active() ? S_IMPORTOVAL : S_IMPORTO);
    imp.set_dirty();
    imp.on_hit();
    m.set_mode(NO_MODE);
  }
  return TRUE;
}

bool TPay_mask::sottoconto_handler(TMask_field& f, KEY k)
{           
  bool ok = TRUE;
  if (k == K_ENTER && f.mask().insert_mode() && f.get().empty())
    ok = f.error_box("Contropartita obbligatoria");
  return ok;
}

bool TPay_mask::datapag_handler(TMask_field& f, KEY k)
{   
  if (f.to_check(k))           
  {
    const TDate datapag(f.get());
    TPay_mask& m = (TPay_mask&)f.mask();         
    if (datapag < m._datadoc)
      return f.error_box("La data del pagamento e' inferiore alla data del documento %s", 
                         m._datadoc.string());
  }
  return TRUE;
}

bool TPay_mask::conto_handler(TMask_field& f, KEY k)
{   
  if (k == K_TAB && f.focusdirty())
  {                        
    TMask& m = f.mask();
    TBill conto; conto.get(m, S_GRUPPO, S_CONTO, S_SOTTOCONTO);
    const TString& desc = conto.descrizione();
    if (desc.empty()) 
      m.reset(S_SOTTOCONTO);
    m.set(S_DESCRCONTO, desc);
  }           
  return TRUE;
}

///////////////////////////////////////////////////////////
// Maschera gestione nuovo pagamento / fattura
///////////////////////////////////////////////////////////

class TNew_mask : public TMask
{        
  bool _allow_fatt;

protected:
  static bool tipomov_handler(TMask_field& f, KEY k);
              
public:
  TNew_mask(char tipocf, bool fatt, bool edit);
  virtual ~TNew_mask() {}
};                                                         

bool TNew_mask::tipomov_handler(TMask_field& f, KEY k)
{
  if (k == K_ENTER)
  {
    TNew_mask& m = (TNew_mask&)f.mask();
    if (!m._allow_fatt && f.get() == "1")
      return f.error_box("Non e' possibile utilizzare una fattura come pagamento");
  }
  
  return TRUE;
}

TNew_mask::TNew_mask(char tipocf, bool fatt, bool edit)
         : TMask("cg2100n"), _allow_fatt(fatt)
{   
  TMask_field& tipomov = field(P_NUOVO);
#ifdef __EXTRA__
  tipomov.set_handler(tipomov_handler);
  tipomov.enable();
  tipomov.set(_allow_fatt ? "1" : "3");
  if (!_allow_fatt)
    set_caption("Nuovo pagamento");
#else  
  tipomov.disable();
#endif  

  enable(P_ANNO,   edit);
  enable(P_NUMERO, edit);
  if (edit) first_focus(P_NUMERO);
  
  const char a = TPartita::allineamento_richiesto(tipocf);
  field(P_NUMERO).set_justify(a == 'R');
}         

///////////////////////////////////////////////////////////
// Maschera partite
///////////////////////////////////////////////////////////

void TGame_mask::append_conto(TString& s) const
{
  switch (conto().tipo()) 
  {
  case 'C':
    s << "Cliente"; break;
  case 'F':
    s << "Fornitore"; break;
  default:
    s << "Conto " << conto().gruppo() << ' ' << conto().conto(); break;
  }    
  s << ' ' << conto().sottoconto();  
}

TGame_mask::TGame_mask(const TBill& bill, long numreg, int riga) 
: TMask("cg2100p"), _conto(bill), _numreg(numreg), _numrig(riga),
  _changed(FALSE), _valfirst(FALSE), _causali(LF_CAUSALI, "CODCAUS", "DESCR")
{     
  TString descr(80);
  append_conto(descr);
  descr << ' ' << ((TBill&)_conto).descrizione();
  set(P_DESCR, descr);
              
#ifdef __EXTRA__  
  xvt_statbar_set("Estratto conto", TRUE);

  disable(-3);     // Disabilita gestione valuta
  hide(P_RESIDUO);
  hide(P_RESIDUOVAL);
#else
  TValuta val;
  const TRiga_partite* row = cerca_prima_riga();
  if (row != NULL)
  {                                   
    val.get(*row);                               // Legge valuta standard dalla partita
    set(P_ANNO, row->get(PART_ANNO));            // Propone anno e partita
    set(P_NUMERO, row->get(PART_NUMPART));
  }
  else
  {
    TMask& cm = app().curr_mask();               // Legge valuta dal movimento      
    val.get(cm, SK_VALUTA, SK_DATACAMBIO, SK_CAMBIO);
    
    if (cm.id2pos(F_ANNORIF) > 0)                // Se in testata c'e' l'anno di riferimento
    {
      set(P_ANNO, cm.get(F_ANNORIF));            // Propone anno e partita
      set(P_NUMERO, cm.get(F_NUMRIF));             
    }  
  }
  val.set(*this, P_VALUTA, P_DATACAMBIO, P_CAMBIO);
  enable(-3, val.in_valuta());
#endif  
  
  set_handler(P_ANNO,    annopart_handler);
  set_handler(P_NUMERO,  numpart_handler);
  set_handler(P_SHOWALL, show_all_handler);
  set_handler(P_NUOVO,   nuovo_handler);
  set_handler(P_CAMBIO,  cambio_handler);
  
  TSheet_field& games = partite();
  games.set_notify(partite_notify);
    
  scadenze().set_notify(scadenze_notify);
  scadenze().sheet_mask().set_handler(100, edit_scadenza_handler);
  
  fill_partite();                                     // Riempie sheet partite
}

///////////////////////////////////////////////////////////                          
// Handlers dei campi e della maschera principale
///////////////////////////////////////////////////////////                          

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

bool TGame_mask::numpart_handler(TMask_field& f, KEY k)
{
  if (k == K_TAB && f.focusdirty())
  {                  
    const TGame_mask& m = (const TGame_mask&)f.mask();
    const int anno = m.get_int(P_ANNO);        // Anno partita da cercare
    if (anno > 0)
    {
      const TString key = f.get();             // Numero partita da cercare
      int best_match = 0;                      // Partita piu' somigliante
      long min_dist = 10000000L;               // Livello di somiglianza migliore
      
      TSheet_field& sheet = m.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 ...
        {        
          const long dist = m.number_distance(key, row.get());
          if (i == 0 || dist < min_dist)
          {
            min_dist = dist;
            best_match = i;
            if (dist == 0L)
              break;
          }
        }  
      }
      sheet.select(best_match);                   // seleziona la partita
    }
  }
  return TRUE;
}

bool TGame_mask::show_all_handler(TMask_field& f, KEY k)
{
  TGame_mask& gm = (TGame_mask&)f.mask();
  if (k == K_SPACE && gm.is_running())
  {
    gm.fill_partite();
  } 
  return TRUE;
}

bool TGame_mask::cambio_handler(TMask_field& f, KEY k)
{
  if (k == K_TAB && f.focusdirty())
  {
    TGame_mask& gm = (TGame_mask&)f.mask();
    const bool needed = app().partite().mov2rig(gm._numreg, gm._numrig) > 0;
    if (needed && yesno_box("Aggiornare gli importi dei pagamenti?"))
    {
      const TValuta val(gm, P_VALUTA, P_DATACAMBIO, P_CAMBIO);
      gm.aggiorna_valuta(val);
    }  
    gm.aggiorna_residuo();
  }
  return TRUE;
}

///////////////////////////////////////////////////////////                          
// Metodi dei campi e della maschera principale
///////////////////////////////////////////////////////////                          

// Aggiorna il campo con il residuo da spendere sui pagamenti
void TGame_mask::aggiorna_residuo()
{                            
#ifndef __EXTRA__
  _importo = app().get_cgs_imp(_numrig-1);                     // Importo sulla riga contabile
  _residuo = _importo;
  
  TPartite_array& giochi = app().partite();
  const TImporto speso = giochi.importo_speso(_numreg, _numrig); 
  _residuo -= speso;                                           // Residuo della riga

  const char sez = calcola_sezione();                          // Sezione di riferimento
  _residuo.normalize(sez);
  set(P_RESIDUO, _residuo.valore());
  
  const TValuta cambio(*this, P_VALUTA, P_DATACAMBIO, P_CAMBIO);
  if (cambio.in_valuta())
  {                                                                         
    // Importo della riga contabile senza differenza cambi
    _resval = _importo;
    const TImporto abb_diff = giochi.importo_speso(_numreg, _numrig, FALSE, 0x6);
    _resval -= abb_diff;
    cambio.lit2val(_resval);
    const TImporto spesoval = giochi.importo_speso(_numreg, _numrig, TRUE, 0x1);
    _resval -= spesoval;                                       // Residuo della riga
    _resval.normalize(sez);
    set(P_RESIDUOVAL, _resval.valore());
  }
#endif  
}

// Scandisce tutte le partite per cercare la prima del movimento corrente
const TRiga_partite* TGame_mask::cerca_prima_riga() const
{   
  const TRiga_partite* riga = app().partite().mov2rig(_numreg, _numrig);
  return riga;
}


void TGame_mask::aggiorna_valuta(const TValuta& val)
{          
  TPartite_array& pa = app().partite();
  for (TPartita* game = pa.first(); game; game = pa.next())
  {
    for (int r = game->last(); r > 0; r = game->pred(r))
    {
      const TRiga_partite& riga = game->riga(r);
      for (int s = riga.rate(); s > 0; s--)
      {
        const TRiga_scadenze& scad = riga.rata(s);
        for (int p = scad.last(); p > 0; p = scad.pred(p))
        {
          TRiga_partite& sum = game->riga(p);
          if (sum.get_long(PART_NREG) == _numreg && 
              sum.get_int(PART_NUMRIG) == _numrig)
          {     
            TRectype pag(scad.row(p));
            real imp(pag.get(PAGSCA_IMPORTOVAL));
            val.val2lit(imp);
            pag.put(PAGSCA_IMPORTO, imp);          // Converte in lire l'importo in valuta
#ifdef __EXTRA__
            game->modifica_pagamento(pag, val, TRUE);
#else                           
            app().notify_edit_pagamento(*game, pag, val);
#endif            
          }
        }
      }
    }
  }  
  fill_partite(); 
}

/*
void TGame_mask::aggiorna_sorelle(const TRiga_partite& part) const
{     
  TPartite_array& pa = app().partite();
  for (TPartita* game = pa.first(); game; game = pa.next())
  {
    for (int r = game->last(); r > 0; r = game->pred(r))
    {
      TRiga_partite& row = game->riga(r);
      if (row.get_long(PART_NREG) == _numreg && row.get_int(PART_NUMRIG) == _numrig)
      {
        row.put(PART_DESCR,   part.get(PART_DESCR));
        row.put(PART_DATAPAG, part.get(PART_DATAPAG));
        row.put(PART_TIPOPAG, part.get(PART_TIPOPAG));
      }
    }
  }  
} 
*/

bool TGame_mask::partite_notify(TSheet_field& partite, int r, KEY k)
{
  TGame_mask& gm = (TGame_mask&)partite.mask();

  if (k == K_TAB)
  {           
    const bool changing_row = gm._riga_partite != r;
    if (!changing_row)
      return TRUE;
      
    main_app().begin_wait();  
    
    gm._riga_partite = r;
    
    TSheet_field& sheet = gm.scadenze();
    TString_array& scadenze = sheet.rows_array();           // Array delle righe
    scadenze.destroy();                                     // Azzera righe
    
    TToken_string& row = partite.row(r);
    const int anno = row.get_int(0);                        // Anno partita
    const TString16 num = row.get();                        // Numero partita
    gm.set(P_ANNO, anno);                                   // Aggiorna campi di ricerca
    gm.set(P_NUMERO, num);
    
    TValuta prima_valuta;                                   // Codice prima valuta
      
    if (anno > 0)
    {
      const TBill& zio = gm.conto();                          // Conto cliente/fornitore
      
      TPartita* game = app().partite().exist(zio, anno, num); // Cerca la partita tra quelle editate
      const bool should_delete_game = (game == NULL);         // Ricorda di fare delete
      if (should_delete_game)                                 // Se non c'era ...
        game = new TPartita(zio, anno, num);                  // ... creane una temporanea
      
      TImporto tot_lit, tot_val;
      TToken_string riga_fattura(80);
      
      const int lastrow = game->last();
      
      if (lastrow > 0)
        prima_valuta.get(game->riga(lastrow));
      const bool in_valuta = prima_valuta.in_valuta();
      
      for (int ri = game->first(); ri <= lastrow; ri = game->succ(ri))
      {
        const TRiga_partite& riga = game->riga(ri);
        if (!riga.is_fattura())
          continue;

        riga_fattura.cut(0);
        riga_fattura.add(ri);
        riga_fattura.add("");
        riga_fattura.add(riga.get(PART_DATADOC)); 
        riga_fattura.add("");     // Data scad
        gm.add_descrizione(riga_fattura, riga);
        gm.add_importo(riga_fattura, riga.importo(FALSE, 0x1));
        if (in_valuta)
          gm.add_importo(riga_fattura, riga.importo(TRUE, 0x1), TRUE);
        else
          riga_fattura.add("");  
        riga_fattura.add(riga.get(PART_NREG));
        riga_fattura.add(riga.get(PART_DATAREG));
        riga_fattura.add(riga.get(PART_NUMDOC)); 
        riga_fattura.add(riga.get(PART_PROTIVA)); 
        riga_fattura.add(riga.get(PART_TIPOMOV)); 
        scadenze.add(riga_fattura);

        for (int ra = 1; ra <= riga.rate(); ra++)
        {
          const TRiga_scadenze& scad = riga.rata(ra);
            
          TToken_string& row = scadenze.row(scadenze.add(riga_fattura));
          row.add(ra, 1);                            
          row.add(scad.get(SCAD_DATASCAD), 3); 
          gm.add_importo(row, scad.importo(FALSE), FALSE, 5);
          if (in_valuta)
            gm.add_importo(row, scad.importo(TRUE), TRUE, 6);
          
          const TString& descr = scad.get(SCAD_DESCR);   
          if (descr.not_empty())
            row.add(descr, 4);
          
          const bool blocked = scad.get_bool(SCAD_BLOCCATA);
          row.add(blocked ? "X" : " ", 13);
            
          const int lastp = scad.last();
          for (int pa = scad.first(); pa <= lastp; pa = scad.succ(pa))
          {
            const TRectype& pag = scad.row(pa);
            const TRiga_partite& sum = game->riga(pa);
            const char sez = sum.sezione();
              
            TToken_string& row = scadenze.row(scadenze.add(""));
            row.add(ri);
            row.add(ra);
            row.add(sum.get(PART_DATADOC)); 
            row.add(sum.get(PART_DATAPAG)); 
            gm.add_descrizione(row, sum);
            const TImporto imp(sez, pag.get_real(PAGSCA_IMPORTO));
            if (in_valuta)
            {
              gm.add_importo(row, imp);
              gm.add_importo(row, TImporto(sez, pag.get_real(PAGSCA_IMPORTOVAL)), TRUE);
            }  
            else
            {
              gm.add_importo(row, imp);
              row.add("");
            }  
            row.add(sum.get(PART_NREG));
            row.add(sum.get(PART_DATAREG));
            row.add(sum.get(PART_NUMDOC)); 
            row.add(""); 
            row.add(sum.get(PART_TIPOMOV)); 
            row.add(pa);
            
            // Le ritenute non possono esistere in valuta
            if (!in_valuta)
            {
              const TImporto rit(sez, pag.get_real(PAGSCA_RITENUTE)); 
              if (!rit.is_zero())   
              {
                TToken_string& rrit = scadenze.row(scadenze.add(""));
                rrit.add("Ritenute professionali", 4); 
                gm.add_importo(rrit, rit, FALSE);
                rrit.add(sum.get(PART_TIPOMOV), 11);
              }
            }  

            // Gli abbuoni e le differenze cambio esistono solo se e' a saldo
            if (pag.get_char(PAGSCA_ACCSAL) == 'S')
            {
              const TImporto abb(sez, pag.get_real(PAGSCA_ABBUONI));
              if (!abb.is_zero())
              {
                TToken_string& rabb = scadenze.row(scadenze.add(""));
                const char tipo_abb = pag.get_char(PAGSCA_PASSATT);
                rabb.add("Abbuoni ", 4); 
                rabb << (tipo_abb == 'A' ? "attivi" : "passivi");
                if (in_valuta)
                {                   
                  TImporto abb_lit = abb;
                  prima_valuta.val2lit(abb_lit);
                  gm.add_importo(rabb, abb_lit, FALSE);
                  gm.add_importo(rabb, abb, TRUE);
                }  
                else  
                {
                  gm.add_importo(rabb, abb, FALSE);
                  rabb.add("");
                }
                rabb.add(sum.get(PART_TIPOMOV), 11);
              }
              
              // Le differenze cambio possono esistere solo in valuta
              if (in_valuta)  
              {
                const TImporto diff(sez, pag.get_real(PAGSCA_DIFFCAM));
                if (!diff.is_zero())
                {
                  TToken_string& rdiff = scadenze.row(scadenze.add(""));
                  rdiff.add("Differenza cambio", 4);
                  gm.add_importo(rdiff, diff);
                  rdiff.add(sum.get(PART_TIPOMOV), 11);
                }
              }  
            
            }      // Il pagamento era a saldo
          }        // Fine ciclo sui pagamenti della rata
    
          TToken_string& rsal = scadenze.row(scadenze.add(""));
          rsal.add("Saldo rata ", 4); rsal << ra;
          if (!scad.chiusa())
          {           
            TImporto sl = scad.residuo(FALSE);
            gm.add_importo(rsal, sl);
            tot_lit += sl;
              
            if (in_valuta)
            { 
              sl = scad.residuo(TRUE, 0xB);
              gm.add_importo(rsal, sl, TRUE);
              tot_val += sl;
            }  
          }  
        }
      }
      
      TRecord_array& unas = game->unassigned();
      const int lastp = unas.last_row();
      for (int pa = unas.first_row(); pa <= lastp; pa = unas.succ_row(pa))
      {
        const TRectype& pag = unas.row(pa);
        const TRiga_partite& sum = game->riga(pa);
        const char sez = sum.sezione();
          
        TToken_string& row = scadenze.row(scadenze.add(""));
        row.add(pag.get(PAGSCA_NRIGA));
        row.add(pag.get(PAGSCA_NRATA));
        row.add(sum.get(PART_DATADOC)); 
        row.add(sum.get(PART_DATAPAG));
        gm.add_descrizione(row, sum);
        
        TImporto imp(sez, pag.get_real(PAGSCA_IMPORTO));
        gm.add_importo(row, imp);
        tot_lit += imp;
        
        const real& impval = pag.get_real(PAGSCA_IMPORTOVAL);
        if (!impval.is_zero())     
        { 
          imp.set(sum.sezione(), impval);
          imp.normalize();
          gm.add_importo(row, imp, TRUE);
          tot_val += imp;
        }  
        else
          row.add("");  
        row.add(sum.get(PART_NREG));
        row.add(sum.get(PART_DATAREG));
        row.add(sum.get(PART_NUMDOC)); 
        row.add(""); 
        row.add(sum.get(PART_TIPOMOV)); 
        row.add(pa);
        
        const TImporto rit(sez, pag.get_real(PAGSCA_RITENUTE));
        if (!rit.is_zero())
        {
          TToken_string& row = scadenze.row(scadenze.add(""));
          row.add("Ritenute professionali", 4); 
          gm.add_importo(row, rit, FALSE);
          row.add(sum.get(PART_TIPOMOV), 11);
          tot_lit += rit;
        }
      }
      
      if (lastrow > 0)
      {        
        TToken_string& sp = scadenze.row(scadenze.add(""));
        sp.add("Saldo partita", 4);
        if (prima_valuta.in_valuta())
          sp << ' ' << prima_valuta.codice();
#ifdef __EXTRA__
        prima_valuta.set(gm, P_VALUTA, P_DATACAMBIO, P_CAMBIO);
#endif         
        gm.add_importo(sp, tot_lit);
        gm.add_importo(sp, tot_val, TRUE);
      }
    
      if (should_delete_game)
        delete game;
    }
    
    if (prima_valuta.in_valuta() != gm._valfirst)
    { 
      sheet.swap_columns(106, 107); // Scambia le colonne dell'importo in lire e in valuta
      gm._valfirst = !gm._valfirst;
    }
    
    if (sheet.items() > 0)
      sheet.select(0, TRUE);
    else  
      sheet.force_update(); 
      
    main_app().end_wait();  
  }   
  
  if (k == K_INS)
  {
    gm.send_key(K_CTRL + 'N', 0, &partite);  // Simula la pressione del tasto nuovo
    return FALSE;                            // Rifiuta l'aggiunta di una riga
  }
  
  return TRUE;
}

bool TGame_mask::scadenze_notify(TSheet_field& scadenze, int r, KEY k)
{
  if (k == K_INS)
  {
    TGame_mask& gm = (TGame_mask&)scadenze.mask();
    gm.send_key(K_CTRL + 'N', 0, &scadenze); // Simula la pressione del tasto nuovo
    return FALSE;                            // Rifiuta l'aggiunta di una riga
  }
  return TRUE;
}


// Complesso algoritmo per calcolare la sezione di una nuova riga partita
char TGame_mask::calcola_sezione(tipo_movimento tm) const
{ 
  char sezione = ' ';
  const char tipoc = conto().tipo();

#ifndef __EXTRA__ 
  const TCausale& causale = app().causale();
  tm = (tipo_movimento)causale.tipomov();
  sezione = causale.sezione(1);                     // Usa la sezione della causale
#endif
  
  if (sezione <= ' ')                               // Se non c'e' la sezione bell'e' ch'e' pronta
  {
    if (tm == tm_fattura || tm == tm_insoluto)      // calcola in base al tipo movimento e
      sezione = (tipoc == 'C') ? 'D' : 'A';         // al tipo cliente/fornitore
    else  
      sezione = (tipoc == 'C') ? 'A' : 'D';
  }

#ifndef __EXTRA__ 
  // Gestione compensazioni
  if (tipoc > ' ')                                  // Se il tipo e' C o F
  {
    TBill bill; causale.bill(1, bill);              // Legge primo conto causale
    const char tc = bill.tipo();
    if (tc > ' ' && tc != tipoc)
      sezione = (sezione == 'D') ? 'A' : 'D';       // scambia segno
  }
#endif

  return sezione;
}

int TGame_mask::nuova_riga(TPartita& partita, tipo_movimento tm) const
{ 
  const int una_riga = partita.last();              // Memorizza una riga valida

  TRiga_partite& part = partita.new_row();          // Creazione nuova riga vuota
  const int nriga = part.get_int(PART_NRIGA);       // Nuova riga
  
  // Copia dati movimento corrente
  part.put(PART_NREG,   _numreg);                   // Numero operazione
  part.put(PART_NUMRIG, _numrig);                   // Riga su cui ho cliccato
  
  // Forza il gruppo/conto cliente corretto 
  part.put(PART_GRUPPOCL, conto().gruppo());
  part.put(PART_CONTOCL,  conto().conto());
  
  part.put(PART_TIPOMOV, (int)tm);       
  
  if (una_riga > 0)
  {
    const char* valuta = partita.riga(una_riga).get(PART_CODVAL);
    part.put(PART_CODVAL, valuta);
  }

#ifdef __EXTRA__    
  const TDate oggi(TODAY);
  const char* s = oggi.string();
  part.put(PART_DATADOC, s);
  part.put(PART_DATAREG, s);
#else
  // Setta il cambio corrente
  const TValuta valuta(*this, P_VALUTA, P_DATACAMBIO, P_CAMBIO);
  valuta.put(part);

  TMask& cm = app().curr_mask();
  const TCausale& causale = app().causale();
  part.put(PART_NUMDOC,  cm.get(F_NUMDOC));
  part.put(PART_DATADOC, cm.get(F_DATADOC));
  part.put(PART_DATAREG, cm.get(F_DATAREG));
  part.put(PART_DESCR,   cm.get(F_DESCR));
  part.put(PART_DATAPAG, cm.get(F_DATAREG));
  part.put(PART_TIPOPAG, 1);
  
  const TRiga_partite* prima = (tm != tm_fattura) ? cerca_prima_riga() : NULL;
  if (prima != NULL && prima != &part)
  {
    part.put(PART_DESCR,   prima->get(PART_DESCR));
    part.put(PART_DATAPAG, prima->get(PART_DATAPAG));
    part.put(PART_TIPOPAG, prima->get(PART_TIPOPAG));
  }
  
  // Copia dati causale corrente
  part.put(PART_CODCAUS, causale.codice());
  if (causale.iva() != nessuna_iva)
  {
    part.put(PART_REG,     cm.get(F_CODREG));
    part.put(PART_PROTIVA, cm.get(F_PROTIVA));
  }   
#endif    

  const char sezione = calcola_sezione(tm);
  
  // Memorizza solo la sezione (importi nulli)  
  part.put(PART_SEZ,       sezione);
  part.put(PART_SEZABB,    sezione); 
  part.put(PART_SEZDIFCAM, sezione);
  
  return nriga;
}

int TGame_mask::nuovo_pagamento(TPartita& partita, int nriga, int rata, tipo_movimento tm) const
{              
#ifdef __EXTRA__                
  const int nrigp = nuova_riga(partita, tm);
#else
  int nrigp = partita.mov2rig(_numreg, _numrig);       // Cerca riga partita relativa alla riga rmov
  if (nrigp <= 0)                                      // Devo creare una nuova riga di partita
    nrigp = nuova_riga(partita, tm);
#endif
  TRectype& pagamento = partita.pagamento(nriga, rata, nrigp);      // Crea nuovo pagamento
  
  // Calcola riga causale per la contropartita in base al tipo pagamento
  int caus = 2;          
  
  if (nriga != TPartita::UNASSIGNED)
  {       
    const TRiga_partite& fatt = partita.riga(nriga);
    const TRiga_scadenze& scad = fatt.rata(rata);
    const int tp = scad.get_int(SCAD_TIPOPAG);
    caus = partita.tipopag2causale(tp);
    
    TRiga_partite& somma = partita.riga(nrigp);
    somma.put(PART_TIPOPAG, tp);
    somma.put(PART_CODVAL, fatt.get(PART_CODVAL));
    
    pagamento.put(PAGSCA_CODABIPR, scad.get(SCAD_CODABIPR));
    pagamento.put(PAGSCA_CODCABPR, scad.get(SCAD_CODCABPR));
    pagamento.put(PAGSCA_CODABI,   scad.get(SCAD_CODABI));
    pagamento.put(PAGSCA_CODCAB,   scad.get(SCAD_CODCAB));
    pagamento.put(PAGSCA_CODAG,    scad.get(SCAD_CODAG));
  }

#ifndef __EXTRA__  
  const TCausale& causale = app().causale();
  TBill contro; causale.bill(caus, contro);    // Legge conto contropartita
  if (caus != 2 && contro.empty())             // Se non specificato ...
    causale.bill(caus = 2, contro);            // ... prende il primo
  contro.put(pagamento, TRUE);                 // Scrive conto contropartita
#endif  
  
  return nrigp;
}

bool TGame_mask::edit_scadenza_handler(TMask_field& f, KEY k)
{             
  if (k == K_SPACE)
  {
    TMask& m = f.mask();
    const int nriga = m.get_int(101);  // Numero riga fattura

    if (nriga == 0)
      return FALSE;                    // Ho cliccato su di un saldo (per sbaglio!)
    
    TGame_mask& gm = (TGame_mask&)(m.get_sheet()->mask());
    const TBill&  bill   = gm.conto();             // Clifo 
    
    TSheet_field& sp = gm.partite();
    TToken_string& spr = sp.row(sp.selected());
    const int anno = spr.get_int(0);               // Anno
    const TString numero = spr.get();              // Numero
    
    TPartite_array& giochi = app().partite();
    TPartita* was = giochi.exist(bill, anno, numero);      // Controlla esistenza nell'array
    TPartita& game = was ? *was : giochi.partita(bill, anno, numero);
    
    long nreg = m.get_long(108);       // Numero registrazione
    const int nrata = m.get_int(102);  // Rata selezionata (puo' essere 0)
    int nrigp = m.get_int(113);        // Pagamento selezionato (puo' essere 0)
    
    if (nrata != 0 && nrigp == 0)
    {          
      if (m.get_bool(114))
      {
        if (was == NULL) giochi.destroy(game);
        return f.error_box("La rata %d e' bloccata.", nrata);
      }  

#ifndef __EXTRA__
      const TValuta parval(game.riga(nriga));
      const TValuta curval(gm, P_VALUTA, P_DATACAMBIO, P_CAMBIO);
      if (parval != curval)
      {
        TString c = parval.codice();
        if (c.empty()) c = "lire";

        if (was == NULL) giochi.destroy(game);
        return f.error_box("La fattura deve essere pagata in %s.", (const char*)c);
      }                   
#endif
      
      tipo_movimento tm;

#ifdef __EXTRA__
      TMask* nm = new TNew_mask(gm.conto().tipo(), FALSE, FALSE);
      nm->set(P_ANNO, game.anno());
      nm->set(P_NUMERO, game.numero());
      const KEY k = nm->run();
      
      if (k == K_ENTER)
        tm = (tipo_movimento)nm->get_int(P_NUOVO);
      else  
      {
        if (was == NULL) giochi.destroy(game);
        return FALSE;
      }  
      delete nm;   
#else        
      tm = (tipo_movimento)app().causale().tipomov();
#endif    
      
      nrigp = gm.nuovo_pagamento(game, nriga, nrata, tm);
      nreg = gm._numreg;
    }
    
    bool cambiato  = FALSE;
    
    if (nrigp > 0)            // Si vuole editare un pagamento
    {                       
      if (nreg == gm._numreg)
      {
        cambiato = gm.edit_pagamento(game, nriga, nrata, nrigp);
        if (cambiato)
        {                              
#ifdef __EXTRA__
          game.rewrite();   // In extra-contabile salvo subito!
#endif            
        }  
      }
      else
      {
#ifdef __EXTRA__
        gm.prima_nota(nreg);
#else      
        if (was == NULL) giochi.destroy(game);
        return f.error_box("Modificare il movimento %ld", nreg);  
#endif        
      }  
    }
    else
    {                        // Si vogliono editare le rate
#ifdef __EXTRA__
      if (nreg > 0)
        gm.prima_nota(nreg);
      else  
        cambiato = gm.edit_fattura(game, nriga);
#else      
      if (nreg != gm._numreg || nrata == 0)
      {              
        if (nreg == 0)
          f.error_box("Utilizzare la gestione extra-contabile");
        else
          f.error_box("Modificare il movimento %ld", nreg);
        if (was == NULL) giochi.destroy(game);
        return FALSE;
      }  
#endif        
    }  
    
    if (cambiato)
    {                 
      if (m.is_running())               // Se la maschera e' aperta la chiudo
        m.stop_run(K_FORCE_CLOSE);
    
      TSheet_field& ss = gm.scadenze();
      const int rs = ss.selected();     // Memorizza la riga corrente
      gm.fill_partite();                // Aggiorna elenco partite
      if (rs < ss.items())              // Se esiste ancora ...
        ss.select(rs);                  // ... riporta la selezione sulla riga corrente
      gm._changed = TRUE;
    }  
  }
  return TRUE;
}

bool TGame_mask::nuovo_handler(TMask_field& f, KEY k)
{
  if (k == K_SPACE)
  { 
    TGame_mask& gm = (TGame_mask&)f.mask();
    int anno;
    TString numero;

#ifdef __EXTRA__
    const bool allow_fatt = TRUE;
#else
    const bool allow_fatt = FALSE;
#endif    
    TMask* new_game = new TNew_mask(gm.conto().tipo(), allow_fatt, TRUE);     
    
    tipo_movimento tm;

#ifndef __EXTRA__                     
    const TMask& cm = app().curr_mask();
    tm = (tipo_movimento)app().causale().tipomov();
    new_game->set(P_NUOVO, tm);
    if (tm == tm_nota_credito)
    {                    
      new_game->set(P_ANNO, cm.get(F_ANNORIF)); 
      new_game->set(P_NUMERO, cm.get(F_NUMRIF));
    }
#endif             

    k = new_game->run();
    tm = (tipo_movimento)new_game->get_int(P_NUOVO);
    anno   = new_game->get_int(P_ANNO);
    numero = new_game->get(P_NUMERO);
    
    // Distruzione maschera di richiesta
    delete new_game; new_game = NULL;
    
    if (k == K_ENTER)
    {             
      // Creazione nuova partita         
      TPartita& game = app().partite().partita(gm.conto(), anno, numero);
      
      bool edit = FALSE;
      // N.B. Le fatture non possone essere editate in modo contabile
      if (tm != tm_fattura)     
      {                              
        const int nriga = TPartita::UNASSIGNED;
        const int nrata = TPartita::UNASSIGNED;
        const int nrigp = gm.nuovo_pagamento(game, nriga, nrata, tm);
        edit = gm.edit_pagamento(game, nriga, nrata, nrigp);
#ifdef __EXTRA__      
        if (edit) game.rewrite();
#endif        
      }   
#ifdef __EXTRA__      
      else
        edit = gm.edit_fattura(game, 0);
#endif    
      
      if (edit)
      {
        gm.set(P_ANNO, anno);
        gm.set(P_NUMERO, numero);
        gm._changed = TRUE;
        
        // Aggiorna sheet partite: aggiunge la nuova partita e lo riordina
        gm.fill_partite();                    
      } // Sono state apportate modifiche 
    }
  }
  
  return TRUE;
}


///////////////////////////////////////////////////////////                          
// Metodi della maschera delle partite
///////////////////////////////////////////////////////////                          

void TGame_mask::add_importo(TToken_string& s, const TImporto& i, bool valuta, int pos)
{
  if (i.is_zero())
    s.add("", pos);  
  else  
  {              
    TString80 v;
    TImporto n(i); n.normalize();
    if (valuta)
    {
      v = n.valore().string(0, 3);
      const int sep = v.find('.');
      v[sep] = ',';
    }
    else
      v = n.valore().string(0, 0);
    v << ' ' << n.sezione();
    s.add(v, pos);
  }
} 

void TGame_mask::add_descrizione(TToken_string& s, const TRiga_partite& riga, int pos)
{
  const TString& desc = riga.get(PART_DESCR);
  if (desc.empty())
  {
    const TString& caus = riga.get(PART_CODCAUS);
    if (caus.not_empty())
      s.add(_causali.decode(caus), pos);
    else
      s.add("", pos);
  }
  else
    s.add(desc, pos);
}

TImporto TGame_mask::get_importo(TToken_string& s, int pos) const
{
  const TFixed_string imp(s.get(pos));
  const real i(imp);
  const char sez = imp.right(1)[0];
  return TImporto(sez, i);
} 

int TGame_mask::update_partita(const TRectype& riga, 
                               const TImporto& saldo, const TImporto& doc, 
                               const TImporto& pag, const TImporto& imp, int prow)
{              
  TSheet_field& games = partite();
  TToken_string &r = games.row(prow);                    // Stringa di lavoro per lo sheet
  if (!riga.empty())                                     // Esiste veramente 
  {
    r.cut(0);
    r.add(riga.get(PART_ANNO)); r.right_just(4);          // Mette gli spazi se ce n'e' bisogno
    r.add(riga.get(PART_NUMPART));
    r.add(riga.get(PART_DATADOC));
    r.add(riga.get(PART_NUMDOC));
    add_importo(r, saldo);
    add_importo(r, doc);
    add_importo(r, pag);
    add_importo(r, imp);
    r.add(riga.get(PART_DESCR)); 
  }
  else
  {
    r.add("", 4);
    r.add("", 5);
    r.add("", 6);
    r.add("", 7);
  }  
  
  if (prow >= 0)
  {                            
    games.force_update(prow);
    update_saldo_clifo();
    games.force_update(games.items()-1);
    aggiorna_residuo();
  }
  else
    prow = partite().items()-1;
    
  if (prow == 0)
  {
    const char all = TPartita::allineamento_richiesto(conto().tipo());
    field(P_NUMERO).set_justify(all == 'R');
  }  
  
  return prow;    
}

int TGame_mask::update_partita(const TPartita& part, int prow)
{                                            
  int r = part.prima_fattura();
  if (r <= 0) r = part.first();

  TImporto saldo, doc, pag, imp;                       
  part.calcola_saldo(saldo, doc, pag, imp);
  return update_partita(part.riga(r), saldo, doc, pag, imp, prow);
}

int TGame_mask::update_partita(const TRectype& riga, int prow)
{                                            
  TImporto saldo, doc, pag, imp;
  
  TRectype rec = riga;
  const int err = TPartita::read_saldo(rec, saldo, doc, pag, imp);
  return update_partita(rec, saldo, doc, pag, imp, prow);
}

void TGame_mask::update_saldo_clifo()
{                    
  TString_array& s = partite().rows_array();
  
  TImporto sal, doc, pag, imp;
  for (int i = 0; i < s.items(); i++)
  {                  
    TToken_string& r = s.row(i);
    if (r.get_int(0) > 0)
    {
      sal += get_importo(r, 4);
      doc += get_importo(r, -1);
      pag += get_importo(r, -1);
      imp += get_importo(r, -1);
    }  
    else
      break;
  }
  
  TToken_string& r = s.row(s.add("", i));
  r.add(""); 
  r.add("");
  r.add(TDate(TODAY).string());
  r.add("");
  add_importo(r, sal);
  add_importo(r, doc);
  add_importo(r, pag);
  add_importo(r, imp);
  r.add("Saldo "); 
  append_conto(r);
}

long TGame_mask::number_distance(const char* k, const char* n) const
{
  TString16 key(k); key.upper(); key.trim(); 
  const int kl = key.len();
  TString16 num(n); num.upper(); num.trim();
  const int nl = num.len();
  long dist = 0;
  for (int i = kl-1; i >= 0; i--)
  {
    const char kc = i < kl ? key[i] : 0;
    const char nc = i < nl ? num[i] : 0;
    const long d = abs(kc - nc) * (kl - i) * 32;
    dist += d;
  }
  return dist;
}

bool TGame_mask::same_number(const char* key, const char* num) const
{
  TString16 k(key); k.upper(); k.trim();
  TString16 n(num); n.upper(); n.trim();
  return k == n;
}

void TGame_mask::fill_partite()
{                                                 
  const int annorif = get_int(P_ANNO);           // Anno corrente    
  const TString numrif = get(P_NUMERO);          // Partita corrente
  const bool all = get(P_SHOWALL).not_empty();   // Visualizza anche partite chiuse
                              
  TString_array& a = partite().rows_array();
  a.destroy();

  app().begin_wait();
  
  TPartite_array& giochi = app().partite();
  for (TPartita* gioco = giochi.first(); gioco != NULL; gioco = giochi.next())
  {     
    // Visualizza solo le partite con almeno una riga!  Non posso scaricarle a priori in quanto
    // potrebbero essere state cancellate proprio ora e quindi devo tenerle cosi' per aggiornare
    // correttamente gli archivi.
    if (gioco->ok())     
    {        
      const TBill& k = gioco->conto();       
      bool u = (k.tipo() > ' ' && k.sottoconto() == conto().sottoconto()) || k == conto();

      if (u && !all && gioco->chiusa() && gioco->mov2rig(_numreg, _numrig) <= 0)                     
        u = FALSE;
      
      if (u)
        update_partita(*gioco, -1);             
    }  
    else
    {                               // Se la partita e' vuota ...
      if (!gioco->is_on_file())     // ... e non esiste su file
        giochi.destroy(*gioco);     // posso eliminarla tranquillamente
    }
  }
  
  TLocalisamfile partita(LF_PARTITE);
  TRectype& curpar = partita.curr();
  curpar.zero();
  if (conto().tipo() > ' ')                   // Ignora gruppo e conto dei clifo
  {
    curpar.put(PART_TIPOCF, conto().tipo());             
    curpar.put(PART_SOTTOCONTO, conto().codclifo()); 
  }
  else 
    conto().put(curpar);                      // Scrive completamente i conti normali
  
  const TRectype filter(curpar);              // Record campione

  for (int err = partita.read(_isgreat); 
       err == NOERR && curpar == filter; 
       err = partita.read(_isgreat))
  {
    if (!giochi.exist(curpar))
    {
      if (all || curpar.get_bool(PART_CHIUSA) == FALSE)
        update_partita(curpar, -1);
    }
    // Forza lettura partita successiva nella prossima read
    curpar.put(PART_NRIGA, (int)TPartita::UNASSIGNED); 
  }
  
  a.sort();
  for (int r = a.items()-1; r > 0; r--)
  {
    TToken_string& row = a.row(r);
    if (annorif == row.get_int(0) && same_number(numrif, row.get(1)))
      break;
  }

  update_saldo_clifo();
  partite().force_update();
  aggiorna_residuo();
  
  if (a.items() > 1)
  {
    _riga_partite = -1;
    partite().select(r, TRUE); 
  }  
  else
  {
    scadenze().destroy();
  }  
  app().end_wait();
}


bool TGame_mask::edit_pagamento(TPartita& p, int nriga, int nrata, int nrigp) const
{ 
  TRectype oldpag = p.pagamento(nriga, nrata, nrigp);
  TRiga_partite& somma  = p.riga(nrigp);

  const bool nuovo = oldpag.get(PAGSCA_ACCSAL) != "S" && 
                     oldpag.get_real(PAGSCA_IMPORTO).is_zero() &&
                     oldpag.get_real(PAGSCA_RITENUTE).is_zero();
  
  // We must create masks on the heap
  TPay_mask* pm = new TPay_mask(*this, nuovo ? MODE_INS : MODE_MOD);              
  TPay_mask& m = *pm;

  if (nriga == TPartita::UNASSIGNED)
  {              
    TRiga_scadenze& scaden = somma.new_row();        // Crea una rata falsa
    scaden.put(SCAD_DATASCAD, somma.get(PART_DATADOC));
    m.set_pag(oldpag, scaden, _residuo);
    somma.destroy_rows();                            // Distrugge la rata falsa
  }  
  else
  {
    const TRiga_scadenze& scaden = p.rata(nriga, nrata);
    m.set_pag(oldpag, scaden, _residuo);
  }
  
  KEY key = m.run();
  
  if (key == K_DEL)
  {
    const bool truly = yesno_box("Confermare l'eliminazione");
    if (!truly) key = K_ESC;
  }
  
  if (key == K_ESC && nuovo)
    key = K_DEL;
  
  if (key != K_ESC)
  {
    TRectype newpag(oldpag);

    if (key == K_DEL)
    {
      newpag.zero(PAGSCA_ACCSAL);                  // Non puo' essere un saldo
      newpag.zero(PAGSCA_IMPORTO);                 // Azzera importo ...
      newpag.zero(PAGSCA_IMPORTOVAL);              // .. anche in valuta
      newpag.zero(PAGSCA_RITENUTE);                // Azzera ritenute
    }
    else
    {
      m.get_pag(newpag, somma);   
    }
    
    const TValuta val(somma);                              
#ifdef __EXTRA__
    p.modifica_pagamento(newpag, val, TRUE);
#else  
    if (somma.is_nota_credito())      
      p.modifica_pagamento(newpag, val, TRUE);
    else
      app().notify_edit_pagamento(p, newpag, val);
#endif          
  }       
  
  delete pm;
  
  return key != K_ESC;
}

#ifndef __EXTRA__

///////////////////////////////////////////////////////////
// Edit delle partite
///////////////////////////////////////////////////////////

bool TPrimanota_application::edit_partite(const TMask& m, int riga)
{                           
  const char tipo = m.get(CG_TIPO)[0];
  const char rt = m.get(CG_ROWTYPE)[0];
  if (rt == 'T' && tipo <= ' ')           // Nelle note di credito DEVE essere un clifo
    return FALSE;

  const int gruppo = m.get_int(CG_GRUPPO);
  const int conto = m.get_int(CG_CONTO);
  const long sottoconto = m.get_long(CG_SOTTOCONTO);
  TBill b(gruppo, conto, sottoconto, tipo);  // Legge il conto della riga selezionata
  
  // Esci se il conto della riga cliente non e' valido
  if (!b.ok()) 
    return m.field(CG_SOTTOCONTO).error_box("Conto incompleto");
  
  // Aggiorna conto sulla riga contabile  
  b.add_to(cgs().row(riga), 3, 0x0);
    
  TMovimentoPN* pn = (TMovimentoPN*)get_relation();
  curr_mask().autosave(*pn);   // Aggiorna i dati della testata sulle partite
  partite().update_reg(pn->curr());
  
  // Esecuzione maschera di selezione partite
  TGame_mask* mask = new TGame_mask(b, pn->curr().get_long(MOV_NUMREG), riga+1); 
  mask->run();        
  const bool changed = mask->changed();
  delete mask;
  
  if (changed)
  {
    cgs().force_update();      // Aggiornamento righe contabili
    calcola_saldo();
  }
  return changed;
}

#endif
