// Chiusura/Apertura Conti

#include <applicat.h>
#include <config.h>
#include <mask.h>
#include <progind.h>

#include "cg4.h"
#include "cg4600.h"
#include "cg2101.h"      
#include "cglib02.h"

#include <pconti.h>
#include <mov.h>
#include <saldi.h>
#include <rmov.h>


#define MAX 98

class TApertura_chiusura : public TSkeleton_application
{
  TRelation*      _rel;
  TMovimentoPN*   _pn;
  TCursor*        _cur;
  TSaldo_agg*     _sld;
  TSaldo*         _sale;   
  TProgind*       _prog;  
  TConto          _tcbilch,_tcproper,_tcbilap,_tcutilp,_tcperdp,_tcutile,_tcperde, _conto_corrente;
  TEsercizi_contabili* _esc;

  real    _saldo, _totale_saldo, _capitale_netto;
  int     _annoesch, _annoesap;
  long    _numreg;
  TDate   _dataregap, _dataregch, _datacompch, _datacompap;
  TString _codcausap, _codcausch;

protected:  
  static bool mask_datac    (TMask_field&, KEY);
  static bool mask_dataap   (TMask_field&, KEY);
  static bool mask_distinti (TMask_field&, KEY);  
  static bool attivo_passivo(TMask_field&, KEY);
  static bool costi_ricavi  (TMask_field&, KEY);       
	static bool abilita_anni(TMask& m, KEY k);
	bool anni_contigui (int annoch, int annoap);
	const bool cerca_esercizio(int anno, TMask_field& f);

  long ultima_registrazione();
  void compila_testata(int anno,const TDate& datareg,const TString& codcaus,const TDate& datacomp);
  void registra_pn();

public:           
  virtual bool create();
  virtual bool destroy();
  virtual void main_loop();
  
  void costi ();
  void ricavi();
  void chiudi_attivita();
  void chiudi_passivita();
  void chiudi_conti_ordine();                                              
  void apri_attivita();
  void apri_passivita();     
  void apri_conti_ordine();
  void rmov_proper (int, long, TDate&, TRectype&, TConto&, real&, bool);
  void chiusura_conto_economico();
  void chiusura_conto_patrimoniale();
  void apertura_capitale_netto();
  bool set();
  
  TApertura_chiusura() {}
};

TApertura_chiusura& app() { return (TApertura_chiusura&) main_app(); }
                                      
bool TApertura_chiusura::abilita_anni(TMask& m, KEY k)
{
  if (k == K_SHIFT+K_F12)
  { 
    m.enable(F_ANNOCH);
    m.enable(F_ANNO);
  }
  return TRUE;
}
                                         
bool TApertura_chiusura::anni_contigui (int annoch, int annoap)
{
	const TEsercizio & chi = _esc->esercizio(annoch);
	const TEsercizio & ap = _esc->esercizio(annoap);
  const TDate inizio(ap.inizio() - 1L);
	const TDate fine(chi.fine());

  if (inizio != fine) 
    return warning_box(TR("I due esercizi indicati non risultano contigui"));
  
  return TRUE;
}

const bool TApertura_chiusura::cerca_esercizio(int anno, TMask_field& f)
{
  if (!_esc->exist(anno))
    return f.warning_box(TR("Esercizio non presente in tabella esercizi"));
  return TRUE;
}
                                         
bool TApertura_chiusura::mask_datac(TMask_field& f, KEY k)
{ 
  bool ok = TRUE;
  
  if ( k == K_TAB && f.focusdirty() )
  {
    TDate data = f.get();
    int anno = app()._esc->date2esc(data);
    
	  f.mask().set(F_ANNOCH, anno);   // Esercizio di chiusura
    if (anno == 0)
      return f.error_box("Esercizio non presente in tabella esercizi");
  } 

  if ( (k == K_ENTER) && f.to_check(k) )
  {                                          
		const TDate data    = f.get();
    const int annoch = f.mask().get_int(F_ANNOCH);
    const int annoap = f.mask().get_int(F_ANNO);                                        
		int anno = 0;

    if (app().cerca_esercizio(annoap,f) && app().cerca_esercizio(annoch,f) && 
				app().anni_contigui(annoch,annoap))
		{
			const TEsercizio & ap = app()._esc->esercizio(annoap);
			const TDate inizio  = ap.inizio();
			const TDate fine    = ap.fine();
			const TDate scarico = ap.scarico();

	    const TEsercizio & chi = app()._esc->esercizio(annoch);
			const TDate iniziop = chi.inizio();                     
			const TDate finep   = chi.fine();   
    
			if (data < finep)
			{
				f.warning_box (TR("La data di chiusura non puo' essere inferiore alla data di fine esercizio precedente"));
				return FALSE;
			}
			if (data > fine)
			{
				f.warning_box (TR("La data di chiusura non puo' essere superiore alla data di fine esercizio in corso"));
				return FALSE;
			}
			if ( scarico.ok() && (data <= scarico) )
			{
				f.warning_box (TR("La data di chiusura non puo' essere inferiore o uguale alla data di scarico")); 
				return FALSE;
			}       
			if ( (data >= inizio) && (data <= fine) ) //la data di chiusura e' cioe' relativa all'esercizio in corso   
				anno = fine.year();
			else if ( (data >= iniziop) && (data <= finep) ) //la data di chiusura e' cioe' relativa all'esercizio precedente 
				anno = finep.year();
		}
		else
			return FALSE;
    
		TRelation reg("REG");
		TRectype & tabreg = reg.curr();
    TString16 annos;

		annos.format("%04d", anno);
    tabreg.put("CODTAB", annos);
  
		TCursor cur(&reg, "", 1, &tabreg, &tabreg);
		const TRecnotype items = cur.items();

		cur.freeze();
		for (cur = 0L; cur.pos() < items; ++cur)
		{
			if (tabreg.get_int("I0") == 5)
      {
        const TDate datast(tabreg.get_date("D3"));

        if (data < datast)
					return f.warning_box(TR("La data di apertura non puo' essere inferiore alla data ultima stampa bollato")); 
      }     
    }
  }     
  return TRUE;
}

bool TApertura_chiusura::mask_dataap (TMask_field& f, KEY k)
{
  bool ok = TRUE;            

  if ( k == K_TAB && f.focusdirty() )
  {
    TDate data = f.mask().get_date(F_DATAAP);
    int   anno = app()._esc->date2esc(data);
    
    f.mask().set(F_ANNO, anno);              // Esercizio di apertura
    if (anno != 0)
    {
      const int pred = app()._esc->pred(anno);
      if (pred > 0)
			{
        f.mask().set(F_ANNOCH, pred);
        f.mask().set(F_DATAC, app()._esc->esercizio(pred).fine());
			}
    }
    else  
      return f.error_box(TR("Esercizio non presente in tabella esercizi"));
  } 

  if ( (k == K_ENTER) && f.to_check(k) )
  {                
    const int annoch = f.mask().get_int(F_ANNOCH);
    const int annoap = f.mask().get_int(F_ANNO);                                        
    const TDate data = f.get();  
    int anno = 0;
    
    if (app().cerca_esercizio(annoap,f) && app().cerca_esercizio(annoch,f) && 
				app().anni_contigui(annoch,annoap))
		{
			const TEsercizio & ap = app()._esc->esercizio(annoap);
			const TDate inizio  = ap.inizio();
			const TDate fine    = ap.fine();
			const TDate scarico = ap.scarico();

	    const TEsercizio & chi = app()._esc->esercizio(annoch);
			const TDate iniziop = chi.inizio();                     
			const TDate finep   = chi.fine();   

			if (data < inizio)
			{
				f.warning_box (TR("La data di apertura non puo' essere inferiore alla data di inizio esercizio in corso"));
				return FALSE;
			}
			if (data > fine)
			{
				f.warning_box (TR("La data di apertura non puo' essere superiore alla data di fine esercizio in corso"));
				return FALSE;
			}
			if ( scarico.ok() && (data <= scarico) )
			{
				f.warning_box (TR("La data di apertura non puo' essere inferiore o uguale alla data di scarico")); 
				return FALSE;
			}
    
			if ( (data >= inizio) && (data <= fine) ) //la data di apertura e' cioe' relativa all'esercizio in corso   
				anno = fine.year();
			else if( (data >= iniziop) && (data <= finep) ) //la data di apertura e' cioe' relativa all'esercizio precedente 
				anno = finep.year();
		}
		else
			return FALSE;
    
		TRelation reg("REG");
		TRectype & tabreg = reg.curr();
		TString16 annos; 
		
		annos.format("%04d", anno);
    tabreg.put("CODTAB", annos);
  
		TCursor cur(&reg, "", 1, &tabreg, &tabreg);
		const TRecnotype items = cur.items();

		cur.freeze();
		for (cur = 0L; cur.pos() < items; ++cur)
		{
			if (tabreg.get_int("I0") == 5)
      {
        const TDate datast(tabreg.get_date("D3"));

        if (data < datast)
					return f.warning_box(TR("La data di apertura non puo' essere inferiore alla data ultima stampa bollato")); 
      }     
    }
  }
  
  if (k == K_ENTER)
  {
    int anno = f.mask().get_int(F_ANNO);

    if (anno == 0)
      return f.warning_box(TR("L'eventuale esercizio di apertura non e' presente sulla tabella esercizi"));
  }     
  return TRUE;
}  

bool TApertura_chiusura::mask_distinti (TMask_field& f, KEY k)
{
  if (k == K_ENTER)
  {
    int idg = F_BILCHG;
    int idc = F_BILCHC;
    int ids = F_BILCHS;

    for (int i = 0; i < 6; i++)
    {
      const int  g = f.mask().get_int(idg);
      const int  c = f.mask().get_int(idc);
      const long s = f.mask().get_long(ids);
      
      int idg1 = idg;
      int idc1 = idc;
      int ids1 = ids;
      
      for (int j = i+1; j < 7; j++)
      {
        idg1 += 3;
        idc1 += 3;
        ids1 += 3;
        
        const int  gruppo = f.mask().get_int(idg1);
        const int  conto  = f.mask().get_int(idc1);
        const long sottoc = f.mask().get_long(ids1);
        
        if ((g == gruppo)&&(c == conto)&&(s == sottoc))
          return f.warning_box(FR("Il conto %d.%d.%ld non puo' essere ripetuto!"), gruppo, conto, sottoc);
      }
      
      idg += 3;
      idc += 3;
      ids += 3;
      
    }   
  }
  return TRUE;
}

bool TApertura_chiusura::attivo_passivo (TMask_field& f, KEY k)
{
  if (k == K_ENTER) 
  {
    int g,c;
    int id = f.dlg();
    
    if (id == F_UTILPC)
      g = f.mask().get_int(F_UTILPG);
    else
      if (id == F_PERDPC)
        g = f.mask().get_int(F_PERDPG);
        
    c = atoi(f.get());
    
    TString16 key;

		key.format("%d|%d", g, c);

		const TRectype & pcon = cache().get(LF_PCON, key);

		if (!pcon.empty())
    {
      int indbil = pcon.get_int(PCN_INDBIL);
      if (indbil != 1 && indbil != 2 && indbil != 5)
        return f.warning_box(TR("Indicatore di bilancio del conto %d %d errato: deve essere 1,2 o 5"), g, c);
    }      
  }     
  return TRUE;
}  

bool TApertura_chiusura::costi_ricavi (TMask_field& f, KEY k)
{
  if (k == K_ENTER) 
  {
    int g,c;
    int id = f.dlg();
    
    if (id == F_UTILEC)
      g = f.mask().get_int(F_UTILEG);
    else
      if (id == F_PERDEC)
        g = f.mask().get_int(F_PERDEG);
        
    c = atoi(f.get());
    
    TString16 key;

		key.format("%d|%d", g, c);

		const TRectype & pcon = cache().get(LF_PCON, key);
	  if (!pcon.empty())
    {
      int indbil = pcon.get_int(PCN_INDBIL);
      if (indbil != 3 && indbil != 4)
        return f.warning_box(TR("Indicatore di bilancio del conto %d %d errato: deve essere 3 o 4"), g, c);
    }      
  }     
  return TRUE;
}  

bool TApertura_chiusura::create()
{
  open_files(LF_TABCOM, LF_TAB, LF_SALDI, LF_PCON, LF_MOV, LF_RMOV, LF_RMOVIVA,
						 LF_PARTITE, LF_SCADENZE, LF_PAGSCA, 0);
		
	_rel   = new TRelation (LF_PCON);
  _cur   = new TCursor(_rel,"((GRUPPO!=\"\")&&(CONTO!=\"\")&&(SOTTOCONTO==\"\"))",1);
 
  _pn    = new TMovimentoPN();
  _sld   = new TSaldo_agg();
  _sale  = new TSaldo();
	_esc   = new TEsercizi_contabili;
         
  _capitale_netto = ZERO;
       
  return TSkeleton_application::create();
}

bool TApertura_chiusura::destroy()
{
  delete _sale;
  delete _esc;
  delete _pn;
  delete _rel;
  delete _cur;
  delete _sld;
  
  return TApplication::destroy();
}

long TApertura_chiusura::ultima_registrazione()
{
	TLocalisamfile mov(LF_MOV);

	// Leggo il numero di registrazione dell'ultimo record di mov, e lo 
	// incremento di uno per ottenere un numero di registrazione sicuramente non esistente.
	
	mov.last();
  _numreg = mov.get_long(MOV_NUMREG) + 1;
  return _numreg;                              
}

bool TApertura_chiusura::set()
{
  TMask m ("cg4600a");
  KEY     tasto;
  int     gbilch, cbilch , gproper, cproper, gbilap, cbilap, gutilp;
  int     cutilp, gperdp, cperdp, gutile, cutile, gperde, cperde;
  long    sbilch, sproper, sbilap, sutilp, sperdp, sutile, sperde;


  TConfig conf(CONFIG_DITTA);
  
  m.set(F_CHIUSURA, conf.get("CoCaCh"));
  m.set(F_APERTURA, conf.get("CoCaAp"));

  int anno_ap  = _esc->last();  
  TDate inizio = _esc->esercizio(anno_ap).inizio();

  // determina quello precedente
  const int anno_ch = _esc->pred(anno_ap);
  const TDate fine = _esc->esercizio(anno_ch).fine();  //data fine es. precedente
  
  if (anno_ap == anno_ch)
  {
    anno_ap = 0;
    inizio = botime;
  }
  
  m.set(F_ANNO,   anno_ap);
  m.set(F_ANNOCH, anno_ch);
  m.set(F_DATAC, fine);
  m.set(F_DATAAP, inizio);  
  
  m.set(F_BILCHG,  conf.get("CsBiChG"));
  m.set(F_BILCHC,  conf.get("CsBiChC"));
  m.set(F_BILCHS,  conf.get("CsBiChS"));
  m.set(F_PROPERG, conf.get("CsPrPeG"));
  m.set(F_PROPERC, conf.get("CsPrPeC"));
  m.set(F_PROPERS, conf.get("CsPrPeS"));
  m.set(F_BILAPG,  conf.get("CsBiApG"));
  m.set(F_BILAPC,  conf.get("CsBiApC"));
  m.set(F_BILAPS,  conf.get("CsBiApS"));
  m.set(F_UTILPG,  conf.get("CsUeCpG"));
  m.set(F_UTILPC,  conf.get("CsUeCpC"));
  m.set(F_UTILPS,  conf.get("CsUeCpS"));
  m.set(F_PERDPG,  conf.get("CsPeCpG"));
  m.set(F_PERDPC,  conf.get("CsPeCpC"));
  m.set(F_PERDPS,  conf.get("CsPeCpS"));
  m.set(F_UTILEG,  conf.get("CsUeCeG"));
  m.set(F_UTILEC,  conf.get("CsUeCeC"));
  m.set(F_UTILES,  conf.get("CsUeCeS"));
  m.set(F_PERDEG,  conf.get("CsPeCeG"));
  m.set(F_PERDEC,  conf.get("CsPeCeC"));
  m.set(F_PERDES,  conf.get("CsPeCeS"));
          
  m.set_handler (F_DATAC,  mask_datac);
  m.set_handler (F_DATAAP, mask_dataap);
  m.set_handler (F_PERDES, mask_distinti);
  m.set_handler (F_UTILPC, attivo_passivo);
  m.set_handler (F_PERDPC, attivo_passivo);
  m.set_handler (F_UTILEC, costi_ricavi);
  m.set_handler (F_PERDEC, costi_ricavi); 
  m.set_handler (abilita_anni);
  
  tasto = m.run();

  if (tasto == K_ENTER)
  {
    _annoesch   = m.get_int(F_ANNOCH);
    _annoesap   = m.get_int(F_ANNO);
    _dataregch  = m.get     (F_DATAC);
    _codcausch  = m.get     (F_CHIUSURA);
    _dataregap  = m.get     (F_DATAAP);
    _codcausap  = m.get     (F_APERTURA);  
	  if (_esc->exist(_annoesch))
			_datacompch = _esc->esercizio(_annoesch).fine();
    gbilch      = m.get_int (F_BILCHG);
    cbilch      = m.get_int (F_BILCHC);
    sbilch      = m.get_long(F_BILCHS);
    gproper     = m.get_int (F_PROPERG);
    cproper     = m.get_int (F_PROPERC);
    sproper     = m.get_long(F_PROPERS);
    gbilap      = m.get_int (F_BILAPG);
    cbilap      = m.get_int (F_BILAPC);
    sbilap      = m.get_long(F_BILAPS);
    gutilp      = m.get_int (F_UTILPG);
    cutilp      = m.get_int (F_UTILPC);
    sutilp      = m.get_long(F_UTILPS);
    gperdp      = m.get_int (F_PERDPG);
    cperdp      = m.get_int (F_PERDPC);
    sperdp      = m.get_long(F_PERDPS);
    gutile      = m.get_int (F_UTILEG);
    cutile      = m.get_int (F_UTILEC);
    sutile      = m.get_long(F_UTILES);
    gperde      = m.get_int (F_PERDEG);
    cperde      = m.get_int (F_PERDEC);
    sperde      = m.get_long(F_PERDES);         

    _tcbilch.set (gbilch,cbilch,sbilch);
    _tcproper.set(gproper,cproper,sproper);
    _tcbilap.set (gbilap,cbilap,sbilap);
    _tcutilp.set (gutilp,cutilp,sutilp);
    _tcperdp.set (gperdp,cperdp,sperdp);
    _tcutile.set (gutile,cutile,sutile);
    _tcperde.set (gperde,cperde,sperde);

    long cicli = (_cur->items() * 8) + 4;
    _prog  = new TProgind(cicli,TR("Chiusura/Apertura conti in corso... Prego attendere"),FALSE);

    _numreg = 0;
    (*_cur) = 0L;
    _sld->set_anno_es(_annoesch);
    _sld->set_movprovv(FALSE);
    _sld->set_tipo_saldo(chiusura); 
    _sld->set_movimentato(TRUE);       
        
    costi ();
    *_cur = 0l;
    ricavi();
    chiusura_conto_economico();
    _totale_saldo = ZERO;
    *_cur = 0l;
    chiudi_attivita();
    *_cur = 0l;
    chiudi_passivita();
    *_cur = 0l;
    chiudi_conti_ordine();
    chiusura_conto_patrimoniale();
    _totale_saldo = ZERO;
  
    _sld->set_anno_es(_annoesap);
    _sld->set_tipo_saldo(apertura);    
    _sld->set_movimentato(TRUE);
    
    *_cur = 0l;
    apri_attivita();
    *_cur = 0l;
    apri_passivita();
    *_cur = 0l;
    apri_conti_ordine();
    apertura_capitale_netto();

    delete _prog;
    message_box(TR("Apertura/chiusura conti completata"));
  }                              //K_ENTER
  return FALSE;
}

void TApertura_chiusura::compila_testata(int annoes,const TDate& datareg,const TString& codcaus,const TDate& datacomp)
{
  _numreg = ultima_registrazione();

  _pn->curr().zero(); 
  _pn->curr().put(MOV_ANNOES,   annoes);     //Viene generato un movimento
  _pn->curr().put(MOV_DATAREG,  datareg);    //a rottura di conto
  _pn->curr().put(MOV_CODCAUS,  codcaus);    
  _pn->curr().put(MOV_NUMREG,   _numreg); 
  _pn->curr().put(MOV_DATACOMP, datacomp);
}

void TApertura_chiusura::rmov_proper(int anno,long numrig,TDate& datareg,TRectype& rmov,                                    
                                     TConto& tc,real& tot_saldo,bool sezione_opposta)
{
  char sez_rmov = ' ';
  char sezione  = ' ';  
  real totale = tot_saldo;

  rmov.zero();
  rmov.put(RMV_ANNOES,     anno);
  rmov.put(RMV_NUMREG,     _numreg); 
  rmov.put(RMV_NUMRIG,     numrig);
  rmov.put(RMV_DATAREG,    datareg);
  rmov.put(RMV_GRUPPO,     tc.gruppo());
  rmov.put(RMV_CONTO,      tc.conto());
  rmov.put(RMV_SOTTOCONTO, tc.sottoconto());
  
  if (totale > ZERO)
  {       
    sez_rmov  = 'A';
    sezione   = 'D';
  }
  else
    if (totale < ZERO)
    {
      sez_rmov = 'D';
      sezione  = 'A';
      totale   = -totale;
    }
  
  if (sezione_opposta)
  {
    rmov.put(RMV_SEZIONE,    sez_rmov);
    _sld->aggiorna(tc,TImporto(sez_rmov,totale)); //Aggiorno anche i saldi con
                                                  // l'oggetto TSaldo_agg
  }
  else
  {
    rmov.put(RMV_SEZIONE,    sezione);
    _sld->aggiorna(tc,TImporto(sezione,totale)); //Aggiorno anche i saldi con 
                                                 //l'oggetto TSaldo_agg
  }
  rmov.put(RMV_IMPORTO,    totale);
}

void TApertura_chiusura::registra_pn()
{
  _pn->write();          
  _pn->destroy_rows(_numreg);  //Azzero l'oggetto pn.    

  _sld->set_num_ulmov(_numreg);
  _sld->set_data_ulmov(_pn->curr().get_date(MOV_DATAREG));
  _sld->registra();
  _sld->reset();
}

void TApertura_chiusura::costi()
{                                   
  bool      compila_mov = TRUE;
  long      s;
  char      sez_rmov = ' ', sezione = ' ';
  real      tot_saldo;
  long      numrig   = 0;
  TSaldo&   sale     = *_sale;
  int       j        = 0; 
	TLocalisamfile saldi(LF_SALDI);
  
  _totale_saldo = ZERO;
  tot_saldo     = ZERO;

  TRecnotype items_pcon  = _cur->items();
  
  for (int i = 0; i < items_pcon; i++, ++(*_cur))
  {
    int     indbil = _cur->curr().get_int(PCN_INDBIL);
    int     g      = _cur->curr().get_int(PCN_GRUPPO);
    int     c      = _cur->curr().get_int(PCN_CONTO);
    TString tmcf   = _cur->curr().get    (PCN_TMCF);
    
    _prog->addstatus(1);
    
    if (indbil == 3)
    { 
      compila_mov = TRUE;
      
      saldi.setkey(1);
			saldi.zero();
			saldi.put(SLD_ANNOES, _annoesch);
      saldi.put(SLD_GRUPPO, g);
      saldi.put(SLD_CONTO,  c);
      saldi.put(SLD_FLSCA,  FALSE);
            
      const TRectype rec(saldi.curr());

      j      = 0;
      numrig = 0;
      
      for (saldi.read(); ; saldi.next())
      {
        _saldo = ZERO;
        
        if (saldi.eof() || (saldi.curr() != rec)) 
        {
          // Aggiungo un ulteriore riga di movimento contenente la somma
          // di tutti i saldi aventi lo stesso conto, indicandola
          // con una sezione opposta al risultato (della somma).
          
          if (j >= 1)
          {
            numrig++;
            if (tot_saldo != ZERO)
              rmov_proper(_annoesch,numrig,_dataregch,_pn->cg(j),_tcproper,tot_saldo,FALSE);
            
            tot_saldo = ZERO;
          }
          break;
        }

        if (compila_mov)
        {
          compila_testata(_annoesch,_dataregch,_codcausch,_datacompch); //Reg. 1 Chiusura Costi
          compila_mov = FALSE;
        }

        s               = saldi.get_long(SLD_SOTTOCONTO);
        sale.ultima_immissione_bilancio(_annoesch,g,c,s,indbil, 1);
        _saldo          = sale.saldo();

        if (_saldo.is_zero())
					continue;
        
        numrig++;
        
        if (j >= MAX || saldi.eof())
        {
          // Aggiungo un ulteriore riga di movimento contenente la somma
          // di tutti i saldi aventi lo stesso sottoconto, indicandola
          // con una sezione opposta al risultato (della somma).

          if (tot_saldo != ZERO)
            rmov_proper (_annoesch,numrig,_dataregch,_pn->cg(j),_tcproper,tot_saldo,FALSE);
          registra_pn();
          
          j      = 0;
          numrig = 1;
          compila_testata(_annoesch,_dataregch,_codcausch,_datacompch); //Reg. 1 Chiusura Costi
          compila_mov = FALSE;
          tot_saldo   = ZERO;
        }

        if (_saldo >= ZERO)
          sezione = 'D';
        else
        {
          sezione = 'A';
          _saldo = -_saldo;
        }

        if (sezione == 'D')       // ---> Tengo una variabile in cui salvo gli
        {                         // importi trovati sui saldi. Quando ho
          sez_rmov   = 'A';       // finito di leggere i sottoconti, oppure
          tot_saldo += _saldo;    // quando ho raggiunto un massimo di 99
          _totale_saldo += _saldo;
        }                         // righe di movimento, genero un' altra    
        else                      // riga con importo di sezione opposta alla somma, mandando a zero   
        {                       // il saldo di quel movimento.
          sez_rmov   = 'D';
          tot_saldo -= _saldo;
          _totale_saldo -= _saldo; 
        }
        
        if (!saldi.eof())
        {
          TRectype& rmov = _pn->cg(j);
          
          rmov.zero();  
          rmov.put(RMV_ANNOES,     _annoesch);  //Compilo una riga di movimento
          rmov.put(RMV_DATAREG,    _dataregch); //per ogni sottoconto che leggo
          rmov.put(RMV_GRUPPO,     g);          //sui saldi. Siccome queste
          rmov.put(RMV_CONTO,      c);          //righe servono per mandare a 0
          rmov.put(RMV_SOTTOCONTO, s);          //il saldo dei movimenti, la
          rmov.put(RMV_SEZIONE,    sez_rmov);   //sezione sara' opposta a 
          rmov.put(RMV_IMPORTO,    _saldo);     //quella letta sui saldi.
          rmov.put(RMV_NUMREG,     _numreg);
          rmov.put(RMV_NUMRIG,     numrig);
          rmov.put(RMV_TIPOC,      tmcf);
          _tcproper.put(rmov, TRUE);            // Contropartita
          
          TBill tc(g,c,s); 
          _sld->aggiorna(tc,TImporto(sez_rmov,_saldo));    //l'oggetto TSaldo_agg
          j++;
        }
        if (saldi.eof()) break;
      }                        //for saldi
      if (j >= 1)
      {
        registra_pn();
        j = 0;
      }
    }                          // if (indbil == 3)                   
  }                            // for pcon
}

void TApertura_chiusura::ricavi()
{ 
  bool      compila_mov = TRUE;
  long      s;
  char      sez_rmov = ' ', sezione = ' ';
  real      tot_saldo;
  long      numrig   = 0;
  TSaldo&   sale     = *_sale;
  int       j        = 0;
	TLocalisamfile saldi(LF_SALDI);
    
  tot_saldo = ZERO;

  TRecnotype items_pcon  = _cur->items();
  
  for (int i = 0; i < items_pcon; i++, ++(*_cur))
  {
    int  indbil  = _cur->curr().get_int(PCN_INDBIL);
    int  g       = _cur->curr().get_int(PCN_GRUPPO);
    int  c       = _cur->curr().get_int(PCN_CONTO);
    TString tmcf = _cur->curr().get    (PCN_TMCF);
    
    _prog->addstatus(1);
        
    if (indbil == 4)
    {
      compila_mov = TRUE;
      
      saldi.zero();
      saldi.put(SLD_ANNOES, _annoesch);
      saldi.put(SLD_GRUPPO, g);
      saldi.put(SLD_CONTO,  c);
      saldi.put(SLD_FLSCA,  FALSE);      
      
      const TRectype rec(saldi.curr());

      j      = 0;
      numrig = 0;

      for (saldi.read(); ; saldi.next())
      {
        _saldo = ZERO;

        if (saldi.eof() || (saldi.curr() != rec)) 
        {
          // Aggiungo un ulteriore riga di movimento contenente la somma
          // di tutti i saldi aventi lo stesso conto, indicandola
          // con una sezione opposta al risultato (della somma).
          
          if (j >= 1)
          {
            numrig++;
            if (tot_saldo != ZERO)
              rmov_proper(_annoesch,numrig,_dataregch,_pn->cg(j),_tcproper,tot_saldo,FALSE);
            
            tot_saldo = ZERO;
          }
          break;
        }
      
        if (compila_mov)
        {
          compila_testata(_annoesch,_dataregch,_codcausch,_datacompch); //Reg. 2 Chiusura Ricavi
          compila_mov = FALSE;
        }
      
        //numrig++;
        s               = saldi.get_long(SLD_SOTTOCONTO);
        //sale.calcola_ultima_immissione(_annoesch,0,g,c,s,indbil);
        sale.ultima_immissione_bilancio(_annoesch,g,c,s,indbil, 1);
        _saldo          = sale.saldo();

        if (_saldo.is_zero()) continue;
        
        numrig++;
        
        if (j >= MAX || saldi.eof())
        {
          // Aggiungo un ulteriore riga di movimento contenente la somma
          // di tutti i saldi aventi lo stesso sottoconto, indicandola
          // con una sezione opposta al risultato (della somma).

          //      numrig++;
          if (tot_saldo != ZERO)
            rmov_proper (_annoesch,numrig,_dataregch,_pn->cg(j),_tcproper,tot_saldo,FALSE);
          registra_pn();

          j      = 0;
          numrig = 1;        
          compila_testata(_annoesch,_dataregch,_codcausch,_datacompch); //Reg. 2 Chiusura Ricavi         
          compila_mov = FALSE;
          tot_saldo = ZERO;
        }

        if (_saldo > ZERO)
          sezione = 'D';
        else
          if (_saldo < ZERO)
          {
            sezione = 'A';
            _saldo = -_saldo;
          }

        if (sezione == 'D')       // ---> Tengo una variabile in cui salvo gli
        {                         // importi trovati sui saldi. Quando ho
          sez_rmov   = 'A';       // finito di leggere i sottoconti, oppure
          tot_saldo += _saldo;    // quando ho raggiunto un massimo di 99
          _totale_saldo += _saldo;
        }                         // righe di movimento, genero un' altra    
        else                      // riga con importo di sezione opposta   
         if (sezione == 'A')      // alla somma, mandando a zero   
         {                        // il saldo di quel movimento.
           sez_rmov   = 'D';
           tot_saldo -= _saldo;
           _totale_saldo -= _saldo; 
         }
        
        if (!saldi.eof())
        {
          TRectype& rmov = _pn->cg(j);
          
          rmov.zero();  
          rmov.put(RMV_ANNOES,     _annoesch);  //Compilo una riga di movimento
          rmov.put(RMV_DATAREG,    _dataregch); //per ogni sottoconto che leggo
          rmov.put(RMV_GRUPPO,     g);          //sui saldi. Siccome queste
          rmov.put(RMV_CONTO,      c);          //righe servono per mandare a 0
          rmov.put(RMV_SOTTOCONTO, s);          //il saldo dei movimenti, la
          rmov.put(RMV_SEZIONE,    sez_rmov);   //sezione sara' opposta a 
          rmov.put(RMV_IMPORTO,    _saldo);     //quella letta sui saldi.
          rmov.put(RMV_NUMREG,     _numreg);
          rmov.put(RMV_NUMRIG,     numrig);
          rmov.put(RMV_TIPOC,      tmcf);
          _tcproper.put(rmov, TRUE);            // Contropartita
          
          TBill tc(g,c,s); 
          _sld->aggiorna(tc,TImporto(sez_rmov,_saldo));    //l'oggetto TSaldo_agg
          j++;
        }
        if (saldi.eof()) break;
      }                       //for saldi
      if (j >= 1)
      {
        registra_pn();
        j = 0;
      }
    }                        // if (indbil == 4)                   
  }                          // for pcon
}

void TApertura_chiusura::chiusura_conto_economico()
{
  _capitale_netto = _totale_saldo; //Mi serve per fare la riapertura del capitale netto

  if (_totale_saldo.is_zero())
    return;
  
  if (_totale_saldo > ZERO)
  {
    int j;

    //Compilo la testata per perdite di es. c.economico a Profitti e Perdite
    //Chiusura conto economico
    
    j = 0;
    compila_testata(_annoesch,_dataregch,_codcausch,_datacompch);  //Reg. 3 Chiusura Conto Economico  

    TRectype& rmov1 = _pn->cg(j);
    long numrig = 1;
    rmov_proper(_annoesch,numrig,_dataregch,rmov1,_tcproper,_totale_saldo,TRUE);
    _tcperde.put(rmov1, TRUE);            // Contropartita

    numrig++;
    j++;
    TRectype& rmov2 = _pn->cg(j);
    rmov_proper(_annoesch,numrig,_dataregch,rmov2,_tcperde,_totale_saldo,FALSE);
    _tcproper.put(rmov2, TRUE);            // Contropartita
    
    registra_pn();

    //Compilo la testata per perdite di es. c.patrimon. a Perdita di es. c. econom.
    //Chiusura capitale netto

    j = 0;
    compila_testata(_annoesch,_dataregch,_codcausch,_datacompch);  //Reg. 4 Chiusura Capitale netto
    
    TRectype& rmov3 = _pn->cg(j);
    numrig = 1;
    rmov_proper(_annoesch,numrig,_dataregch,rmov3,_tcperde,_totale_saldo,TRUE);
    _tcperdp.put(rmov3, TRUE);            // Contropartita

    numrig++;
    j++;
    TRectype& rmov4 = _pn->cg(j);
    rmov_proper(_annoesch,numrig,_dataregch,rmov4,_tcperdp,_totale_saldo,FALSE);
    _tcperde.put(rmov4, TRUE);            // Contropartita

    registra_pn();
  }
  else
  {
    int j;

    //Compilo la testata per Profitti e perdite a Utile di es. c.economico
    //Chiusura conto economico

    j = 0;
    compila_testata(_annoesch,_dataregch,_codcausch,_datacompch);    //Reg. 3 Chiusura Conto Economico

    TRectype& rmov1 = _pn->cg(j);
    long numrig = 1;
    rmov_proper(_annoesch,numrig,_dataregch,rmov1,_tcutile,_totale_saldo,FALSE);
    _tcproper.put(rmov1, TRUE);            // Contropartita

    numrig++;
    j++;
    TRectype& rmov2 = _pn->cg(j);
    rmov_proper(_annoesch,numrig,_dataregch,rmov2,_tcproper,_totale_saldo,TRUE);
    _tcutile.put(rmov2, TRUE);            // Contropartita

    registra_pn();
    
    //Compilo la testata per Utile di es. c.economico a Utile di es. c.patrimoniale
    //Chiusura capitale netto

    j = 0;
    compila_testata(_annoesch,_dataregch,_codcausch,_datacompch);   //Reg. 4 Chiusura Capitale netto
    
    TRectype& rmov3 = _pn->cg(j);
    numrig = 1;
    rmov_proper(_annoesch,numrig,_dataregch,rmov3,_tcutilp,_totale_saldo,FALSE);
    _tcutile.put(rmov3, TRUE);            // Contropartita
    
    numrig++;
    j++;
    TRectype& rmov4 = _pn->cg(j);
    rmov_proper(_annoesch,numrig,_dataregch,rmov4,_tcutile,_totale_saldo,TRUE);
    _tcutilp.put(rmov4, TRUE);            // Contropartita

    registra_pn();
  }
}

void TApertura_chiusura::chiudi_attivita()
{     
  bool      compila_mov = TRUE;
  long      s;
  char      sez_rmov = ' ', sezione = ' ';
  real      tot_saldo;
  long      numrig   = 0;
  TSaldo&   sale     = *_sale;
  int       j        = 0; 
	TLocalisamfile saldi(LF_SALDI);
    
  tot_saldo = ZERO;

  TRecnotype items_pcon  = _cur->items();
  
  for (int i = 0; i < items_pcon; i++, ++(*_cur))
  {
    int  indbil  = _cur->curr().get_int(PCN_INDBIL);
    int  g       = _cur->curr().get_int(PCN_GRUPPO);
    int  c       = _cur->curr().get_int(PCN_CONTO);
    TString tmcf = _cur->curr().get    (PCN_TMCF);
    
    _prog->addstatus(1);
         
    if (indbil == 1)
    {
      compila_mov = TRUE;
      
      saldi.setkey(1);
			saldi.zero();
      saldi.put(SLD_ANNOES, _annoesch);
      saldi.put(SLD_GRUPPO, g);
      saldi.put(SLD_CONTO,  c);
      saldi.put(SLD_FLSCA,  FALSE);      
      
      const TRectype rec(saldi.curr());      

      j      = 0; 
      numrig = 0;
      
      for (int err = saldi.read(_isgteq); ; saldi.next())
      {
        if (saldi.eof() || err != NOERR || (saldi.curr() != rec)) 
        {
          // Aggiungo un ulteriore riga di movimento contenente la somma
          // di tutti i saldi aventi lo stesso conto, indicandola
          // con una sezione opposta al risultato (della somma).
          
          if (j >= 1)
          {
            numrig++;
            if (tot_saldo != ZERO)
              rmov_proper(_annoesch,numrig,_dataregch,_pn->cg(j),_tcbilch,tot_saldo,FALSE); //Chiusura
            
            tot_saldo = ZERO;
          }
          break;
        }

        if (compila_mov)
        {
          compila_testata(_annoesch,_dataregch,_codcausch,_datacompch); //Reg. 5 Chiusura Attivita'
          compila_mov = FALSE;
        }

        s  = saldi.get_long(SLD_SOTTOCONTO);
        sale.ultima_immissione_bilancio(_annoesch,g,c,s,indbil, 1);
        _saldo  = sale.saldo();
        const int dbkey = saldi.getkey();
        saldi.setkey(1);
        
        if (_saldo == ZERO) continue;       // *** TBC qui fa ciclo infinito
        
        numrig++;
        
        if (j >= MAX || saldi.eof())
        {
          // Aggiungo un ulteriore riga di movimento contenente la somma
          // di tutti i saldi aventi lo stesso sottoconto, indicandola
          // con una sezione opposta al risultato (della somma).

          //      numrig++;
          if (tot_saldo != ZERO)
            rmov_proper (_annoesch,numrig,_dataregch,_pn->cg(j),_tcbilch,tot_saldo,FALSE); //Chiusura  
          registra_pn();

          j      = 0;
          numrig = 1;      
          compila_testata(_annoesch,_dataregch,_codcausch,_datacompch); //Reg. 5 Chiusura Attivita'
          compila_mov = FALSE;
          tot_saldo = ZERO;
        }

        if (_saldo >= ZERO)
          sezione = 'D';
        else
        {
          sezione = 'A';
          _saldo = -_saldo;
        }

        if (sezione == 'D')       // ---> Tengo una variabile in cui salvo gli
        {                         // importi trovati sui saldi. Quando ho
          sez_rmov   = 'A';       // finito di leggere i sottoconti, oppure
          tot_saldo += _saldo;    // quando ho raggiunto un massimo di 99
          _totale_saldo += _saldo;
        }                         // righe di movimento, genero un' altra    
        else                      // riga con importo di sezione opposta   
          if (sezione == 'A')     // alla somma, mandando a zero   
          {                       // il saldo di quel movimento.
            sez_rmov   = 'D';
            tot_saldo -= _saldo;
            _totale_saldo -= _saldo; 
          }
  
        if (!saldi.eof())
        {
          TRectype& rmov = _pn->cg(j);
          
          rmov.zero();  
          rmov.put(RMV_ANNOES,     _annoesch);  //Compilo una riga di movimento
          rmov.put(RMV_DATAREG,    _dataregch); //per ogni sottoconto che leggo
          rmov.put(RMV_GRUPPO,     g);          //sui saldi. Siccome queste
          rmov.put(RMV_CONTO,      c);          //righe servono per mandare a 0
          rmov.put(RMV_SOTTOCONTO, s);          //il saldo dei movimenti, la
          rmov.put(RMV_SEZIONE,    sez_rmov);   //sezione sara' opposta a 
          rmov.put(RMV_IMPORTO,    _saldo);     //quella letta sui saldi.
          rmov.put(RMV_NUMREG,     _numreg);
          rmov.put(RMV_NUMRIG,     numrig);
          rmov.put(RMV_TIPOC,      tmcf);
          _tcbilch.put(rmov, TRUE);             // Contropartita
          
          TBill tc(g,c,s); 
          _sld->aggiorna(tc,TImporto(sez_rmov,_saldo));    //l'oggetto TSaldo_agg

          j++;
        }
        if (saldi.eof()) break;
      }                       //for saldi
      if (j >= 1)
      {
        registra_pn();
        j = 0;
      }
    }                        // if (indbil == 1)                   
  }                          // for pcon
}

void TApertura_chiusura::chiudi_passivita()
{     
  bool      compila_mov = TRUE;
  long      s;
  char      sez_rmov = ' ', sezione = ' ';
  real      tot_saldo;
  long      numrig   = 0;
  TSaldo&   sale     = *_sale;
  int       j        = 0;
	TLocalisamfile saldi(LF_SALDI);
  
  tot_saldo = ZERO;

  TRecnotype items_pcon  = _cur->items();
  
  for (int i = 0; i < items_pcon; i++, ++(*_cur))
  {
    int     indbil = _cur->curr().get_int(PCN_INDBIL);
    int     g      = _cur->curr().get_int(PCN_GRUPPO);
    int     c      = _cur->curr().get_int(PCN_CONTO);
    TString tmcf   = _cur->curr().get    (PCN_TMCF);
    
    _prog->addstatus(1);
    
    if (indbil == 2)
    {
      compila_mov = TRUE;
      
      saldi.setkey(1);
      saldi.zero();
      saldi.put(SLD_ANNOES, _annoesch);
      saldi.put(SLD_GRUPPO, g);
      saldi.put(SLD_CONTO,  c);
      saldi.put(SLD_FLSCA,  FALSE);      
      
      const TRectype rec (saldi.curr());

      j      = 0; 
      numrig = 0;
      
      for (saldi.read(); ; saldi.next())
      {
        if ((saldi.curr() != rec) || saldi.eof()) 
        {
          // Aggiungo un ulteriore riga di movimento contenente la somma
          // di tutti i saldi aventi lo stesso conto, indicandola
          // con una sezione opposta al risultato (della somma).
          
          if (j >= 1)
          {
            numrig++;
            if (tot_saldo != ZERO)
              rmov_proper(_annoesch,numrig,_dataregch,_pn->cg(j),_tcbilch,tot_saldo,FALSE); //Chiusura
            
            tot_saldo = ZERO;
          }
          break;
        }
      
        if (compila_mov)
        {
          compila_testata(_annoesch,_dataregch,_codcausch,_datacompch); //Reg. 6 Chiusura Passivita'
          compila_mov = FALSE;
        }
      
        //numrig++;
        s               = saldi.get_long(SLD_SOTTOCONTO);
        //sale.calcola_ultima_immissione(_annoesch,0,g,c,s,indbil);
        sale.ultima_immissione_bilancio(_annoesch,g,c,s,indbil, 1);
        _saldo          = sale.saldo();
        
        if (_saldo.is_zero()) continue;
        
        numrig++;
        
        if (j >= MAX || saldi.eof())
        {
          // Aggiungo un ulteriore riga di movimento contenente la somma
          // di tutti i saldi aventi lo stesso sottoconto, indicandola
          // con una sezione opposta al risultato (della somma).

          //      numrig++;
          if (tot_saldo != ZERO)
            rmov_proper (_annoesch,numrig,_dataregch,_pn->cg(j),_tcbilch,tot_saldo,FALSE); //Chiusura  
          registra_pn();
  
          j      = 0;
          numrig = 1;      
          compila_testata(_annoesch,_dataregch,_codcausch,_datacompch); //Reg. 6 Chiusura Passivita'         
          compila_mov = FALSE;
          tot_saldo = ZERO;
        }

        if (_saldo >= ZERO)
          sezione = 'D';
        else
        {
          sezione = 'A';
          _saldo = -_saldo;
        }

        if (sezione == 'D')       // ---> Tengo una variabile in cui salvo gli
        {                         // importi trovati sui saldi. Quando ho
          sez_rmov   = 'A';       // finito di leggere i sottoconti, oppure
          tot_saldo += _saldo;    // quando ho raggiunto un massimo di 99
          _totale_saldo += _saldo;
        }                         // righe di movimento, genero un' altra    
        else                      // riga con importo di sezione opposta alla somma, mandando a zero   
        {                         // il saldo di quel movimento.
          sez_rmov   = 'D';
          tot_saldo -= _saldo;
          _totale_saldo -= _saldo; 
        }
        
        if (!saldi.eof())
        {
          TRectype& rmov = _pn->cg(j);
          
          rmov.zero();  
          rmov.put(RMV_ANNOES,     _annoesch); //Compilo una riga di movimento
          rmov.put(RMV_DATAREG,    _dataregch);  //per ogni sottoconto che leggo
          rmov.put(RMV_GRUPPO,     g);        //sui saldi. Siccome queste
          rmov.put(RMV_CONTO,      c);        //righe servono per mandare a 0
          rmov.put(RMV_SOTTOCONTO, s);        //il saldo dei movimenti, la
          rmov.put(RMV_SEZIONE,    sez_rmov); //sezione sara' opposta a 
          rmov.put(RMV_IMPORTO,    _saldo);    //quella letta sui saldi.
          rmov.put(RMV_NUMREG,     _numreg);
          rmov.put(RMV_NUMRIG,     numrig);
          rmov.put(RMV_TIPOC,      tmcf);
          _tcbilch.put(rmov, TRUE);            // Contropartita
          
          TBill tc(g,c,s); 
          _sld->aggiorna(tc,TImporto(sez_rmov,_saldo));    //l'oggetto TSaldo_agg

          j++;
        }
        if (saldi.eof()) break;
      }                       //for saldi
      if (j >= 1)
      {
        registra_pn();
        j = 0;
      }
    }                        // if (indbil == 2)                   
  }                          // for pcon                
}

void TApertura_chiusura::chiudi_conti_ordine()
{     
  bool      compila_mov = TRUE;
  long      s;
  char      sez_rmov = ' ', sezione = ' ';
  real      tot_saldo;
  long      numrig   = 0;
  TSaldo&   sale     = *_sale;
  int       j        = 0; 
	TLocalisamfile saldi(LF_SALDI);
    
  tot_saldo = ZERO;

  TRecnotype items_pcon  = _cur->items();
  
  for (int i = 0; i < items_pcon; i++, ++(*_cur))
  {
    int  indbil  = _cur->curr().get_int(PCN_INDBIL);
    int  g       = _cur->curr().get_int(PCN_GRUPPO);
    int  c       = _cur->curr().get_int(PCN_CONTO);
    TString tmcf = _cur->curr().get    (PCN_TMCF);
    
    _prog->addstatus(1);
         
    if (indbil == 5)
    {
      compila_mov = TRUE;
      
      saldi.setkey(1);
      saldi.zero();
      saldi.put(SLD_ANNOES, _annoesch);
      saldi.put(SLD_GRUPPO, g);
      saldi.put(SLD_CONTO,  c);
      saldi.put(SLD_FLSCA,  FALSE);      
      
      const TRectype rec(saldi.curr());

      j      = 0; 
      numrig = 0;
      
      for (saldi.read(_isgteq); ; saldi.next())
      {
        if (saldi.eof() || (saldi.curr() != rec)) 
        {
          // Aggiungo un ulteriore riga di movimento contenente la somma
          // di tutti i saldi aventi lo stesso conto, indicandola
          // con una sezione opposta al risultato (della somma).
          
          if (j >= 1)
          {
            numrig++;
            if (tot_saldo != ZERO)
              rmov_proper(_annoesch,numrig,_dataregch,_pn->cg(j),_tcbilch,tot_saldo,FALSE); //Chiusura
            
            tot_saldo = ZERO;
          }
          break;
        }

        if (compila_mov)
        {
          compila_testata(_annoesch,_dataregch,_codcausch,_datacompch); 
          compila_mov = FALSE;
        }

        s               = saldi.get_long(SLD_SOTTOCONTO);
        sale.ultima_immissione_bilancio(_annoesch,g,c,s,indbil, 1);
        _saldo          = sale.saldo();
        const int dbkey = saldi.getkey();
        saldi.setkey(1);
        
        if (_saldo == ZERO) continue;
        
        numrig++;
        
        if (j >= MAX || saldi.eof())
        {
          // Aggiungo un ulteriore riga di movimento contenente la somma
          // di tutti i saldi aventi lo stesso sottoconto, indicandola
          // con una sezione opposta al risultato (della somma).

          if (tot_saldo != ZERO)
            rmov_proper (_annoesch,numrig,_dataregch,_pn->cg(j),_tcbilch,tot_saldo,FALSE); //Chiusura  
          registra_pn();
  
          j      = 0;
          numrig = 1;      
          compila_testata(_annoesch,_dataregch,_codcausch,_datacompch); //Reg. 5 Chiusura Attivita'
          compila_mov = FALSE;
          tot_saldo = ZERO;
        }

        if (_saldo >= ZERO)
          sezione = 'D';
        else
        {
          sezione = 'A';
          _saldo = -_saldo;
        }

        if (sezione == 'D')       // ---> Tengo una variabile in cui salvo gli
        {                         // importi trovati sui saldi. Quando ho
          sez_rmov   = 'A';       // finito di leggere i sottoconti, oppure
          tot_saldo += _saldo;    // quando ho raggiunto un massimo di 99
          _totale_saldo += _saldo;
        }                         // righe di movimento, genero un' altra    
        else                      // riga con importo di sezione opposta alla somma, mandando a zero   
        {                       // il saldo di quel movimento.
          sez_rmov   = 'D';
          tot_saldo -= _saldo;
          _totale_saldo -= _saldo; 
        }
  
        if (!saldi.eof())
        {
          TRectype& rmov = _pn->cg(j);
          
          rmov.zero();  
          rmov.put(RMV_ANNOES,     _annoesch);  //Compilo una riga di movimento
          rmov.put(RMV_DATAREG,    _dataregch); //per ogni sottoconto che leggo
          rmov.put(RMV_GRUPPO,     g);          //sui saldi. Siccome queste
          rmov.put(RMV_CONTO,      c);          //righe servono per mandare a 0
          rmov.put(RMV_SOTTOCONTO, s);          //il saldo dei movimenti, la
          rmov.put(RMV_SEZIONE,    sez_rmov);   //sezione sara' opposta a 
          rmov.put(RMV_IMPORTO,    _saldo);     //quella letta sui saldi.
          rmov.put(RMV_NUMREG,     _numreg);
          rmov.put(RMV_NUMRIG,     numrig);
          rmov.put(RMV_TIPOC,      tmcf);
          _tcbilch.put(rmov, TRUE);            // Contropartita
          
          TBill tc(g,c,s); 
          _sld->aggiorna(tc,TImporto(sez_rmov,_saldo));    //l'oggetto TSaldo_agg

          j++;
        }
        if (saldi.eof()) break;
      }                       //for saldi
      if (j >= 1)
      {
        registra_pn();
        j = 0;
      }
    }                        // if (indbil == 1)                   
  }                          // for pcon
}

void TApertura_chiusura::chiusura_conto_patrimoniale()
{
  int  j;
  long numrig;
            
  if (_totale_saldo > ZERO)
  {
    //Compilo la testata per Bilancio di chiusura a Perdita di es. c. patrimoniale
    //Chiusura conto patrimoniale

    j = 0;
    compila_testata(_annoesch,_dataregch,_codcausch,_datacompch);   //Reg. 7 Chiusura Conto Patrimoniale
    
    TRectype& rmov1 = _pn->cg(j);
    numrig = 1;
    rmov_proper(_annoesch,numrig,_dataregch,rmov1,_tcutilp,_totale_saldo,FALSE);
    _tcbilch.put(rmov1, TRUE);            // Contropartita

    numrig++;
    j++;
    TRectype& rmov2 = _pn->cg(j);
    rmov_proper(_annoesch,numrig,_dataregch,rmov2,_tcbilch,_totale_saldo,TRUE);
    _tcutilp.put(rmov2, TRUE);            // Contropartita

    registra_pn();
  } 
  else
  if (_totale_saldo < ZERO)
  {
    //Compilo la testata per Utile di es. c.patrimon. a Bilancio di chiusura
    //Chiusura conto patrimoniale

    j = 0;
    compila_testata(_annoesch,_dataregch,_codcausch,_datacompch);    //Reg. 7 Chiusura Conto Patrimoniale
    
    TRectype& rmov1 = _pn->cg(j);
    numrig = 1;
    rmov_proper(_annoesch,numrig,_dataregch,rmov1,_tcbilch,_totale_saldo,TRUE);
    _tcperdp.put(rmov1, TRUE);            // Contropartita

    numrig++;
    j++;
    TRectype& rmov2 = _pn->cg(j);
    rmov_proper(_annoesch,numrig,_dataregch,rmov2,_tcperdp,_totale_saldo,FALSE);
    _tcbilch.put(rmov2, TRUE);            // Contropartita

    registra_pn();
  }
}

void TApertura_chiusura::apri_attivita()
{       
  bool      compila_mov = TRUE;
  long      s;
  char      sezione = ' ';
  real      tot_saldo;
  long      numrig   = 0;
  TSaldo&   sale     = *_sale;
  int       j        = 0; 
	TLocalisamfile saldi(LF_SALDI);
      
  tot_saldo = ZERO;

  TRecnotype items_pcon  = _cur->items();
  
  for (int i = 0; i < items_pcon; i++, ++(*_cur))
  {
    int  indbil  = _cur->curr().get_int(PCN_INDBIL);
    int  g       = _cur->curr().get_int(PCN_GRUPPO);
    int  c       = _cur->curr().get_int(PCN_CONTO);
    TString tmcf = _cur->curr().get    (PCN_TMCF);
    
    _prog->addstatus(1);
         
    if (indbil == 1)
    {
      compila_mov = TRUE;
      
      saldi.setkey(1);
      saldi.zero();
      saldi.put(SLD_ANNOES, _annoesch);
      saldi.put(SLD_GRUPPO, g);
      saldi.put(SLD_CONTO,  c);
      saldi.put(SLD_FLSCA,  FALSE);      
      
      const TRectype rec (saldi.curr());

      j      = 0;
      numrig = 0;       
      
      for (saldi.read(); ; saldi.next())
      {
        if (saldi.eof() || (saldi.curr() != rec)) 
        {
          // Aggiungo un ulteriore riga di movimento contenente la somma
          // di tutti i saldi aventi lo stesso conto, indicandola
          // con una sezione opposta al risultato (della somma).
          
          if (j >= 1)
          {
            numrig++;
            if (tot_saldo != ZERO)
              rmov_proper(_annoesap,numrig,_dataregap,_pn->cg(j),_tcbilap,tot_saldo,TRUE); //Apertura
            
            tot_saldo = ZERO;
          }
          break;
        }

        if (compila_mov)
        {
          compila_testata(_annoesap,_dataregap,_codcausap,_dataregap); //Reg. 8 Apertura Attivita'
          compila_mov = FALSE;
        }

        //numrig++;
        s               = saldi.get_long(SLD_SOTTOCONTO);
        sale.ultima_immissione_bilancio(_annoesch,g,c,s,indbil, 1);
        _saldo          = sale.saldo();

        if (_saldo == ZERO) continue;
        
        numrig++;
        
        if (j >= MAX || saldi.eof())
        {
          // Aggiungo un ulteriore riga di movimento contenente la somma
          // di tutti i saldi aventi lo stesso sottoconto, indicandola
          // con una sezione opposta al risultato (della somma).
          
          if (tot_saldo != ZERO)
            rmov_proper (_annoesap,numrig,_dataregap,_pn->cg(j),_tcbilap,tot_saldo,TRUE); //Chiusura  
          registra_pn();
  
          j      = 0;
          numrig = 1;      
          compila_testata(_annoesap,_dataregap,_codcausap,_dataregap); //Reg. 8 Apertura Attivita'
          compila_mov = FALSE;
          tot_saldo = ZERO;
        }

        if (_saldo > ZERO)
          sezione = 'D';
        else
          if (_saldo < ZERO)
          {
            sezione = 'A';
            _saldo = -_saldo;
          }

        if (sezione == 'D')       // ---> Tengo una variabile in cui salvo gli
        {                         // importi trovati sui saldi. Quando ho
          tot_saldo += _saldo;    // quando ho raggiunto un massimo di 99
          _totale_saldo += _saldo;
        }                         // righe di movimento, genero un' altra    
        else                      // riga con importo di sezione opposta   
          if (sezione == 'A')     // alla somma, mandando a zero   
          {                       // il saldo di quel movimento.
            tot_saldo -= _saldo;
            _totale_saldo -= _saldo; 
          }
  
        if (!saldi.eof())
        {
          TRectype& rmov = _pn->cg(j);
          
          rmov.zero();  
          rmov.put(RMV_ANNOES,     _annoesap);  //Compilo una riga di movimento
          rmov.put(RMV_DATAREG,    _dataregap); //per ogni sottoconto che leggo
          rmov.put(RMV_GRUPPO,     g);          //sui saldi. Siccome queste
          rmov.put(RMV_CONTO,      c);          //righe servono per mandare a 0
          rmov.put(RMV_SOTTOCONTO, s);          //il saldo dei movimenti, la
          rmov.put(RMV_SEZIONE,    sezione);    //sezione sara' opposta a 
          rmov.put(RMV_IMPORTO,    _saldo);     //quella letta sui saldi.
          rmov.put(RMV_NUMREG,     _numreg);
          rmov.put(RMV_NUMRIG,     numrig);
          rmov.put(RMV_TIPOC,      tmcf);
          _tcbilap.put(rmov, TRUE);            // Contropartita

          
          TBill tc(g,c,s); 
          _sld->aggiorna(tc,TImporto(sezione,_saldo));    //l'oggetto TSaldo_agg

          j++;
        }
        if (saldi.eof()) break;
      }                       //for saldi
      if (j >= 1)
      {
        registra_pn();
        j = 0;
      }
    }                        // if (indbil == 1)                   
  }                          // for pcon
}

void TApertura_chiusura::apri_passivita()
{       
  bool      compila_mov = TRUE;
  long      s;
  char      sezione = ' ';
  real      tot_saldo;
  long      numrig   = 0;
  TSaldo&   sale     = *_sale;
  int       j        = 0;
	TLocalisamfile saldi(LF_SALDI);
  
  tot_saldo = ZERO;

  TRecnotype items_pcon  = _cur->items();
  
  for (int i = 0; i < items_pcon; i++, ++(*_cur))
  {
    int     indbil = _cur->curr().get_int(PCN_INDBIL);
    int     g      = _cur->curr().get_int(PCN_GRUPPO);
    int     c      = _cur->curr().get_int(PCN_CONTO);
    TString tmcf   = _cur->curr().get    (PCN_TMCF);
    
    _prog->addstatus(1);
    
    if (indbil == 2)
    {
      compila_mov = TRUE;
      
      saldi.setkey(1);
      saldi.zero();
      saldi.put(SLD_ANNOES, _annoesch);
      saldi.put(SLD_GRUPPO, g);
      saldi.put(SLD_CONTO,  c);
      saldi.put(SLD_FLSCA,  FALSE);      
      
      const TRectype rec(saldi.curr());

      j      = 0;
      numrig = 0;
      
      for (saldi.read(); ; saldi.next())
      {
        if (saldi.eof() || (saldi.curr() != rec)) 
        {
          // Aggiungo un ulteriore riga di movimento contenente la somma
          // di tutti i saldi aventi lo stesso conto, indicandola
          // con una sezione opposta al risultato (della somma).
          
          if (j >= 1)
          {
            numrig++;
            if (tot_saldo != ZERO)
              rmov_proper(_annoesap,numrig,_dataregap,_pn->cg(j),_tcbilap,tot_saldo,TRUE); //Apertura
            
            tot_saldo = ZERO;
          }
          break;
        }
      
        if (compila_mov)
        {
          compila_testata(_annoesap,_dataregap,_codcausap,_dataregap); //Reg. 9 Apertura Passivita'
          compila_mov = FALSE;
        }
      
        //numrig++;
        s               = saldi.get_long(SLD_SOTTOCONTO);
        sale.ultima_immissione_bilancio(_annoesch,g,c,s,indbil, 1);
        _saldo          = sale.saldo();

        if (_saldo.is_zero()) continue;
        
        numrig++;
        
        if (j >= MAX || saldi.eof())
        {
          // Aggiungo un ulteriore riga di movimento contenente la somma
          // di tutti i saldi aventi lo stesso sottoconto, indicandola
          // con una sezione opposta al risultato (della somma).
          
          if (tot_saldo != ZERO)
            rmov_proper (_annoesap,numrig,_dataregap,_pn->cg(j),_tcbilap,tot_saldo,TRUE); //Apertura  
          registra_pn();
  
          j      = 0;
          numrig = 1;
          compila_testata(_annoesap,_dataregap,_codcausap,_dataregap); //Reg. 9 Apertura Passivita'          
          compila_mov = FALSE;
          tot_saldo = ZERO;
        }

        if (_saldo > ZERO)
          sezione = 'D';
        else
          if (_saldo < ZERO)
          {
            sezione = 'A';
            _saldo = -_saldo;
          }

        if (sezione == 'D')        // ---> Tengo una variabile in cui salvo gli
        {                          // importi trovati sui saldi. Quando ho 
          tot_saldo += _saldo;     // finito di leggere i sottoconti, oppure
          _totale_saldo += _saldo; // quando ho raggiunto un massimo di 99
        }                          // righe di movimento, genero un' altra    
        else                       // riga con importo di sezione opposta   
          if (sezione == 'A')      // alla somma, mandando a zero   
          {                        // il saldo di quel movimento.
            tot_saldo -= _saldo;
            _totale_saldo -= _saldo; 
          }
        
        if (!saldi.eof())
        {
          TRectype& rmov = _pn->cg(j);
          
          rmov.zero();  
          rmov.put(RMV_ANNOES,     _annoesap);  //Compilo una riga di movimento
          rmov.put(RMV_DATAREG,    _dataregap); //per ogni sottoconto che leggo
          rmov.put(RMV_GRUPPO,     g);          //sui saldi. Siccome queste
          rmov.put(RMV_CONTO,      c);          //righe servono per mandare a 0
          rmov.put(RMV_SOTTOCONTO, s);          //il saldo dei movimenti, la
          rmov.put(RMV_SEZIONE,    sezione);    //sezione sara' opposta a 
          rmov.put(RMV_IMPORTO,    _saldo);     //quella letta sui saldi.
          rmov.put(RMV_NUMREG,     _numreg);
          rmov.put(RMV_NUMRIG,     numrig);
          rmov.put(RMV_TIPOC,      tmcf);
          _tcbilap.put(rmov, TRUE);            // Contropartita
          
          TBill tc(g,c,s); 
          _sld->aggiorna(tc,TImporto(sezione,_saldo));    //l'oggetto TSaldo_agg

          j++;
        }
        if (saldi.eof()) break;
      }                       //for saldi
      if (j >= 1)
      {
        registra_pn();
        j = 0;
      }
    }                        // if (indbil == 2)                   
  }                          // for pcon
}

void TApertura_chiusura::apri_conti_ordine()
{       
  bool      compila_mov = TRUE;
  long      s;
  char      sezione = ' ';
  real      tot_saldo;
  long      numrig   = 0;
  TSaldo&   sale     = *_sale;
  int       j        = 0; 
	TLocalisamfile saldi(LF_SALDI);
      
  tot_saldo = ZERO;

  TRecnotype items_pcon  = _cur->items();
  
  for (int i = 0; i < items_pcon; i++, ++(*_cur))
  {
    int  indbil  = _cur->curr().get_int(PCN_INDBIL);
    int  g       = _cur->curr().get_int(PCN_GRUPPO);
    int  c       = _cur->curr().get_int(PCN_CONTO);
    TString tmcf = _cur->curr().get    (PCN_TMCF);
    
    _prog->addstatus(1);
         
    if (indbil == 5)
    {
      compila_mov = TRUE;
      
      saldi.setkey(1);
      saldi.zero();
      saldi.put(SLD_ANNOES, _annoesch);
      saldi.put(SLD_GRUPPO, g);
      saldi.put(SLD_CONTO,  c);
      saldi.put(SLD_FLSCA,  FALSE);      
      
      const TRectype rec(saldi.curr());

      j      = 0;
      numrig = 0;       
      
      for (saldi.read(); ; saldi.next())
      {
        if (saldi.eof() || (saldi.curr() != rec)) 
        {
          // Aggiungo un ulteriore riga di movimento contenente la somma
          // di tutti i saldi aventi lo stesso conto, indicandola
          // con una sezione opposta al risultato (della somma).
          
          if (j >= 1)
          {
            numrig++;
            if (tot_saldo != ZERO)
              rmov_proper(_annoesap,numrig,_dataregap,_pn->cg(j),_tcbilap,tot_saldo,TRUE); //Apertura
            
            tot_saldo = ZERO;
          }
          break;
        }

        if (compila_mov)
        {
          compila_testata(_annoesap,_dataregap,_codcausap,_dataregap); //Reg. 8 Apertura Attivita'
          compila_mov = FALSE;
        }

        //numrig++;
        s               = saldi.get_long(SLD_SOTTOCONTO);
        sale.ultima_immissione_bilancio(_annoesch,g,c,s,indbil, 1);
        _saldo          = sale.saldo();

        if (_saldo == ZERO) continue;
        
        numrig++;
        
        if (j >= MAX || saldi.eof())
        {
          // Aggiungo un ulteriore riga di movimento contenente la somma
          // di tutti i saldi aventi lo stesso sottoconto, indicandola
          // con una sezione opposta al risultato (della somma).
          
          if (tot_saldo != ZERO)
            rmov_proper (_annoesap,numrig,_dataregap,_pn->cg(j),_tcbilap,tot_saldo,TRUE); //Chiusura  
          registra_pn();
  
          j      = 0;
          numrig = 1;      
          compila_testata(_annoesap,_dataregap,_codcausap,_dataregap); //Reg. 8 Apertura Attivita'
          compila_mov = FALSE;
          tot_saldo = ZERO;
        }

        if (_saldo > ZERO)
          sezione = 'D';
        else
          if (_saldo < ZERO)
          {
            sezione = 'A';
            _saldo = -_saldo;
          }

        if (sezione == 'D')       // ---> Tengo una variabile in cui salvo gli
        {                         // importi trovati sui saldi. Quando ho
          tot_saldo += _saldo;    // quando ho raggiunto un massimo di 99
          _totale_saldo += _saldo;
        }                         // righe di movimento, genero un' altra    
        else                      // riga con importo di sezione opposta   
          if (sezione == 'A')     // alla somma, mandando a zero   
          {                       // il saldo di quel movimento.
            tot_saldo -= _saldo;
            _totale_saldo -= _saldo; 
          }
  
        if (!saldi.eof())
        {
          TRectype& rmov = _pn->cg(j);
          
          rmov.zero();  
          rmov.put(RMV_ANNOES,     _annoesap);  //Compilo una riga di movimento
          rmov.put(RMV_DATAREG,    _dataregap); //per ogni sottoconto che leggo
          rmov.put(RMV_GRUPPO,     g);          //sui saldi. Siccome queste
          rmov.put(RMV_CONTO,      c);          //righe servono per mandare a 0
          rmov.put(RMV_SOTTOCONTO, s);          //il saldo dei movimenti, la
          rmov.put(RMV_SEZIONE,    sezione);    //sezione sara' opposta a 
          rmov.put(RMV_IMPORTO,    _saldo);     //quella letta sui saldi.
          rmov.put(RMV_NUMREG,     _numreg);
          rmov.put(RMV_NUMRIG,     numrig);
          rmov.put(RMV_TIPOC,      tmcf);
          _tcbilap.put(rmov, TRUE);            // Contropartita
          
          TBill tc(g,c,s); 
          _sld->aggiorna(tc,TImporto(sezione,_saldo));    //l'oggetto TSaldo_agg

          j++;
        }
        if (saldi.eof()) break;
      }                       //for saldi
      if (j >= 1)
      {
        registra_pn();
        j = 0;
      }
    }                        // if (indbil == 1)                   
  }                          // for pcon
}

void TApertura_chiusura::apertura_capitale_netto()
{ 
  int numrig;
  
  if (_capitale_netto > ZERO)
  {
    //Compilo la testata per Perdita es. c/to patrimoniale a Bilancio di apertura
    //Apertura capitale netto
    
    int j = 0;

    compila_testata(_annoesap,_dataregap,_codcausap,_dataregap);  //Reg. 10 Apertura Capitale netto
    
    TRectype& rmov1 = _pn->cg(j);
    numrig = 1;
    rmov_proper(_annoesap,numrig,_dataregap,rmov1,_tcbilap,_capitale_netto,TRUE);
    _tcperdp.put(rmov1, TRUE);            // Contropartita
    
    numrig++;
    j++;
    TRectype& rmov2 = _pn->cg(j);
    rmov_proper(_annoesap,numrig,_dataregap,rmov2,_tcperdp,_capitale_netto,FALSE);
    _tcbilap.put(rmov2, TRUE);            // Contropartita

    registra_pn();
  }
  else
    if (_capitale_netto < ZERO)
    {
      //Compilo la testata per Bilancio di apertura  a Utile es. c/to patrimoniale
      //Apertura capitale netto
      
      int j = 0;

      compila_testata(_annoesap,_dataregap,_codcausap,_dataregap);  //Reg. 10 Apertura Capitale netto
      
      TRectype& rmov1 = _pn->cg(j);
      numrig = 1;
      rmov_proper(_annoesap,numrig,_dataregap,rmov1,_tcbilap,_capitale_netto,TRUE);
      _tcutilp.put(rmov1, TRUE);            // Contropartita
      
      numrig++;
      j++;
      TRectype& rmov2 = _pn->cg(j);
      rmov_proper(_annoesap,numrig,_dataregap,rmov2,_tcutilp,_capitale_netto,FALSE);
      _tcbilap.put(rmov2, TRUE);            // Contropartita

      registra_pn();
    }
}

void TApertura_chiusura::main_loop()
{
  set(); 
}

int cg4600 (int argc, char* argv[])
{
  TApertura_chiusura main_app;
  main_app.run(argc, argv, TR("Apertura/Chiusura Conti"));
  return TRUE;
}