campo-sirio/ef/ef0500.cpp

#include <applicat.h>
#include <filetext.h>
#include <form.h>
#include <mask.h>
#include <os_dep.h>
#include <relation.h>
#include <printer.h>
#include <progind.h>

#include "ef0.h"
#include "ef0301.h"
#include "ef0500.h"

#include <clifo.h>
#include <comuni.h>

class TRiba_form;
class TDistinta_form;
class TRiba_file;
enum fo { kb360 = 1, kb720 = 2, kb1200 = 3, kb1440 = 4 };

#define RIBAFILENAME "ribael.dat"
///////////////////////////////////////////////////////////////////////
// Classe per l'emissione di effetti e distinte su carta o su floppy //
///////////////////////////////////////////////////////////////////////
class TEmissione: public TSkeleton_application
{
  fo _foutput;
  TMask* _msk;
  TRelation* _firmrel;
  TRelation* _rel;
  TCursor* _cur;
  TRiba_form* _formrb;
  TDistinta_form* _formdse;
  TRiba_file* _trasfile;
  int _base_page_no;
protected:
  virtual bool create(void);
  virtual void main_loop();
  virtual bool destroy(void) ;
  virtual void on_firm_change(void);
  void conferma(void);              
  void enable_dettaglio(TForm& form) const;
  virtual void print_rb(char tipost, int ndist, char tipodist, int ncopie, const bool is_vis);
  virtual void print_dse(char tipost, int ndist, char tipodist, int ncopie, const bool is_vis);
  virtual void print(void);
  void floppy(void);
  void save_data_emis(void);
  void header_rb(void);
  void footer_ef(void);
  void inizializza_cur(void);
  void inizializza_file(void);
  void record(THash_object& lavoro);
  bool ok_write(void);
  void aggiorna_rb(TCursor*);
  void aggiorna_dist(TCursor*);
  static bool annulla_handler(TMask_field& f, KEY k);
public:
  int base_no() { return _base_page_no;}
  const TMask& msk() const {return *_msk;}
  TEmissione() {};
  virtual ~TEmissione() {};
};

// restituisce un riferimento all' applicazione
inline TEmissione& app() { return (TEmissione&) main_app();}

/////////////////////////////////////////////////////////////
// Classe TRiba_form customizzata dalla Form per le Ri.Ba. //
/////////////////////////////////////////////////////////////
class TRiba_form: public TForm
{
protected:
  virtual bool validate(TForm_item &, TToken_string &);
public:
  TRiba_form(const char *);
  virtual ~TRiba_form(){};
};

///////////////////////////////////////////////////////////////////
// Classe TDistinta_form customizzata dalla Form per le Distinte //
///////////////////////////////////////////////////////////////////
class TDistinta_form: public TForm
{
  TRelation *_firmrel;
  TSorted_cursor *_cursor;// cursore che permette l'ordinamento degli effetti
protected:                // nella distinta per data scadenza o per dati fattura
  virtual bool validate(TForm_item &, TToken_string &);
public:
  void set_order(const char tipo);
  virtual TCursor* cursor() const { return (TCursor*)_cursor;}
  TDistinta_form(const char*, TRelation *);
  virtual ~TDistinta_form();
};

/////////////////////////////////////////////////////
// Classe TRiba_file customizzata dalla TFile_text //
/////////////////////////////////////////////////////
class TRiba_file: public TFile_text
{
  long _nditta;
  real _tot_importi;
protected:
  virtual void validate(TCursor& cur,TRecord_text &rec, TToken_string &val, TString& str);
public:
  TRiba_file(const TString& file_name, const TString& config_name):TFile_text(file_name, config_name){}
  virtual ~TRiba_file(){}
  void set_ditta(long nditta){_nditta = nditta;}
  const long ditta(void) const {return _nditta;}
  void set_tot_importi(real importo){_tot_importi = importo;}
  void add_tot_importi(real importo){_tot_importi += importo;}
  const real tot_importi(void) const {return _tot_importi;}
};

// creazione dell'applicazione
bool TEmissione::create()
{
  _formrb = NULL;
  _formdse = NULL;
  _msk = new TMask("ef0500a");
  _firmrel= new TRelation(LF_NDITTE);
  _firmrel->add(LF_ANAG, "TIPOA=TIPOA|CODANAGR=CODANAGR");
  _firmrel->add(LF_UNLOC,"CODDITTA=CODDITTA");
  _rel = new TRelation(LF_EFFETTI);
  _rel->add(LF_REFFETTI, "NPROGTR=NPROGTR");
  _rel->add(LF_CESS, "NPROGTR=NPROGTR");
  _rel->add(LF_CLIFO, "TIPOCF=TIPOCF|CODCF=CODCF");
  _rel->add("%BAN", "CODTAB[1,5]=CODABI", 1, 0, 401);
  _rel->add("%BAN", "CODTAB=CODABI+CODCAB", 1, 0, 402);
  _rel->add(LF_COMUNI, "STATO=STATOCF|COM=COMCF",1,LF_CLIFO);
  _cur = NULL;
  _msk->set(F_NOMEFILE,RIBAFILENAME);
//  _trasfile = new TRiba_file(RIBAFILENAME, "riba.ini");
//  _trasfile->set_ditta(get_firm());
  _msk->set_handler(DLG_CANCEL, annulla_handler);
  _trasfile = NULL;
  return TSkeleton_application::create();
}

// distruzione dell'applicazione
bool TEmissione::destroy()
{
  if (_formrb) delete _formrb;
  if (_formdse) delete _formdse;
  delete _msk;
  delete _firmrel;
  delete _rel;
  delete _cur;
  if (_trasfile)
    delete _trasfile;
  return TSkeleton_application::destroy();
}

// carica la ditta corrente
void TEmissione::on_firm_change()
{
  TRectype& firm = _firmrel->curr();
  firm.put("CODDITTA", get_firm());
  _firmrel->read();
}

// carica la maschera per emissione effetti e  distinte
void TEmissione::main_loop()
{ 
  // Preimposta gli eventuali valori specificati sulla riga di comando            
  if (argc() >= 4)    
  {
    TLocalisamfile eff(LF_EFFETTI);
    eff.setkey(4);
    eff.put(EFF_TIPODIST, argv(2));
    eff.put(EFF_NDIST, argv(3));
    eff.put(EFF_NRIGADIST, 1);
    if (eff.read() == NOERR)       
    {
      _msk->set(F_TIPODIST, eff.get(EFF_TIPODIST));
      _msk->set(F_TIPOCF, eff.get(EFF_TIPOCF));
      _msk->set(F_NUMBER, eff.get(EFF_NDIST));
    }
  }
  
  KEY key = K_ENTER;
  while (key != K_QUIT)
  {
    key = _msk->run();
    if (key == K_ENTER)
      conferma();
  }
}

// gestisce la scelta fra le due possibili emissioni
void TEmissione::conferma()
{
  const int tipoemis = _msk->get_int(F_TIPOEMIS);
  if (tipoemis == 1)
    floppy();
  else
    print();
}

// gestione emissione su floppy
void TEmissione::floppy()
{
  inizializza_cur();
   
  const long codabi = _cur->curr().get_long(EFF_CODABIP);
  const char tipocf = _cur->curr().get_char(EFF_TIPOCF);
  const char tipopag = _cur->curr().get_char(EFF_TIPOPAG);
  
  TFilename ribaini;
  
  ribaini.format("r%c%c%05ld.ini",tipocf, tipopag, codabi);// compongo il nome del tracciato
  if (!ribaini.exist())              // se non esiste
    ribaini.overwrite("00000", 3);   // Elimino codice banca
  if (!ribaini.exist())              // se non esiste
   ribaini = "riba.ini";             // utilizzo quello generico
             
  _trasfile = new TRiba_file(RIBAFILENAME, ribaini);
  _trasfile->set_ditta(get_firm());
  inizializza_file();
  
  long n_eff = _cur->items();
  bool condition = ok_write();
  
  if (!condition)
    error_box("Impossibile continuare dischetto pieno");
  else
  {
   TProgind pi(n_eff,"Emissione Ri.Ba. su floppy...",FALSE,TRUE);
             
   TAssoc_array& tracciati = _trasfile->tracciati();
   header_rb();//intestazione flusso effetti
   //scandisco tutti gli effetti della distinta selezionata
   for (*_cur = 0; _cur->pos() < n_eff; ++(*_cur))
   {
      pi.addstatus(1L);
      save_data_emis();
      THash_object* lavoro =  tracciati.get_hashobj();
      //scandisco tutti i record  di un effetto
      for (int i = 0; lavoro != NULL; i++)
      {
        record(*lavoro);//emetto il record
        lavoro =  tracciati.get_hashobj();
      }
   }
   footer_ef(); //chiusura flusso effetti
  }
  _trasfile->close();
  delete _trasfile;
  _trasfile = NULL;
}

// registro la data ed il numero di emissione dell'effetto corrente
void TEmissione::save_data_emis()
{
   const TDate data_emis = _msk->get_date(F_DATAEMIS);
   TLocalisamfile& effetti = _rel->lfile();
   TEffetto effetto = effetti.curr();
   long numero = effetto.numero();
   effetto.put(EFF_NUMEMISS, numero);
   effetto.put(EFF_DATAEMISS, data_emis);
   effetto.put(EFF_DATARIBA, data_emis);
   bool cond = TRUE;
   effetto.put(EFF_DISRIBAEST, cond);
   effetto.rewrite(effetti);
}

//emetto il record d'intestazione del flusso di effetti
void TEmissione::header_rb()
{
   TRecord_text rec;
   *_cur = 0;
   rec.set_type("RB");
   _trasfile->autoload(rec, *_cur);
   _trasfile->write(rec);
}

//emetto il record di chiusura del flusso di effetti
void TEmissione::footer_ef()
{
  TRecord_text rec;
  *_cur = 0;
  rec.set_type("EF");
  _trasfile->autoload(rec, *_cur);
  _trasfile->write(rec);
  _trasfile->write_file()->seekp(0, ios::end);
}

//inizializza il cursore per la gestione dei dati da caricare negli effetti
void TEmissione::inizializza_cur()
{
  const int ndist = _msk->get_int(F_NUMBER);
  const char tipodist = _msk->get(F_TIPODIST)[0];
  TRectype from(_rel->lfile().curr());
  from.zero();
  from.put(EFF_TIPODIST, tipodist);
  from.put(EFF_NDIST, ndist);
  _cur = new TCursor(_rel,"",4,&from,&from);
  _cur->freeze();
}

//inizializza il file di testo su cui emettere gli effetti
void TEmissione::inizializza_file()
{
   TFilename fileriba = _msk->get(F_UNITA);
   fileriba << ":\\" << _msk->get(F_NOMEFILE);
   _trasfile->open(fileriba,'w');
   _trasfile->set_tot_importi(0.0);
   _foutput = (fo)_msk->get_int(F_FOR_OUT);
}

//emetto un record del flusso di effetti
void TEmissione::record(THash_object& lavoro)
{
   TString chiave = lavoro.key();
    if (chiave !="EF" && chiave !="RB")
    {
         TTracciato_record&  oggetto = (TTracciato_record&)lavoro.obj();
         const TString& tipo = oggetto.type();
         TRecord_text rec(tipo);
          //carico il record da emettere
          _trasfile->autoload(rec, *_cur, &tipo);
          _trasfile->write(rec);//emetto i dati su file
    }
}

//controllo che ci sia spazio a sufficenza per emettere il flusso
//sull'unit<69> scelta dall'utente,ritorna TRUE se <20> possibile farlo
bool TEmissione::ok_write()
{
  long elem = _cur->items();
  int dim = _trasfile->recordsize();
  unsigned long nbyte = (elem*7+2)*dim;

  TString16 unita; unita << _msk->get(F_UNITA)[0] << ":\\";
  return os_test_disk_free_space(unita, nbyte);
}

// aggiorna numero e data di emissione ed il flag di stampa
// su tutti gli effetti nel cursore
void TEmissione::aggiorna_rb(TCursor* cur)
{
  TLocalisamfile &eff = cur->file(LF_EFFETTI);
  for (*cur = 0; cur->pos() < cur->items(); ++(*cur))
  {
     TEffetto effetto = eff.curr();
     long numero = effetto.numero();
     effetto.put(EFF_NUMEMISS, numero);
     TDate data = _msk->get_date(F_DATAEMIS);
     effetto.put(EFF_DATAEMISS, data);
     bool cond = TRUE;
     effetto.put(EFF_EFFSTAMP, cond);
     effetto.rewrite(eff);
  }
}

// aggiorna il flag di stampa della distinta
// su tutti gli effetti nel cursore
void TEmissione::aggiorna_dist(TCursor* cur)
{
  TLocalisamfile &eff = cur->file(LF_EFFETTI);
  for (*cur = 0; cur->pos() < cur->items(); ++(*cur))
  {
     TEffetto effetto = eff.curr();
     bool cond = TRUE;
     effetto.put(EFF_DISTSTAM, cond);
     effetto.rewrite(eff);
  }
}

// gestione emissione su moduli cartacei delle riba
void TEmissione::print_rb(char tipost, int ndist, char tipodist, int ncopie, const bool is_vis)
{
  TCursor* fcur = _formrb->cursor();
  TLocalisamfile &eff = fcur->file(LF_EFFETTI);
  
  TString filter;
  if (tipost == 'D' && !_msk->get_bool(F_RIST))  // se stampa definitiva effetti e se non deve ristampare le riba
    filter = "EFFSTAMP=\" \"";// setta il filtro del cursore per stampare solo gli effetti non ancora stampati

// setta la chiave 4 per il cursore per poter leggere tutti gli effetti della distinta
  fcur->setkey(4);
  if (ndist > 0)
  {
    TRectype darec(eff.curr());// fissa  i dati per la scelta degli ...
    darec.zero();// ... effetti nel primo e nell'ultimo record del cursore
    darec.put(EFF_TIPODIST, tipodist);
    darec.put(EFF_NDIST, ndist);
    fcur->setregion(darec, darec);
  }
  else
  {
    if (filter.not_empty()) filter << "&&";
    filter << "(TIPODIST==\"\")&&(NDIST==\"\")";
  }
  fcur->setfilter(filter,TRUE);
  
  long n = fcur->items();
  fcur->freeze();
// se la stampa non si fa a video istanzia puntatore per la gestione
// della barra di attesa
  for (int j=0; j < ncopie; j++)
  {
    TProgind* pi = NULL;
    if (!is_vis)
      pi = new TProgind(n,"Stampa Effetti...",FALSE,TRUE,10);
    // ciclo sugli elementi del cursore di stampa
    //for (*fcur = 0; fcur->pos() < n; ++(*fcur))
    {
      if (pi) pi->addstatus(1L);   // aggiorna la barra d'attesa
      _formrb->print();    // stampa il form
    }
  }
  if (tipost == 'D')  // se emetto riba in definitiva devo aggiornare
    aggiorna_rb(fcur);// data, numero emissione e flag di stampa effetto
}

// gestione emissione su  moduli cartacei delle distinte
void TEmissione::print_dse(char tipost, int ndist, char tipodist, int ncopie, const bool is_vis)
{
  TCursor* fcur = _formdse->cursor();
  TLocalisamfile &eff = fcur->file(LF_EFFETTI);
// setta la chiave 4 per il cursore per poter leggere tutti gli effetti
// della distinta
  TString16 filter;
  if (tipost == 'D' && !_msk->get_bool(F_RIST))  // se stampa definitiva effetti e se non deve ristampare le riba
    filter = "DISTSTAM=\" \"";// setta il filtro del cursore per ...
  fcur->setfilter(filter,TRUE);
  fcur->setkey(4);
  TRectype darec(eff.curr()); // fissa  i dati per la scelta degli ...
  darec.zero(); // ... effetti nel primo e nell'ultimo record del cursore
  if (ndist > 0)
  {
    darec.put(EFF_NDIST, ndist);
    darec.put(EFF_TIPODIST, tipodist);
    TRectype arec(darec);
    fcur->setregion(darec, arec);
    fcur->setfilter("");
  }
  else
    fcur->setfilter("(TIPODIST==\"\")&&(NDIST==\"\")");
  long n = fcur->items();
  fcur->freeze();
// se la stampa non si fa a video istanzia puntatore per la gestione
// della barra di attesa
  for (int j=0; j < ncopie; j++)
  {
    TProgind* pi;
    if (!is_vis)
      pi = new TProgind(n,"Stampa Distinta...",FALSE,TRUE,10);
    _base_page_no = 0;
    if (!is_vis)
      pi->addstatus(1L); // aggiorna la barra d'attesa
    _formdse->find_field('F',last_page,2).set(""); // Azzera nr documenti
    _formdse->find_field('F',last_page,3).set(""); // Azzera tot documenti
    _formdse->print();   // stampa il form
   // stampa numero di pagina (solo nella distinta)
    _base_page_no = printer().getcurrentpage() -1;
  }
  if (tipost == 'D')  // se emetto distinta in definitiva ...
    aggiorna_dist(fcur);// ... devo aggiornare  flag di stampa distinta
}

void TEmissione::enable_dettaglio(TForm& form) const
{
  TForm_subsection* fss = form.exist_field('B', odd_page, "RIGHE_EFFETTO");
  const bool dett = _msk->get_bool(F_DETTAGLIO);
  if (fss)
    fss->show(dett);
  else
  {
    if (dett)
    {
      warning_box("Il modulo %s non prevede la stampa dei dettagli:\n"
                  "E' necessario aggiungere la sezione RIGHE_EFFETTO",
                  (const char*)form.name());
    }
  }
}

// gestione emissione  effetti/distinte su moduli cartacei
void TEmissione::print()
{
  int ncopie = _msk->get_int(F_NCOPIE);
  if (ncopie == 0) ncopie = 1;
  printer().open();
  // TRUE se si stampa a video
  const bool is_vis = printer().printtype() == screenvis;
  int emis = _msk->get_int(F_EMIS);
  int ndist = _msk->get_int(F_NUMBER);
  char tipodist = _msk->get(F_TIPODIST)[0];
  _rel->lfile().put(EFF_TIPODIST,tipodist);
  _rel->lfile().put(EFF_NDIST,ndist);
  _rel->lfile().put(EFF_NRIGADIST,1);
  _rel->lfile().setkey(4);
  _rel->read();
  long codabi = _rel->lfile().get_long(EFF_CODABIP);
  const char tipocf = _rel->lfile().get_char(EFF_TIPOCF);
  const char tipopag = _rel->lfile().get_char(EFF_TIPOPAG);
  
  char tipost = _msk->get(F_TIPOST)[0];
  char tipord = _msk->get(F_TIPORD)[0];
// se emetto riba istanzio il form per le riba
// se emetto distinta istanzio il form per le distinte
  TFilename nomeform; // compongo il nome del form
  if (emis == 1)
  {
    nomeform.format("r%c%c%05ld.frm",tipocf, tipopag, codabi);
    if (!nomeform.exist())                // se non esiste
      nomeform.overwrite("00000", 3);     // elimino codice banca
    if (!nomeform.exist())                // se non esiste 
       nomeform = "rb.frm";               // utilizzo quello generico
    _formrb = new TRiba_form(nomeform);
    enable_dettaglio(*_formrb);
    print_rb(tipost,ndist,tipodist,ncopie,is_vis);
  }
  else
  {
    nomeform.format("d%c%c%05ld.frm",tipocf, tipopag, codabi);// compongo il nome del form
    if (!nomeform.exist())                // se non esiste
      nomeform.overwrite("00000", 3);     // elimino codice banca
    if (!nomeform.exist())                // se non esiste
       nomeform = "dse.frm";              // utilizzo quello generico
    _formdse = new TDistinta_form(nomeform, _firmrel);
    enable_dettaglio(*_formdse);
    _formdse->set_order(tipord);
    print_dse(tipost,ndist,tipodist,ncopie,is_vis);
  }
  printer().close();
}

// handler per gestire la conferma dell'annullamento dei dati inseriti
// nella maschera
bool TEmissione::annulla_handler(TMask_field& f, KEY k)
{
  TMask &m = f.mask();
  if (k == K_SPACE)
  {
    if (yesno_box("Vuoi veramente annullare i dati inseriti"))
       m.reset();
  }
  return TRUE;
}

// costruttore classe TRiba_form
TRiba_form::TRiba_form(const char* name): TForm()
{
  read(name);
}

// gestione dei messaggi estesi nei campi
bool TRiba_form::validate(TForm_item &cf, TToken_string &s)
{
  const TString code(s.get(0));
  TString valore;

  if (code == "_IMPORTO")
  {
  // gestione dei campi relativi all'importo dell'effetto. Setta il valore da
  // solo se e' in valuta (cambia anche la picture)
  // sintassi: _IMPORTO
    TEffetto effetto(cursor()->file().curr());
    TString picture(cf.picture());
    const bool in_valuta = effetto.in_valuta();
    real importo = effetto.importo(in_valuta);
    if (in_valuta)
      picture << ",@@@";
    valore = importo.string(picture);
    cf.set(valore);
    cf.put_paragraph(valore);
  } 
  else if (code == "_BANCAP")
  {
  // gestione dei campi relativi alla banca di presentazione dell'effetto
  // sintassi: _BANCAP
    TCursor* cur = cursor();
    if (cur->curr().get_int(EFF_NDIST) > 0)
    {
      TRectype & ban = cur->curr(-204);
      valore.cut(0);
      valore << ban.get("S0");
      valore.trim();
      ban = cur->curr(-202);
      valore << " " << ban.get("S0");
      valore.trim();
      cf.set(valore);
      cf.put_paragraph(valore);
    }
  }
  else if (code == "_FATT")
  {
  // gestione dei campi relativi alle/a fatture/a a cui si riferisce un effetto
  // sintassi: _FATT,<macro>
  // dove: <macro> <20> uno delle macro seguenti:
  //       "!A"         fattura o fatture
  //       "!DATI"      numero e data fattura
  //       "!IMPFATT"   importo fattura
    //TCursor* fcur = cursor();
    //TLocalisamfile &eff = fcur->file(LF_EFFETTI);
    TEffetto effetto(cursor()->file().curr());// = eff.curr();
    long num = effetto.numero();
    const bool in_valuta = effetto.in_valuta();
    bool condition = (effetto.fatt(num));//TRUE se effetto non raggruppato
    TToken_string* dati = effetto.dati_fatt(num, in_valuta);
    TString in(s.get());
    if (in[0]=='!')
    {
      in.ltrim(1);
  // "!A" se 1 sola fattura stampa 'a' altrimenti stampa 'e'
      if (in == "A")
      {
        if (condition)
          cf.set("a");
        else
          cf.set("e");
      }
  // "!DATIFATT" stampa numero e data fattura delle fatture a cui si riferisce l'effetto
      if (in == "DATIFATT")
      {
        int elem = dati->items();
        TString descfatt;
        for (int i = 0; i < elem; i+=3)
        {
            descfatt << dati->get(i);
            descfatt << "  ";
            descfatt << dati->get(i+1);
            descfatt << "  ";
            cf.set(descfatt);
        }
      }
  // "!IMPFATT" se 1 sola fattura ne stampa l' importo
      if (in == "IMPFATT")
      {
        if (condition)
        {
          TString picture(cf.picture());
          if (in_valuta)
            picture << ",@@@";
          real importo(dati->get(2));
          cf.set(importo.string(picture));
         }
      }
    }
    valore = cf.get();
    cf.put_paragraph(valore);
    return (TRUE);
  }
  else
  if (code == "_CLI")
  {
  // gestione dei campi relativi al cliente  a cui si riferisce un effetto
  // sintassi: _CLI,<macro>
  // dove: <macro> <20> uno delle macro seguenti:
  //       "!IND"         INDIRIZZO + NR. CIVICO
  //       "!PIAZZA"      COMUNE + PROVINCIA
    TString in(s.get());
    if (in[0]=='!')
    {
      in.ltrim(1);
      TRelation* rel = relation();
      if (in=="IND")
      {
        valore = rel->lfile(LF_CLIFO).get(CLI_INDCF);
        in = rel->lfile(LF_CLIFO).get(CLI_CIVCF);
        if (in.not_empty())
          valore << ", " << in;
      }
      else
        if (in=="PIAZZA")
        {
          valore = rel->lfile(LF_COMUNI).get(COM_DENCOM);
          in = rel->lfile(LF_COMUNI).get(COM_PROVCOM);
          if (in.not_empty())
            valore << " (" << in << ")";
        }
    }
    cf.put_paragraph(valore);
    return (TRUE);
  }
  return TForm::validate(cf, s);
}

// costruttore classe TDistinta_form
TDistinta_form::TDistinta_form(const char* name, TRelation *rel): TForm(), _firmrel(rel)
{
  read(name);
  _cursor = NULL;
}

// setta l'ordinamento del TSordet_cursor del form
void TDistinta_form::set_order(const char tipo)
{
  TString ordine;
  // ordinamento secondo la data di scadenza dell'effetto
  if (tipo == 'S')
     ordine  = "DATASCAD|TIPODIST|NDIST|NRIGADIST";
  // ordinamento seconda il numero e la data della fattura
  if (tipo == 'F')
     ordine = "14->NFATT|TIPODIST|NDIST|NRIGADIST";
  _cursor = new TSorted_cursor(relation(),ordine);
}

// distruttore classe TDistinta_form
TDistinta_form::~TDistinta_form()
{
  if (_cursor) delete _cursor;
}

// gestione dei messaggi estesi nei campi
bool TDistinta_form::validate(TForm_item &cf, TToken_string &s)
{
  const TString code(s.get(0));
  TString valore;
  if (code == "_IMPORTO")
  {
  // gestione dei campi relativi all'importo dell'effetto. Setta il valore da
  // solo se e' in valuta (cambia anche la picture)
  // sintassi: _IMPORTO
    TEffetto effetto(cursor()->file().curr());
    TString picture(cf.picture());
    const bool in_valuta = effetto.in_valuta();
    real importo = effetto.importo(in_valuta);
    if (in_valuta)
      picture << ",@@@";
    valore = importo.string(picture);
    cf.set(real::ita2eng(valore));
    cf.put_paragraph(valore);
    return (TRUE);
  }
  if (code == "_BANCAP")
  {
  // gestione dei campi relativi alla banca di presentazione della distinta
  // sintassi: _BANCAP
    TCursor* cur = cursor(); 
    TRectype & ban = cur->curr(-204);
    valore.cut(0);
    valore << ban.get("S0");
    valore.trim();
    ban = cur->curr(-202);
    valore << " " << ban.get("S0");
    valore.trim();
    cf.set(valore);
    cf.put_paragraph(valore);
    return (TRUE);
  }
  if (code == "_DITTA")
  {
  // gestione di campi della ditta corrente
  // sintassi: _DITTA,<macro>
  // dove: <macro> <20> uno delle macro seguenti:
  //       "!RAGSOC"     ragione sociale
    TString in(s.get());
    if (in[0]=='!')
    {
      in.ltrim(1);
  // "!RAGSOC" prende la ragione sociale della ditta corrente
      if (in=="RAGSOC")
      {
        valore = _firmrel->lfile().get("RAGSOC");
        valore.strip_d_spaces();
        cf.set(valore);
      }
    }
    valore = cf.get();
    cf.put_paragraph(valore);
    cf.set("");
    return (TRUE);
  }
  if (code == "_CLI")
  {
  // gestione dei campi relativi al cliente  a cui si riferisce un effetto
  // sintassi: _CLI,<macro>
  // dove: <macro> <20> uno delle macro seguenti:
  //       "!IND"         INDIRIZZO + NR. CIVICO
  //       "!PIAZZA"      COMUNE + PROVINCIA
    TString in(s.get());
    if (in[0]=='!')
    {
      in.ltrim(1);
      TRelation* rel = relation();
      if (in=="IND")
      {
        valore = rel->lfile(LF_CLIFO).get(CLI_INDCF);
        in = rel->lfile(LF_CLIFO).get(CLI_CIVCF);
        if (in.not_empty())
          valore << ", " << in;
      }
      else
        if (in=="PIAZZA")
        {
          valore = rel->lfile(LF_COMUNI).get(COM_DENCOM);
          in = rel->lfile(LF_COMUNI).get(COM_PROVCOM);
          if (in.not_empty())
            valore << " (" << in << ")";
        }
    }
    cf.set(valore);
    cf.put_paragraph(valore);
    return (TRUE);
  }
  if (code == "_FATT")
  {
  // gestione dei campi relativi alle fatture a cui si riferisce un effetto
  // sintassi: _FATT,<macro>
  // dove: <macro> <20> uno delle macro seguenti:
  //       "!DATI"      numero e data fattura
    TEffetto effetto(cursor()->file().curr()); //= eff.curr();
    long num = effetto.numero();
    TToken_string* dati = effetto.dati_fatt(num);
    int elem = dati->items();
    TString descfatt;
    TString in(s.get());  // prende il primo parametro, il codice del messaggio
    if (in[0]=='!')
    {
      in.ltrim(1);
  // "!DATIFATT"  stampa numero e data fattura delle fatture a cui si riferisce l'effetto
      if (in == "DATIFATT")
      {
        for (int i = 0; i < elem; i+=3)
        {
           descfatt << dati->get(i);
           descfatt << "  ";
           descfatt << dati->get(i+1);
           descfatt << "  ";
           cf.set(descfatt);
        }
      }
    }
    valore = cf.get();
    cf.put_paragraph(valore);
    return (TRUE);
  }
  if (code == "_DATA")
  {
     // gestione della data di emissione delle riba
     // sintassi: _DATA
    const TDate data_emis = app().msk().get_date(F_DATAEMIS);
    valore = data_emis.string();
    cf.set(valore);
    cf.put_paragraph(valore);
    cf.set("");
    return TRUE;
  }
  return TForm::validate(cf, s);
}

// gestione dei messaggi estesi nei campi
void TRiba_file:: validate(TCursor& cur,TRecord_text &rec, TToken_string &s, TString& str)
{
  const TString code(s.get(0));
  TString valore;
  if (code == "_FISSO")
  {
    // gestione dei campi fissi per i record delle riba
    // sintassi: _FISSO,!<valore>
    // dove: <valore> <20> la stringa fissa da emettere
    TString in(s.get());
    CHECK(in[0]=='!',"Macro _FISSO senza carattere '!'");
    in.ltrim(1);
    in.trim();
    valore = in;
  }
  else if (code == "_DATA")
  {
     // gestione della data di emissione delle riba
     // sintassi: _DATA
     const TDate data_emis = app().msk().get_date(F_DATAEMIS);
     valore = data_emis.string();
  }
  else if (code == "_NRIBA")
  {
    // gestione dei campi relativi al flusso di effetti (riba)
    // sintassi: _NRIBA,<macro>
    // dove: <macro> <20> uno delle macro seguenti:
    //       "!NUM"     numero progressivo riba all'interno del flusso
    //       "!TOT"      numero di effetti nel flusso
    //       "!NREC"    numero di records nel flusso
    int items = (int)cur.items();
    TString in(s.get());
    CHECK(in[0]=='!',"Macro _NRIBA senza carattere '!'");
    in.ltrim(1);
    if (in=="NUM")
    {
      valore.cut(0);
      valore << cur.pos() + 1;
    }
    else if (in=="TOT")
    {
      valore.cut(0);
      valore << items;
    }
    else if (in=="NREC")
    {
      valore.cut(0);
      int rec = items * 7 + 2;
      valore << rec;
    }
    else 
      CHECKS (TRUE,"Sotto-Macro _NRIBA non definita",(const char *)in); 
  }
  else if (code == "_DITTA")
  {
    // gestione di campi della ditta corrente
    // sintassi: _DITTA,<macro>,<opzione>
    // dove: <macro> <20> uno delle macro seguenti:
    //       "!RAGSOC"     ragione sociale
    // dove: <opzione> <20> uno delle opzioni seguenti:
    //      "0" la ragione sociale andr<64> ad occupare un unico campo
    //      "1" la ragione sociale andr<64> ad occupare pi<70> campi, primo segmento
    //      "2" la ragione sociale andr<64> ad occupare pi<70> campi, secondo segmento
    //      "3" la ragione sociale andr<64> ad occupare pi<70> campi, terzo segmento
    //      "4" la ragione sociale andr<64> ad occupare pi<70> campi, quarto segmento
    TLocalisamfile ditte(LF_NDITTE);
    ditte.put("CODDITTA",ditta());
    ditte.read();
    TString in(s.get());
    CHECK(in[0]=='!',"Macro _DITTA senza carattere '!'");
    in.ltrim(1);
    if (in=="RAGSOC")
    {
      const TString ragsoc = ditte.get("RAGSOC");
      in = s.get();
      if (in == "0")
      {
        valore.cut(0);
        valore = ragsoc.left(30);
        valore.trim();
        TString str = ragsoc.right(20);
        str.trim();
        valore << " " << str;
      }
      else
      {
          TParagraph_string string(ragsoc,24);
          string.restart();
          int indice = atoi(in);
          if (in == "1") valore = string.get(indice-1);
          if (in == "2") valore = string.get(indice-1);
          if (in == "3") valore = string.get(indice-1);
          if (in == "4") valore = string.get(indice-1);
      }
    }
    else 
      CHECKS (TRUE,"Sotto-Macro _DITTA non definita",(const char *)in); 
  }
  else if (code == "_DEBITORE")
  {
    // gestione di campi della ditta corrente
    // sintassi: _DEBITORE,<macro>,<opzione>
    // dove: <macro> <20> uno delle macro seguenti:
    //       "!RAGSOC"     ragione sociale
    //       "!CFPI"       Partita IVA o Codice fiscale 
    //       "!INDIRIZZO" indirizzo
    //       "!PIAZZA"      comune + sigla provincia
    // dove: <opzione> <20> uno delle opzioni seguenti:
    //      "1" la ragione sociale andr<64> ad occupare pi<70> campi, primo segmento
    //      "2" la ragione sociale andr<64> ad occupare pi<70> campi, secondo segmento
    TRectype& clifo = cur.curr(LF_CLIFO);
    TRectype& comuni = cur.curr(LF_COMUNI);
    TString in(s.get());
    CHECK(in[0]=='!',"Macro _DEBITORE senza carattere '!'");
    in.ltrim(1);
    if (in=="RAGSOC")
    {
      TString ragsoc = clifo.get("RAGSOC");
      in = s.get();
      TParagraph_string string(ragsoc,30);
      string.restart();
      int indice = atoi(in);
      if (in == "1") valore = string.get(indice-1);
      if (in == "2") valore = string.get(indice-1);
    }
    else if (in=="INDIRIZZO")
    {
      valore.cut(0);
      valore << clifo.get("INDCF");
      valore.trim();
      valore << " " << clifo.get_int("CIVCF");
      valore.trim();
      valore << " " << clifo.get("LOCALITACF");
      valore.trim();
    }
    else if (in=="COMUNE")
    {
      valore.cut(0);
      valore << comuni.get("DENCOM");
      valore.trim();
    }
    else if (in=="PROV")
    {
      valore = comuni.get("PROVCOM");
      valore.trim();
    }
    else if (in=="CFPI")
    {
      valore = clifo.get("PAIV");
      valore.trim();
      if (valore.empty())
        valore = clifo.get("COFI");
      valore.trim();
    }
    else    
      CHECKS (TRUE,"Sotto-Macro _DEBITORE non definita",(const char *)in); 
  }
  else if (code == "_BANCA")
  {
  // gestione dei campi relativi alla banca d'appoggio dell'effetto
  // sintassi: _BANCA
    TRectype & ban = cur.curr(-401);
    valore.cut(0);
    valore << ban.get("S0");
    valore.trim();
    ban = cur.curr(-402);
    valore << " " << ban.get("S0");
    valore.trim();
  }
  else if (code == "_FATT")
  {
    // gestione dei campi relativi alle/a fatture/a a cui si riferisce un effetto
    // sintassi: _FATT,<opzione>
    // dove: <opzione> <20> uno delle opzioni seguenti:
    //  "1" i dati della fattura andranno ad occupare pi<70> campi, primo segmento
    //  "2" i dati della fattura andranno ad occupare pi<70> campi, secondo segmento
    TLocalisamfile &eff = cur.file();
    TEffetto effetto = eff.curr();
    long num = effetto.numero();
    TToken_string* dati = effetto.dati_fatt(num);
    int elem = dati->items();
    TString descfatt;
    for (int i = 0; i < elem; i+=3)
    {
           descfatt << dati->get(i);
           descfatt << " ";
           descfatt << dati->get(i+1);
           descfatt << " ";
    }
    int l = descfatt.len();
    TString in(s.get());
    if (in[0]=='!')
    {
      in.ltrim(1);
      if (in == "1")
      {
       valore = descfatt.left(40);
       valore.trim();
      }
      if (in == "2")
      {
       valore = descfatt.mid(40, l);
      }
    }
  }
  else if (code == "_IMPORTO")
  {
    // gestione di campi degli importi degli effetti nel flusso
    // sintassi: _IMPORTO,<macro>
    // dove: <macro> <20> uno delle macro seguenti:
    //       "!ADD" aggiunge l'importo dell'effetto corrente al totale
    //       "!TOT" emette il totale
    TString in(s.get());
    CHECK(in[0]=='!',"Macro _IMPORTO senza carattere '!'");
    in.ltrim(1);
    if (in=="ADD")
    {
      real importo(str);
      add_tot_importi(importo);
      valore.cut(0);
      valore << importo.string(13,0);
    }
    else if (in=="TOT")
    {
      valore.cut(0);
      real importo = tot_importi();
      valore << importo.string("##############@");
      set_tot_importi(0.0);
    }
    else
      CHECKS (TRUE,"Sotto-Macro _IMPORTO non definita",(const char *)in);
  } else
    if (code == "_CODSIA")
    {
      TConfig cnf(CONFIG_DITTA);
      valore = cnf.get("CODSIA", "ef");
    }
    else
      CHECKS (TRUE,"Macro non definita",(const char *)code);
  str = valore;
}

int ef0500(int argc, char* argv[])
{
  TEmissione a ;
  a.run(argc, argv, "Emissione Effetti e Distinte");
  return 0;
}