campo-sirio/ve/ve1100.cpp

#include <applicat.h>
#include <config.h>
#include <form.h>
#include <mask.h>   
#include <relation.h>
#include <expr.h>
#include <tabutil.h>
#include <printer.h>
#include <utility.h>
#include <urldefid.h>

#include "sconti.h"
#include "tclifor.h"
#include "velib01.h"

#include "ve1100.h"
#include "ve0100b.h"
#include "..\cg\pagament.h"



struct dec_parm {
  int pri_lit,
      pri_val, 
      qta_lit, 
      qta_val,  // si lo so non ha senso, ma lo faccio lo stesso
      imp_lit, 
      imp_val;
      // add other groups here
};

//////////////////////////////////////////////////////////////////////////////////////////////
// classe TDocumentoEsteso: oggetto che ha come finalita' il calcolo dei riepiloghi IVA
//////////////////////////////////////////////////////////////////////////////////////////////

class Riepilogo_Iva : public TObject
{
  real _imp;
  real _iva;
  real _ali;
  byte _tipo;
  TString16 _cod;
  TString   _des;
  
protected:
  
public:
  real& imp()    { return _imp;} // Imponibile
  real& iva()    { return _iva;} // Iva
  real& ali()    { return _ali;} // Aliquota
  TString& cod() { return _cod;} // Descrizione
  TString& des() { return _des;} // Descrizione
  byte&    tipo(){ return _tipo;}// Tipo (Vedi opzioni per la selzione di filtro nella validate())
  void     zero(){ _imp = 0.0; _iva = 0.0; _ali = 0.0; _tipo = 0; _cod = ""; _des = ""; }
  virtual TObject* dup() const { return new Riepilogo_Iva(*this); }
  Riepilogo_Iva& operator = (Riepilogo_Iva& a);
  Riepilogo_Iva() {_imp = 0.0; _iva = 0.0; _ali = 0.0; _tipo = 0;}  
  ~Riepilogo_Iva() {};
};

Riepilogo_Iva& Riepilogo_Iva::operator=(Riepilogo_Iva& a)
{ 
  _imp = a.imp(); _iva = a.iva(); _ali = a.ali();
  _cod = a.cod(); _tipo = a.tipo(); _des = a.des();
  return *this;
}

class TDocumentoEsteso : public TDocumento
{ 
  // Parametri del documento
  dec_parm        _parm;          // Parametri per gli arrotondamenti
  TTable        * _iva;           // Tabella codici IVA
  TCond_vendita * _condv;         // Condizioni di vendita per lo sconto
  
  // Totali del documento ricalcolati non appena la tabellina di riepilogo IVA e' completa
  real _importi_netti, _imposte;

  // membri per il calcolo del riepilogo IVA
  bool            _sum_selected;  // TRUE se ha selezionato una riga del riepilogo, funge da semaforo per leggere la prossima
  int             _sum_filter;    // Filtro corrente della riga Riepilogo_Iva in corso di stampa (-1 se non ha ancora calcolato la tabella)
  TString_array   _order_array;   // Array di TToken_string contenenti i codici IVA soddisfacenti ad ogni tipo di filtro
  TAssoc_array    _summary_table; // Array dove vengono memorizzate le imposte per aliquota
  Riepilogo_Iva   _sum_current;   // Riga corrente del riepilogo

  // membri per il calcolo del riepilogo scadenze
  TString_array   _scadenze_array;// Array che contiene le scadenze ("<data>|<importo>")
  int             _scadenze_current;  // indice per identificare l'elementi corrente sull'array (-1 se non ha ancora calcolato)

public:

  
  // Funzioni per il riepilogo IVA
  const bool summary_compiled() { return _sum_filter > -1; }
  void compile_summary(); // Aggiorna la tabella riepilogativa    
  void summary_filter(byte selector);  // filtra la tabellina secondo il filtro corrente se non e' gia' stato fatto
  void summary_set_next(); // seleziona il prossimo elemento del filtro
  Riepilogo_Iva& sum_current() { return _sum_current; } // ritorna la riga corrente del filtro corrente
  const char * summary_get(const TString& w); // ritorna l'informazione richiesta estratta dall'elemento corrente
  int  summary_items() { return _summary_table.items();} // ritorna il numero di righe in totale della tabellina
  TAssoc_array& summary() { return _summary_table; }

  // Funzioni per il ricalcolo delle scadenze
  void scadenze_recalc(); // resetta e ricalcola le scadenze
  void scadenze_set_next(); // seleziona il prossimo elemento dell'array delle scadenze
  const char * scadenze_get(const TString& w); // reperisce l'informazione richiesta dall'elemento corrente
  int  scadenze_items() { return _scadenze_array.items(); }  // restituisce il numero di scadenze
  TString_array& scadenze() { return _scadenze_array; }

  // Funzioni di totalizzazione
  real& tot_importi_netti();
  real& tot_imposte();
  real tot_spese();
  real tot_documento();
  // restituisce tot_imponibili, tot_esenti, tot_nonsoggetti a seconda del selettore:  
  // 1 = regime normale
  // 2 = da ventilare (non usato)
  // 4 = esenti
  // 8 = non imponibili
  // 16 = non soggetti
  // pertanto i non imponibili avranno selettore 1 e gli esenti selettore 4.
  // per avere esenti + non soggetti il selettore sara' 20 e cosi' via.
  real tot_imponibili(byte selector);
  
  // Reperisce l'informazione <what> dal campo G1 della testata
  const char* get_head_info(const TString& what);
  
  // Funzioni per settare i parametri
  void set_decimals(dec_parm & parm) { _parm = parm ; }
  void set_condv(TCliFor * cli); // Cambia le condizioni di vendita
  TDocumentoEsteso (const TRectype & rec, dec_parm & parm, TCliFor * cli = NULL) ;
  TDocumentoEsteso (const TRectype & rec, TCliFor * cli = NULL) ;
  ~TDocumentoEsteso();
};

void TDocumentoEsteso::compile_summary()
{
  _sum_filter = 0;
  const int items = rows();
  
  _summary_table.destroy();
  _imposte = 0.0;
  _importi_netti = 0.0;
  const bool val = in_valuta();
  // Scorre tutte le righe e compila la tabellina _summary_table
  for (int i = 1; i <= items; i++)
  {
    TRectype& r = row(i);
    int nriga = r.get_int("NRIGA");
    real price = r.get_real("PREZZO");
    real qta = r.get_real("QTA");
    real aliquota, sc, imponibile, iva;
    TString sconto(r.get("SCONTO"));
    TString codiva(r.get("CODIVA"));
    _iva->put("CODTAB", codiva);
    if (_iva->read() != NOERR) continue; // Se non trova il codice salta questa riga
    
    aliquota = _iva->get_real("R0");
    if (_condv != NULL && sconto.not_empty()) // Se c'e' la condizione di vendita, calcola lo sconto...
    {
      _condv->set_sconto(sconto);
      sc = 100.0 - _condv->sconto_val();
      price = ((price * sc) / 100.0);
    }
    price.round(val ? _parm.pri_val : _parm.pri_lit); // prezzo scontato
    qta.round(val ? _parm.qta_val : _parm.qta_lit);
    imponibile = price * qta;
    imponibile.round (val? _parm.imp_val : _parm.imp_lit); // imponibile di riga
    iva = (imponibile * aliquota) / 100.0;
    iva.ceil(val ? _parm.imp_val : _parm.imp_lit); // imposta calcolata

    // Aggiorna o aggiunge l'elemento se non esiste    
    Riepilogo_Iva riepilogo_tmp;
    const bool exists = _summary_table.is_key(codiva);
    Riepilogo_Iva& riepilogo  = (exists ? (Riepilogo_Iva&)_summary_table[codiva] : riepilogo_tmp);
    // Aggiorna anche il totale importi netti ed il totale imposte
    _importi_netti += imponibile;
    _imposte += iva;
    riepilogo.imp() += imponibile; riepilogo.iva() += iva;
    riepilogo.ali() = aliquota; riepilogo.cod() = codiva; 
    TString16 tipo(_iva->get("S1"));
    if (tipo == "VE") riepilogo.tipo() = 2;
    else if (tipo == "ES") riepilogo.tipo() = 4;
    else if (tipo == "NI") riepilogo.tipo() = 8;
    else if (tipo == "NS") riepilogo.tipo() = 16;
    else riepilogo.tipo() = 1; // Regime IVA normale
    if (riepilogo.tipo() != 1) // Se non e' regime normale salva anche la descrizione
      riepilogo.des() = _iva->get("S0");
    _summary_table.add(codiva,riepilogo,exists);
  }
  // Inizializza l'array di ordine
  for (i = 0; i<32;i++) 
  {
    TToken_string s;
    _order_array.add(s);
  }
}

void TDocumentoEsteso::summary_filter(byte selector)
{
  if (_sum_filter == -1) compile_summary(); // Crea la tabella se deve ancora farlo
  // se ha selezionato una riga in precedenza deve finire di stamparla  
  // ovvero non seleziona il filtro fino a quando non ha ricevuto una summary_set_next()
  if (_sum_selected) return;
  //
  // Procedimento:
  // Memorizza in un TString_array tante TToken_string quanti sono i filtri possibili
  // (al massimo 31 [1+2+4+8+16]). Ogni TToken_string contiene i codici IVA
  // delle righe di Riepilogo_Iva che soddisfano la condizione di filtro
  _sum_selected = TRUE;
  _sum_filter = selector;
  TToken_string& codici = _order_array.row(_sum_filter-1);
  if (codici.items() == 0) // Se non c'e' nemmeno un codice IVA allora deve effettuare il filtro
  { // ovvero mette in <<codici>> tutti i codici IVA che soffisfano tale filtro
    // sara' poi la summary_set_next() a selezionare sequenzialmente il giusto codice a seconda del filtro corrente

    // Scorre sequenzialmente la tabella _summary_table e compone la TToken_string coni codici IVA
    const int items = _summary_table.items();
    Riepilogo_Iva* curr = (Riepilogo_Iva *) _summary_table.first_item();
    for (int i = 0; i < items && curr != NULL; i++)
    {
      if (curr->tipo() & _sum_filter) // se fa parte del filtro selezionato schiaffa il codice nella TToken_string
        codici.add(curr->cod());
      curr = (Riepilogo_Iva*) _summary_table.succ_item();
    }
    codici.restart();
    summary_set_next(); // setta l'elemento corrente
  }
}

void TDocumentoEsteso::summary_set_next()
{
  _sum_selected = FALSE;
  TToken_string& codici = _order_array.row(_sum_filter-1);
  
  TString16 codiva(codici.get()); // Reperisce il prossimo codice nella lista. (son gia' ordinati per codice)
  if (codiva.not_empty() && _summary_table.is_key(codiva))
  {
    // Estrae da _summary_table i dati relativio al codice corrispondente.
    Riepilogo_Iva& riep= (Riepilogo_Iva&) _summary_table[codiva];
    _sum_current = riep;
  }
  else
    _sum_current.zero(); // se non esiste il codice  azzera l'elemento corrente (non stampera' nulla)
}

const char *  TDocumentoEsteso::summary_get(const TString& w)
{
  TString ret;
  if (w == "COD") ret = _sum_current.cod();          // Ritorna il codice IVA
  if (w == "IMP" && _sum_current.imp() != 0.0) ret = _sum_current.imp().string(); // Ritorna l'imponibile
  if (w == "IVA" && _sum_current.iva() != 0.0) ret = _sum_current.iva().string(); // Ritorna l'imposta
  if (w == "ALI" && _sum_current.ali() != 0.0) ret = _sum_current.ali().string(); // Ritorna l'aliquota %
  if (w == "DES") ret = _sum_current.des();          // Ritorna la descrizione ( se il codice e' regime normale la descr. e' vuota)
  return (const char *)ret;
}

void  TDocumentoEsteso::scadenze_recalc()
{
  _scadenze_array.destroy();
  _scadenze_current = -1;
  TString16 codpag(head().get("CODPAG"));
  TString16 data(head().get("DATAINSC"));
  TPagamento pag( codpag, data);
  real totspese = tot_spese();
  real totimposte = tot_imposte();
  real totimponibili = tot_documento() - totimposte - totspese;
  const bool valuta = in_valuta();
  if (valuta)
  {
    real change(cambio());
    real val1 = totimponibili * change;
    real val2 = totimposte * change;
    real val3 = totspese * change;
    pag.set_total_valuta( totimponibili, totimposte, totspese, change, val1, val2 ,val3);
  }
  else
    pag.set_total( totimponibili, totimposte, totspese );
  pag.set_rate_auto( );      
  const int numrate = pag.n_rate( );
  for (int i = 0; i< numrate; i++)
  {
    TToken_string t;
    t.add(pag.data_rata(i));
    t.add(pag.importo_rata(i,valuta).string());
    _scadenze_array.add(t);
  }
  if (numrate > 0) _scadenze_current++;
}

const char *  TDocumentoEsteso::scadenze_get(const TString& w)
{
  TString ret;
  
  if (_scadenze_current == -1)
    // calcola le scadenze e le mette in _scadenze_array
    scadenze_recalc();
  if (_scadenze_current > -1 && _scadenze_current < _scadenze_array.items())
  {
    if (w == "DATA") ret = _scadenze_array.row(_scadenze_current).get(0);    // ritorna la data di scadenza
    if (w == "IMPORTO") ret = _scadenze_array.row(_scadenze_current).get(1); // ritorna l'importo in scadenza
  }  
  return (const char*)ret;
}

void TDocumentoEsteso::scadenze_set_next()
{
  if (_scadenze_current < _scadenze_array.items() && _scadenze_current >= 0)
    _scadenze_current++;
}

real& TDocumentoEsteso::tot_importi_netti()
{
  if (!summary_compiled()) compile_summary();
  return _importi_netti;  
}

real& TDocumentoEsteso::tot_imposte()
{
  if (!summary_compiled()) compile_summary();
  return _imposte;  
}

real TDocumentoEsteso::tot_spese()
{
  TString16 t("TOTSP");
  real number(get_head_info(t));
  return number;
}

real TDocumentoEsteso::tot_documento()
{
  if (!summary_compiled()) compile_summary();
  real number = _imposte + _importi_netti;
  return number;  
}

real TDocumentoEsteso::tot_imponibili(byte selector)
{
  if (!summary_compiled()) compile_summary();
  
  real number = 0.0;
  const int items = _summary_table.items();
  Riepilogo_Iva* curr = (Riepilogo_Iva *) _summary_table.first_item();
  for (int i = 0; i < items && curr != NULL; i++)
  {
    if (curr->tipo() & selector) // se fa parte del filtro selezionato schiaffa il codice nella TToken_string
      number += curr->imp();
    curr = (Riepilogo_Iva*) _summary_table.succ_item();
  }
  return number;
}


const char* TDocumentoEsteso::get_head_info(const TString & what)
{
  TToken_string memo(head().get("G1"),'\n'); // prende il campo memo con i totalizzatori. Un totalizzatore per riga nella forma <MACRO>=<VALORE>
  TString rt;
  const int items = memo.items();
  for (int i = 0; i<items; i++) // scorre le righe del memo
  {
    TToken_string item(memo.get(),'=');
    if (what == item.get())
    {
      rt = item.get();
      break;
    }
  }
  return (const char*) rt;
}

void TDocumentoEsteso::set_condv(TCliFor* cli)
{
  if (_condv != NULL)
   delete _condv;
  if (cli != NULL)
    _condv = new TCond_vendita(*cli);
}

TDocumentoEsteso::TDocumentoEsteso(const TRectype& rec, TCliFor *cli)
 : TDocumento(rec), _condv(NULL), _sum_filter(-1), _sum_selected(FALSE), _scadenze_current(-1)
{
  _iva = new TTable("%IVA");
  if (cli != NULL) _condv = new TCond_vendita(*cli);
}

TDocumentoEsteso::TDocumentoEsteso(const TRectype& rec, dec_parm & parm, TCliFor *cli)
 : TDocumento(rec), _condv(NULL), _sum_filter(-1), _sum_selected(FALSE),  _scadenze_current(-1)
{ 
  _parm = parm;
  _iva = new TTable("%IVA");
  if (cli != NULL) _condv = new TCond_vendita(*cli);
}

TDocumentoEsteso::~TDocumentoEsteso()
{
  if (_iva != NULL) delete _iva;
  if (_condv != NULL) delete _condv;
}

    
////////////////////////////////////////////////////////////////////////////
// classe TDocVen_Form customizzata dalla Form per i documenti di vendita
////////////////////////////////////////////////////////////////////////////
class TDocVen_Form: public TForm { 
  TRelation &_firmrel; // relazione di gestione dei dati della ditta corrente
  TString _module; // codice del modulo di carta associato a questo al form
  TCliFor *_cliente; // oggetto per le informazioni sul cliente
  TString_array _exclude_array; // array di coppie tipo/articolo da escludere dalla stampa
  TDocumentoEsteso * _doc; // oggetto 
  bool _cli_loaded; // flag che indica se l'oggetto cliente <20> gi<67> stato caricato
  TString_array _group_decimals; // Array di TToken_string per ogni gruppo definito in GENERAL. 
                                 // Il primo elelemento della token_string conterra' il numero del gruppo
                                 // il secondo il n.ro di decimali per importi in lire ed il terzo il n.ro
                                 // di decimali per gli importi in valuta
  // I gruppi sono cosi' predefiniti:
  // PRI_DECIMALS corrisponde al gruppo 29
  // QTA_DECIMALS corrisponde al gruppo 30
  // IMP_DECIMALS corrisponde al gruppo 31
  // Altri gruppi definiti dall'utente saranno cosi' sintatticamente impostati:
  // NEW_GROUP <n> <lit_dec> <val_dec>
  // Dove <n> e' il numero del gruppo 
  //      <lit_dec> e' il numero di decimali per i documenti in lire
  //      <val_dec> e' il numero di decimali per i documenti in valuta
  // ATTENZIONE: e' importante che i nomi dei gruppi utilizzati per modificare le pictures non siano usati per
  //             per altri messaggi. Inoltre un TForm_item che appartiene ad un gruppo di modifica picture
  //             non puo' appartenere ad un altro gruppo dello stesso tipo, ad esempio i gruppi 29 e 30 contemporaneamente.
  //             Puo' pero' appartenere anche ad altri gruppi che non siano utilizzati per lo scopo qui definito
protected:
  virtual void extended_parse_general(TScanner &); // gestione dei parametri estesi nella sezione general
  virtual bool validate(TForm_item &, TToken_string &); // gestione dei messaggi estesi nei campi
  virtual word set_body(word p, bool u); // derivata per la gestione del totalizzatore
  void edit_picture(TForm_item & f, const int dec);
  void modify_pictures();
public:
  const TString &get_module_code() { return _module; } // ritorna il codice del modulo di carta
  TString_array & exclude_list()   { return _exclude_array; }
  TDocVen_Form(const char *, TRelation &, TDocumentoEsteso * );
  virtual ~TDocVen_Form();
};



TDocVen_Form::TDocVen_Form(const char* name, TRelation &rel, TDocumentoEsteso * doc): TForm(), _firmrel(rel) {
  read(name);
  _cliente= new TCliFor;
  _cli_loaded= FALSE;
  _doc = doc;
  modify_pictures();
  dec_parm p;
  const int items = _group_decimals.items();
  for (int i = 0; i< items; i++)
  {
    TToken_string& t = _group_decimals.row(i);
    int gruppo = t.get_int(0);
    switch (gruppo)
    {
      case 29: p.pri_lit = t.get_int(1);p.pri_val = t.get_int(2);
              break;
      case 30: p.qta_lit = t.get_int(1);p.qta_val = t.get_int(2);
              break;
      case 31: p.imp_lit = t.get_int(1);p.imp_val = t.get_int(2);
              break;
      // add other groups here
      default:
              break;
    }
  }
  _doc->set_decimals(p);
}

TDocVen_Form::~TDocVen_Form() {
  delete _cliente;
  if (_doc) delete _doc;
}

void TDocVen_Form::edit_picture(TForm_item & fi, const int dec)
{
  TString old_picture(20);
  old_picture = fi.picture();
  TString new_picture(20);
  
  if (old_picture.empty())  // picture di default
  {
    new_picture =  ".";     // in lire
    if (dec != 0) new_picture << dec;  // in valuta
  }
  else
  {
    if (dec == 0) return; // 0 non cambia la picture

    TString16 dec_to_add;
    for (int i = 0; i < dec; i++) dec_to_add << "@"; // aggiunge tanti "@" quanti sono i decimali voluti
    new_picture = old_picture;
    if (old_picture.find(',') > 0)
      new_picture << "."; // se ha trovato la virgola come separatore di migliaia significa che deve aggiungere il punto decimale
    else
      new_picture << ","; // altrimenti aggiunge la solita virgola
    new_picture << dec_to_add; // infine aggiunge i decimali richiesti
  }  
  const int w = fi.width();   // se la picture eccede la dimensione, toglie i caratteri piu' a sx
  int exceed = w - new_picture.len();
  if (exceed<0 && w>0)
  {
    exceed=::abs(exceed);
    new_picture = new_picture.mid(exceed,new_picture.len()-exceed);
  }
  fi.set_picture(new_picture); // setta la nuova picture
}

void TDocVen_Form::modify_pictures()
{
  const bool valuta = _doc->in_valuta();
  const char sechar[4] = { 'B', 'F', 'G',  'H' };
  for (int sn = 0; sn < 4 ; sn++) 
  {
    const char sc = sechar[sn];
    for (pagetype pt = odd_page; pt <= last_page; pt = pagetype(pt+1))
    {            
      TPrint_section* sec = exist(sc, pt);
      if (sec != NULL)
        for (word i = 0; i < sec->fields() ; i++)
        {
          TForm_item& fi = sec->field(i);
          const int items = _group_decimals.items(); // numero di gruppi definiti
          for (int j = 0; j < items; j++)
          {
            TToken_string& r = _group_decimals.row(j);
            const int group = r.get_int(0);
            if (fi.in_group(group)) // trova se appartiene al gruppo, modifica la picture
            {
              edit_picture(fi,valuta ? r.get_int(2) : r.get_int(1));
              break; // considera solo il primo gruppo trovato
            }
          }
        }
    }
  }
}

word TDocVen_Form::set_body(word p, bool u) {
  TPrint_section& body = section('B', p);
  return TForm::set_body(p, u);
}

void TDocVen_Form::extended_parse_general(TScanner &scanner) {
  // se viene riconosciuto il token per l'impostazione del modulo legge il codice...
  if (scanner.key() == "MO") _module= scanner.string();

  // Legge i decimali necessari per gli arrotondamenti (il primo per gli importi in lire, l'altro per quelli in valuta)
  if (scanner.key() == "PR") {
    TToken_string t;
    t.add(29);t.add(scanner.integer());t.add(scanner.integer());
    _group_decimals.add(t);
  }
  
  // Stessa cosa per le quantita'
  if (scanner.key() == "QT")
  {
    TToken_string t;
    t.add(30);t.add(scanner.integer());t.add(scanner.integer());
    _group_decimals.add(t);
  } 
  
  // Stessa cosa per gli importi in genere
  if (scanner.key() == "IM") {
    TToken_string t;
    t.add(31);t.add(scanner.integer());t.add(scanner.integer());
    _group_decimals.add(t);
  }

  if (scanner.key() == "NE") {
    TToken_string t;
    t.add(scanner.integer());t.add(scanner.integer());t.add(scanner.integer());
    _group_decimals.add(t);
  }

  // Esclude certi tipi riga e codici articolo
  if (scanner.key() == "EX") {
    TToken_string s(scanner.string(),',');
    _exclude_array.add(s);
  }
}

bool TDocVen_Form::validate(TForm_item &cf, TToken_string &s) {
  const TString code(s.get(0)); // prende il primo parametro, il codice del messaggio
  TString valore;

  if (code== "_ISAMREAD") {
    // lettura generica di un file del database
    // sintassi: _ISAMREAD,<file>,<espressione input>[!<espressione input>!...],{<campo file>|<espressione output>[!<espressione output>!...]}
    // dove: <file> <20> il numero logico del file o il nome della tabella
    //       <espressione input> <20> un'espressione del tipo <campo file>=<espressione campi form>
    //       <espressione campi form> <20> un'espressione di costanti numeriche, stringhe e valori di campi della form (indicati con il loro numero preceduto da #)
    //       <espressione output> <20> un'espressione del tipo <campo form o gruppo>=<campo file> (se <20> un gruppo deve essere seguito da @) oppure solo <campo file> (il campo della form <20> quello corrente)
    int i, j, poseq, posrv, itms;
    pagetype pt;
    char sec;
    TLocalisamfile *file;
    TString f_code(s.get()); // prende il codice del file da leggere
    if (atoi(f_code) != 0) file= new TLocalisamfile(atoi(f_code)); // se il codice <20> numerico allora <20> un file
    else file= new TTable(f_code); // altrimenti <20> una tabella
    file->zero(); // vuota il record corrente del file
    TToken_string in(s.get(), '!');
    for (i=0; i<in.items(); i++) { // scansione sugli elementi dell'input
      TString curr(in.get(i));
      poseq= curr.find("=="); // divide la stringa corrente in lvalue e rvalue
      if (poseq== -1) {
        poseq= curr.find('=');
        if (poseq != -1) posrv= poseq+1;
      } else posrv= poseq+2;
      TString fld(curr.left(poseq)); // preleva il nome del campo del file alla sinistra dell'uguale
      TString expr(curr.mid(posrv)); // preleva l'espressione di assegnamento alla destra dell'uguale
      TExpression rval(expr, _strexpr);
      for (j=0; j<rval.numvar(); j++) { // scansione delle variabili dell'espressione di rvalue
        TString var= rval.varname(j);
        if (var[0]=='#') var.ltrim(1); // rimuove dalla stringa il primo carattere
        TForm_item &fi= cf.find_field(var);
        rval.setvar(j, fi.get()); // il valore corrente del campo viene settato nell'espressione
      }
      file->put(fld, (const char *)rval); // scrive il risultato dell'espressione nel campo del file
    }
    if (file->read()== NOERR) { // tenta una lettura del file
      TToken_string out(s.get(), '!');
      for (i=0; i<out.items(); i++) { // scansione sugli elementi dell'output
        TString curr(out.get(i));
        poseq= curr.find("=="); // divide la stringa corrente in lvalue e rvalue
        if (poseq== -1) {
          poseq= curr.find('=');
          if (poseq != -1) posrv= poseq+1;
        } else posrv= poseq+2;
        if (poseq== -1) {
          const TString &dat= file->get(curr); // preleva il nome del campo del file e lo legge dal record
          cf.set(dat); // setta il campo letto dal file nel campo corrente della form   
          cf.put_paragraph(dat);
          cf.set(""); // Resetta il campo per la prossima stampa di questo item
        } else {
          TString fld(curr.left(poseq)); // preleva il nome del campo del form alla sinistra dell'uguale
          const TString &dat= file->get(curr.mid(posrv)); // preleva il nome del campo del file alla destra dell'uguale e lo legge dal record
          if (fld[0]=='#') fld.ltrim(1);
          if (fld.right(1)== "@") { // se c'<27> la a-commerciale <20> un gruppo
            if (fld.find("->") != -1) { // se nel gruppo c'<27> la freccia si riferisce ad un'altra sezione
              sec= fld[0];
              if (fld[1] != '-') pt= char2page(fld[1]);
              else pt= even_page;
              itms= section(sec, pt).fields();
            } else { // altrimenti si riferisce alla sezione corrente
              sec= cf.section().section_type();
              pt= cf.section().page_type();
              itms= cf.section().fields();
            }
            for (j=0; j<itms; j++) { // per ogni campo della sezione specificata (o sottointesa)...
              TForm_item &fi= section(sec, pt).field(j);
              fi.set(dat); // ...il contenuto viene settato al valore del file
              fi.put_paragraph(dat);
              fi.set(""); // Resetta il campo per la prossima stampa di questo item
            }
          } else {
            TForm_item &fi= cf.find_field(fld);
            fi.set(dat);
            fi.put_paragraph(dat);
            fi.set(""); // Resetta il campo per la prossima stampa di questo item
          }
        }
      }
    }
    delete file;
    return (TRUE);
  } // fine _ISAMREAD

  if (code== "_TABLEREAD") {
    // lettura generica di un campo di una tabella
    // sintassi: _TABLEREAD,<tabella>,<chiave>,<campo file>
    // dove: <tabella> nome tabella da leggere
    //       <chiave> costante stringa o riferimento a campo della form (preceduto da '#') da usare come chiave di ricerca
    //       <campo file> identificativo del campo da leggere dalla tabella
    TTable tab(s.get()); // prende il nome della tabella
    tab.zero(); // vuota il record corrente della tabella
    TString in(s.get()); // prende il valore o il campo da usare come codice di ricerca
    if (in[0]== '#') {
      in.ltrim(1);
      TForm_item &fi= cf.find_field(in);
      in= fi.get();
    }
    tab.put("CODTAB", in); // setta la chiave nella tabella
    if (tab.read()== NOERR) {
      const TString &fld= s.get(); // prende il nome del campo da leggere...
      valore = tab.get(fld);
      cf.set(tab.get(fld)); // ...e lo scrive nel campo del form
      cf.put_paragraph(valore);
      cf.set(""); // Resetta il campo per la prossima stampa di questo item
    }
    return (TRUE);
  } // fine _TABLEREAD
  if (code == "_DESCRIGA") {
    // Messaggio per reperire la descrizione estesa sulle righe del documento
    TLocalisamfile &rdoc= (cursor())->file(LF_RIGHEDOC);
    TString descrizione = rdoc.get("DESCR");
    const bool desclunga = rdoc.get_bool("DESCLUNGA");
    if (desclunga) {
      TTextfile t;  
      rdoc.get_memo("DESCEST",t);
      const long l = t.lines();
      for (long i = 0; i<l; i++) {
        TString linea(t.line(i));
        linea.trim();
        if (linea.not_empty())
          descrizione << " " << linea;
      }
    }
    cf.set(descrizione);
    cf.put_paragraph(descrizione);
    cf.set(""); // Resetta il contenuto del TForm_item(R) per la prossima riga
    cf.section().set_height(cf.effective_height() + 1);
  }
  
  if (code== "_ALIGN") {
    // allineamento della posizione di un campo rispetto ad un altro
    // sintassi: _ALIGN,<campo form>[,<allineamento>][,<allineamento>...]
    // dove: <campo form> <20> il campo della form (preceduto da '#') da cui prendere l'allineamento
    //       <allineamento> <20> uno dei seguenti valori:
    //        TOP    allinea sulla riga d'inizio
    //        MIDDLE allinea al centro (effettivo)
    //        BOTTOM allinea sulla riga di fine (effettiva, non preimpostata)
    //        LEFT   allinea sulla colonna d'inizio
    //        RIGHT  allinea sulla colonna di fine
    TString in(s.get());
    if (in[0]== '#') in.ltrim(1);
    TForm_item &fi= cf.find_field(in);
    const int width = cf.width();    
    valore = cf.get();
    TString clear(width);
    TString picture(cf.picture());
    clear.spaces();
    int i= 2;
    short save_x = cf.x();
    short save_y = cf.y();
    short save_height = cf.height();
    cf.height() = 2; // Solo temporaneamente per far si' che stampi alla giusta posizione
    cf.set(clear);
    cf.put_paragraph(clear);
    while (i<s.items()) { // Calcola la nuova posizione
      TString align(s.get());
      if (align[0]=='!') align.ltrim(1);
      if (align== "TOP") cf.y()= fi.y();
      if (align== "MIDDLE") cf.y()= fi.y()+ fi.effective_height()/2;
      if (align== "BOTTOM") cf.y()= fi.y()+ fi.effective_height()-1;
      if (align== "LEFT") cf.set_x(fi.x());
      if (align== "RIGHT") cf.set_x(fi.x()+ fi.width());
      i++;
    }
    real x(valore);
    if (x.is_real(valore))    // se e' un numero controlla che non sia uguale 0
    {
      if (x != 0.0)
        valore = x.string(picture);
      else 
        valore = "";
    }
    // altrimenti stampa la stringa cosi' com'e'
    cf.set(valore);
    cf.put_paragraph(valore);
    cf.y() = save_y;
    cf.set_x(save_x);
    cf.height() = save_height;
    return (TRUE);
  } // fine _ALIGN
  
  if (code== "_DITTA") {
    // lettura dei dati della ditta
    // sintassi: _DITTA,{<campo relazione>|<macro>}
    // dove: <campo relazione> <20> un riferimento alla relazione di gestione dei dati della ditta (es. 113@->DENCOM <20> la denominazione del comune di residenza della ditta)
    //       <macro> <20> uno delle macro seguenti:
    //         !RAGSOC  ragione sociale
    //         !IND     indirizzo (fiscale se c'<27>, oppure di residenza)
    //         !NUM     numero civico (fiscale se c'<27>, oppure di residenza)
    //         !CAP     CAP (fiscale se c'<27>, oppure di residenza)
    //         !COM     comune (fiscale se c'<27>, oppure di residenza)
    //         !PROV    provincia (fiscale se c'<27>, oppure di residenza)
    //         !IVA     partita iva
    //         !CF      codice fiscale
    //         !TEL     numero di telefono (con prefisso)
    //         !FAX     numero di fax (con prefisso)
    //         !REGSOC  numero di registrazione presso il Tribunale
    //         !CCIAA   numero di registrazione presso la camera di commercio
    // nota: la relazione della ditta <20> cos<6F> strutturata:
    //       %NDITTE (9) Dati ditte
    //       + %ANAGR (6) Anagrafica generale (indirizzo, ecc.)
    //          + %COMUNI (113@) Comune di residenza
    //          + %COMUNI (213@) Comune di residenza fiscale
    TString in(s.get());
    if (in[0]=='!') {
      in.ltrim(1);
      bool _fisc= _firmrel.lfile(6).get("INDRF").not_empty();
      if (in=="RAGSOC") cf.set(_firmrel.lfile().get("RAGSOC"));
      if (in=="IND") {
        if (_fisc) cf.set(_firmrel.lfile(6).get("INDRF"));
        else cf.set(_firmrel.lfile(6).get("INDRES"));
      }
      if (in=="NUM") {
        if (_fisc) cf.set(_firmrel.lfile(6).get("CIVRF"));
        else cf.set(_firmrel.lfile(6).get("CIVRES"));
      }
      if (in=="CAP") {
        if (_fisc) cf.set(_firmrel.lfile(6).get("CAPRF"));
        else cf.set(_firmrel.lfile(6).get("CAPRES"));
      }
      if (in=="COM") {
        if (_fisc) cf.set(_firmrel.lfile(-213).get("DENCOM"));
        else cf.set(_firmrel.lfile(-113).get("DENCOM"));
      }
      if (in=="PROV") {
        if (_fisc) cf.set(_firmrel.lfile(-213).get("PROVCOM"));
        else cf.set(_firmrel.lfile(-113).get("PROVCOM"));
      }
      if (in=="IVA") cf.set(_firmrel.lfile(6).get("PAIV"));
      if (in=="CF") cf.set(_firmrel.lfile(6).get("COFI"));
      if (in=="TEL") {
        TString tel(_firmrel.lfile().get("PTEL"));
        tel << "/" << _firmrel.lfile().get("TEL");
        cf.set(tel);
      }
      if (in=="FAX") {
        TString tel(_firmrel.lfile().get("PFAX"));
        tel << "/" << _firmrel.lfile().get("FAX");
        cf.set(tel);
      }
      if (in=="REGSOC") {
        TString reg(_firmrel[LF_UNLOC].get("REGTRIB"));
        reg << " Vol. " << _firmrel[LF_UNLOC].get("VOLTRIB");
        reg << " Fasc. " << _firmrel[LF_UNLOC].get("FASCTRIB");
        cf.set(reg);
      }
      if (in=="CCIAA") {
        TString cod(_firmrel[LF_UNLOC].get("NUMCCIAA"));
        cod << " del " << _firmrel[LF_UNLOC].get("DATAICCIAA");
        cf.set(cod);
      }
    } else {
      TFieldref fref(s.get(), 0);
      cf.set(fref.read(_firmrel));
    }
    valore = cf.get();
    cf.put_paragraph(valore);
    cf.set(""); // Resetta il campo per la prossima stampa di questo item
    return (TRUE);
  } // fine _DITTA

  if (code== "_CIFRELET") {
    // conversione di un reale da cifre a lettere
    // sintassi: _CIFRELETTERE[,<campo form>]
    // dove: <campo form> <20> il campo della form (preceduto da '#') da cui prendere il valore, se non <20> specificato <20> sottointeso il campo corrente
    // nota: prende il valore del campo specificato e scrive la sua conversione in lettere nel campo corrente
    TString in;
    if (s.items()==2) {
      in= s.get();
      if (in[0]== '#') in.ltrim(1);
      TForm_item &fi= cf.find_field(in);
      in= fi.get();
    } else in= cf.get();
    real n(in);
    valore = n.string("LETTERE");
    cf.set(valore);
    cf.put_paragraph(valore);
    cf.set(""); // Resetta il campo per la prossima stampa di questo item
    return (TRUE);
  } // fine _CIFRELET
  
  if (code.left(6) == "_TOTAL") {
    // totalizzatori di testata/coda, riga e progressione
    // sintassi: _TOTAL_{CODA|RIGA|PROGRES},<totalizzatore>[,<parametri opz>]
    // dove: <totalizzatore> <20> il codice del totalizzatore richiesto
    static real zero("0.0"); // 0 sotto forma di real per i casi in cui il totalizzatore non viene trovato
    if (!_doc->summary_compiled() &&_cli_loaded) _doc->set_condv(_cliente);
    TString tot= s.get(); // prende il codice del totalizzatore richiesto
    TForm_item *fi; // puntatore al campo della form in cui scrivere il valore del totalizzatore
    fi= &cf; // prende il puntatore al campo corrente
    if (code.mid(6) == "_CODA") {
      TString value;
      if (tot == "TOTDOC") value = _doc->tot_documento().string();
      else if (tot == "TIMPNETTI") value = _doc->tot_importi_netti().string();
      else if (tot == "TIMPOSTE") value = _doc->tot_imposte().string();
      else if (tot == "TIMPONIBILI")
      {
        byte sel = atoi(s.get());
        value = _doc->tot_imponibili(sel).string();
      }
      else
        value = _doc->get_head_info(tot);
      if (value.not_empty())
        fi->set(value); // setta il campo della form
      else
        fi->set(zero.string());
    }
    if (code.mid(6) == "_RIGA") {
      TLocalisamfile &rdoc= (cursor())->file(LF_RIGHEDOC);
      TToken_string totriga(rdoc.get("G1"),'\n'); // prende il campo memo con i totalizzatori sotto forma di token string
      TString value;
      const int items = totriga.items();
      for (int i = 0; i<items; i++)
      {
        TToken_string item(totriga.get(),'=');
        if (tot == item.get())
        {
          value = item.get();
          break;
        }
      }
      if (value.not_empty())
        fi->set(value); // setta il campo della form
      else
        fi->set(zero.string());
    }
//    if (code.mid(6) == "_PROGRES") {
//      TString16 tot16(tot);
//      fi->set(_total_prog->get(tot16).string());
//    }

    valore = fi->get();    
    real x(valore);
    TString picture(fi->picture());
    if (x != 0.0)
      valore = x.string(picture); // Riformatta il valore
    else 
      valore = "";
    fi->put_paragraph(valore);
    fi->set(""); // Resetta il campo per la prossima stampa di questo item
    return (TRUE);
  } // fine _TOTAL_xxx
  
  if (code== "_CLIENTE") {
    // lettura dei dati del cliente
    // sintassi: _CLIENTE,{<campo relazione>|<macro>}
    // dove: <campo relazione> <20> un riferimento alla relazione di gestione dei dati del cliente
    //       <macro> <20> uno delle macro seguenti:
    //         !RAGSOC  ragione sociale
    //         !IND     indirizzo
    //         !NUM     numero civico
    //         !INDNUM  indirizzo + numero civico
    //         !LOC     localit<69>
    //         !CAP     CAP
    //         !COM     comune
    //         !PROV    provincia
    //         !IVA     partita iva
    //         !CF      codice fiscale
    //         !PERS    <F> se persona fisica, <G> se giuridica
    //         !DATANAS data di nascita
    //         !COMNAS  comune di nascita
    //         !TEL     primo numero di telefono (con prefisso)
    //         !TEL2    secondo numero di telefono (con prefisso)
    //         !TEL3    terzo numero di telefono (con prefisso)
    //         !FAX     numero di fax (con prefisso)
    // nota: la relazione del cliente <20> cos<6F> strutturata:
    //       CLIFO (20) Clienti/fornitori
    //       + CFVEN (17) Clienti/fornitori per vendite
    //       + %COMUNI (113@) Comune di residenza
    //       + %COMUNI (213@) Comune di nascita
    TLocalisamfile &doc= (cursor())->file(LF_DOC);
    TString16 tipocf= doc.get("TIPOCF"), codcf= doc.get("CODCF"), ocfpi= doc.get("OCFPI");
    if (!_cli_loaded ) { // il cliente <20> sulla testata del documento di vendita, quindi pu<70> essere caricato una volta sola per tutte
      _cliente->load(tipocf[0], atol(codcf), ocfpi);
      _cliente->add(LF_COMUNI, "COM=STATOCF+COMCF", 1, LF_CLIFO, 100+LF_COMUNI);
      _cliente->add(LF_COMUNI, "COM=STATONASC+COMNASC", 1, LF_CLIFO, 200+LF_COMUNI);
      _cli_loaded= TRUE;
    }     
    TString in(s.get()); // prende la macro o il fieldref
    if (in[0]=='!') {
      in.ltrim(1);
      if (in=="RAGSOC") cf.set(_cliente->get(LF_CLIFO, "RAGSOC"));
      if (in=="IND") cf.set(_cliente->get(LF_CLIFO, "INDCF"));
      if (in=="NUM") cf.set(_cliente->get(LF_CLIFO, "CIVCF"));
      if (in=="INDNUM") {
        TString indnum(_cliente->get(LF_CLIFO, "INDCF"));
        indnum << " " << _cliente->get(LF_CLIFO,"CIVCF");
        cf.set(indnum);
      }
      if (in=="LOC") cf.set(_cliente->get(LF_CLIFO, "LOCALITACF"));
      if (in=="CAP") cf.set(_cliente->get(LF_CLIFO, "CAPCF"));
      if (in=="COM") cf.set(_cliente->get(-(100+LF_COMUNI), "DENCOM"));
      if (in=="PROV") cf.set(_cliente->get(-(100+LF_COMUNI), "PROVCOM"));
      if (in=="IVA") cf.set(_cliente->get(LF_CLIFO, "PAIV"));
      if (in=="CF") cf.set(_cliente->get(LF_CLIFO, "COFI"));
      if (in=="PERS") cf.set(_cliente->get(LF_CLIFO, "TIPOPERS"));
      if (in=="DATANAS") cf.set(_cliente->get(LF_CLIFO, "DATANASC"));
      if (in=="COMNAS") cf.set(_cliente->get(-(200+LF_COMUNI), "DENCOM"));
      if (in=="TEL") {
        TString tel(_cliente->get(LF_CLIFO, "PTEL"));
        tel << "/" << _cliente->get(LF_CLIFO, "TEL");
        cf.set(tel);
      }
      if (in=="TEL2") {
        TString tel2(_cliente->get(LF_CLIFO, "PTEL2"));
        tel2 << "/" << _cliente->get(LF_CLIFO, "TEL2");
        cf.set(tel2);
      }
      if (in=="TEL3") {
        TString tel3(_cliente->get(LF_CLIFO, "PTEL3"));
        tel3 << "/" << _cliente->get(LF_CLIFO, "TEL3");
        cf.set(tel3);
      }
      if (in=="FAX") {
        TString fax(_cliente->get(LF_CLIFO, "PFAX"));
        fax << "/" << _cliente->get(LF_CLIFO, "FAX");
        cf.set(fax);
      }
    } else {
      TFieldref fref(s.get(), 0);
      cf.set(fref.read(*_cliente)); // l'oggetto cliente <20> figlio della TRelation, quindi lo passo al fieldref semplicemente con un typecast
    }
    valore = cf.get();
    cf.put_paragraph(valore);
    cf.set(""); // Resetta il campo per la prossima stampa di questo item
    return (TRUE);
  } // fine _CLIENTE

  if (code== "_SCADENZE") {
    // messaggio per stampare le scadenze
    // sintassi: _SCADENZE,<macro>,<cambio codice>
    // dove <macro> e' uno dei seguenti:
    //      DATA    : stampa la data di scadenza 
    //      IMPORTO : stampa l'importo in scadenza
    // dove <cambio codice> vale 0 o 1 se indica di rendere corrente la prossima scadenza
    if (s.items() == 3)
    {
      TString what(s.get());
      TString value(_doc->scadenze_get(what));
      cf.set(value);
        
      real x(value);
      if (x.is_real(value))
      {
        TString picture(cf.picture());
        if (x != 0.0)
          value = x.string(picture); // Riformatta il valore
        else 
          value = "";
      }
      
      what = s.get();
      const bool next = what == "1";
      if (next) _doc->scadenze_set_next();
      cf.put_paragraph(value);
      cf.set(""); // Resetta il campo per la prossima stampa di questo item
    }
  }
  
  if (code== "_RIEPILOGOIVA") {
    // tabella riepilogo aliquote iva e relative imposte
    // sintassi: _RIEPILOGOIVA,<selettore>,<macro>,<cambio codice>
    // dove: <selettore> <20> uno dei seguenti:
    //        1 = codici IVA a regime normale
    //        2 = codici IVA da ventilare
    //        4 = codici IVA esenti
    //        8 = codici IVA non imponibili
    //       16 = codici IVA non soggetti
    //       oppure la combinazione di uno o piu' di essi:
    //       12 = 4+8, 19 = 1+2+16, 29 = 1+4+8+16 ecc...
    // dove: <macro> <20> uno dei seguenti:
    //        COD     colonna dei codici
    //        IMP     colonna degli imponibili
    //        IVA     colonna delle imposte
    //        ALI     colonna delle aliquote
    //        DES     colonna delle descrizioni (stampata solo se il regime IVA non e' normale)
    // dove: <cambio codice> <20> uno dei seguenti:
    //        0        indica di non leggere il successivo codice IVA nella tabella riepilogativa
    //        1        indica di leggere il successivo codice IVA nella tabella riepilogativa

    if (!_doc->summary_compiled() &&_cli_loaded) _doc->set_condv(_cliente);

    if (s.items() == 4)
    {
      byte selector = byte(atoi(s.get())); // il primo parametro e' il selettore del tipo di codice
      if (selector != 0)
      {
        _doc->summary_filter(selector);
                                      
        TString what(s.get()); // cosa deve stampare ?
        TString value(_doc->summary_get(what)); // Piglia il valore dalla riga selezionata sullatabellina
        
        what = s.get();
        const bool next  = what == "1"; // deve cambiare elemento ? 
        if (next) _doc->summary_set_next();
        cf.set(value);
        
        real x(value);
        if (x.is_real(value))
        {
          TString picture(cf.picture());
          if (x != 0.0)
            value = x.string(picture); // Riformatta il valore
          else 
            value = "";
        }
        cf.put_paragraph(value);
        cf.set(""); // Resetta il campo per la prossima stampa di questo item
      }
    }
    else
     error_box("Numero di parametri non corretto in _RIEPILOGOIVA");
    return (TRUE);
  } // fine _RIEPILOGOIVA
  
  // Messaggio per stampare il numero di pagina corrente
  if (code== "_PAGENO") {
    TString16 pg; pg << int(printer().getcurrentpage());
    cf.set(pg); cf.put_paragraph(pg);
    cf.set("");
  }
  return TForm::validate(cf, s); // se il codice del messaggio non <20> identificato viene passato alla funzione standard
}

//////////////////////////////////////////////////////////////////////////////////////////////
// classe TStampa_Doc_Vendita customizzata dalla TApplication per l'applicazione principale
//////////////////////////////////////////////////////////////////////////////////////////////

enum behaviour {
  skip,
  go,
  cancel
};



class TStampa_Doc_Vendita: public TApplication {
  TString _codnum; // codice di numerazione
  TString _provv; // stampa provvisioria
  int _anno; // anno della documentazione
  long _dalnum, _alnum; // estremi di numerazione dei documenti
  TDate _dadata, _adata; // estremi di data dei documenti
  bool _order_by_num; // flag che indica se e' stato selezionato l'ordine principale per numero documento
  bool _interattivo; // flag che indica se il prog. funziona in interattivo o in batch
  bool _definitiva; // flag che indica se la stampa <20> definitiva o no
  TRelation *_firmrel; // puntatore alla relazione che gestisce i dati della ditta corrente
  TDocVen_Form *_form; // puntatore al form di stampa
protected:
  virtual bool create(void);
  virtual bool destroy(void);
  virtual bool menu(MENU_TAG);
  int select(void);
  virtual void print(void);
  virtual void on_firm_change(void);
  virtual behaviour on_module_change(const TString &, TString &); // funzione chiamata ad ogni cambio modulo durante la stampa
  virtual bool query_final_print(void); // funzione chiamata all'inizializzazione per sapere se la stampa <20> definitiva
  static bool date2num_handler(TMask_field& f, KEY key);
  static bool range_handler(TMask_field& f, KEY key);
  static bool filter_rows(const TRelation * r);
};

inline TStampa_Doc_Vendita& app() { return (TStampa_Doc_Vendita&) main_app(); }

bool TStampa_Doc_Vendita::date2num_handler(TMask_field& f, KEY key)
{
  TMask& m = f.mask();
  if (key == K_TAB && f.focusdirty())
  {
    short dlg = f.dlg();
    TLocalisamfile doc(LF_DOC);
    doc.setkey(3);
    TString codnum1(m.get(F_CODNUM)),codnum2;
    TString anno1(m.get(F_ANNO)),anno2;
    TString provv1(m.get(F_PROVV)),provv2;
    TDate   data1(m.get_date(dlg)),data2;
    long numdoc;
    doc.zero(); 
    doc.put("CODNUM", codnum1);
    doc.put("ANNO", anno1);
    doc.put("PROVV", provv1);
    doc.put("DATADOC", data1);
    if (doc.read(_isgteq) == NOERR)
    {
      codnum2 = doc.get("CODNUM");
      anno2 = doc.get("ANNO");
      provv2 = doc.get("PROVV");
      data2 = doc.get_date("DATADOC");
      if (codnum1 == codnum2 && anno1 == anno2 && provv1 == provv2 && data1 == data2)
      {
        numdoc = doc.get_long("NDOC");
        m.set(dlg == F_DA_DATADOC ? F_DA_NDOC : F_A_NDOC, numdoc);
      }
    }
  }
  return TRUE;
}

bool TStampa_Doc_Vendita::range_handler(TMask_field& f, KEY key)
{
  int rt = TRUE;
  TMask& m = f.mask();
  if (key == K_TAB && f.focusdirty())
  {
    const long lim_sup = atol(f.get());
    const long lim_inf = m.get_long(F_DA_NDOC);
    if (lim_sup < lim_inf)
    {
      f.error_box("Il limite superiore deve essere maggiore del limite inferiore");
      rt = FALSE;
    }
  }
  return rt;
}

bool TStampa_Doc_Vendita::filter_rows(const TRelation * r)
{
  TLocalisamfile& righe = r->lfile(LF_RIGHEDOC);
  bool rt = TRUE;
  TString tiporiga(righe.get("TIPORIGA"));
  TString codart(righe.get("CODART"));
  TString_array& a = app()._form->exclude_list();
  const int items = a.items();
  
  for (int i = 0; i < items && rt; i++)
  {
    TToken_string& s=a.row(i);
    TString tr(s.get(0));
    TString ar(s.get(1));
    tr.trim();ar.trim();
    if (tr.empty() && ar == codart) rt = FALSE;
    else if (tr == tiporiga)
      if (ar.empty() || (ar.not_empty() && ar == codart)) rt = FALSE;
  }
  
  return rt;
}

bool TStampa_Doc_Vendita::create() {
  TApplication::create();
  _form = NULL;
  _firmrel= new TRelation(LF_NDITTE); // istanziamento e impostazione della relazione di gestione della ditta corrente
  _firmrel->add(LF_ANAG, "TIPOA=TIPOA|CODANAGR=CODANAGR");
  _firmrel->add(LF_UNLOC,"CODDITTA=CODDITTA"); // si posiziona sulla prima unita' locale della ditta
  _firmrel->add(LF_COMUNI, "COM=STATORES+COMRES", 1, LF_ANAG, 100+LF_COMUNI);
  _firmrel->add(LF_COMUNI, "COM=STATORES+COMRF", 1, LF_ANAG, 200+LF_COMUNI);
  if (argc()>2) { // lettura dei parametri iniziali dalla linea di comando
    _codnum= argv(2); // il primo parametro <20> il codice di numerazione
    _anno= atoi(argv(3)); // il secondo <20> l'anno
    _provv= argv(4); // il terzo <20> il flag di numerazione provvisoria
    _dalnum= atol(argv(5)); // il quarto <20> il numero di documento di partenza
    _alnum= atol(argv(6)); // il quinto <20> il numero di documento di fine
    _definitiva= (strcmp(argv(7), "D")==0); // il sesto <20> se la stampa <20> definitiva (rinumerazione dei documenti)
    _interattivo= FALSE;
    print();
  } else { // oppure lancio della maschera
    _interattivo= TRUE;
    dispatch_e_menu(BAR_ITEM(1));
  }
  return TRUE;
}

bool TStampa_Doc_Vendita::destroy() {
  if (_form) delete _form;
  delete _firmrel; // distruzione della relazione di gestione della ditta corrente
  return TApplication::destroy();
}

void TStampa_Doc_Vendita::on_firm_change() {
  TLocalisamfile &firmfile= _firmrel->lfile();
  firmfile.put("CODDITTA", get_firm());
  _firmrel->read();
}

int TStampa_Doc_Vendita::select() {
  TMask m("ve1100a");
  TString wdate;
  m.set_handler(F_DA_DATADOC, date2num_handler);
  m.set_handler(F_A_DATADOC, date2num_handler);
  m.set_handler(F_A_NDOC, range_handler);
  if (m.run() == K_ENTER) {
    _codnum= m.get(F_CODNUM); // lettura dei dati dalla maschera
    _anno= m.get_int(F_ANNO);
    _provv= m.get(F_PROVV);
    _dalnum= m.get_long(F_DA_NDOC);
    _alnum= m.get_long(F_A_NDOC);
    if (_alnum == 0) _alnum = 9999999L;
    wdate = m.get(F_DA_DATADOC);
    if (wdate.not_empty()) _dadata = wdate;
    else _dadata = botime;
    wdate = m.get(F_A_DATADOC);
    if (wdate.not_empty()) _adata = wdate;
    else _adata = eotime; 
    _order_by_num = m.get(F_DATA_O_NUM) == "N";
    return 1;
  } else return 0; // 0 indica che non si <20> usciti con "Conferma" dalla maschera
}

bool TStampa_Doc_Vendita::menu(MENU_TAG) { // procedura di dispatch dei menu
  int s;
  while ((s= select()) != 0) if (s==1) print(); // se la selezione della maschera ritorna 1 viene lanciata la stampa
  return FALSE;
}

void TStampa_Doc_Vendita::print() {
  TFilename nomeform, profilo; // istanzia le stringhe per il nome del form di stampa e del profilo di configurazione
  TString modulo_prec;  // istanzia la stringa per l'inseguimento del modulo di carta
  TTable tip("%TIP"); // istanzia la tabella dei tipi di documento per i profili
  TRelation rel(LF_DOC); // istanzia la relazione sul file principale
  TCursor cur(&rel); // crea il cursore principale dalla relazione
  if (!_order_by_num) cur.setkey(3); // setta l'ordine per data.
  TLocalisamfile &doc= cur.file(); // prende il riferimento al file principale
  doc.zero(); // vuota il record del file 
  doc.put("CODNUM", _codnum); // compone la chiave per il record di inizio cursore
  doc.put("ANNO", _anno);
  doc.put("PROVV", _provv);
  doc.put("NDOC", _dalnum);
  if (!_order_by_num) doc.put("DATADOC", _dadata);
  doc.read(); // posiziona il file sul record
  TRectype darec= doc.curr(); // copia il record di inizio cursore
  doc.zero(); // vuota il record del file 
  doc.put("CODNUM", _codnum); // compone la chiave per il record di fine cursore
  doc.put("ANNO", _anno);
  doc.put("PROVV", _provv);
  doc.put("NDOC", _alnum);
  if (!_order_by_num) doc.put("DATADOC", _adata);
  doc.read(); // posiziona il file sul record
  const long num_lim_sup = doc.get_int("NDOC");
  const TDate date_lim_sup = doc.get_date("DATADOC");
  if (num_lim_sup > _alnum || (!_order_by_num && date_lim_sup < _adata))
  {
    error_box("Non vi sono documenti da stampare nell'intervallo indicato");
    return;
  }
  _definitiva= query_final_print(); // legge il flag di stampa definitiva
  printer().open(); // apre la stampante
  TRectype arec= doc.curr(); // copia il record di fine cursore
  cur.setregion(darec, arec); // imposta il filtro sul cursore di stampa (nell'ordine giusto :-)
  for (cur= 0; cur.pos()<cur.items(); ++cur) { // ciclo sugli elementi del cursore di stampa
    tip.put("CODTAB", doc.get("TIPODOC")); // posiziona la tabella dei tipi di documento
    int err=tip.read(); // legge la tabella
    if (err==NOERR) { // se non ci sono errori procede con la stampa
      nomeform= tip.get("S5"); // legge il nome del form di stampa
      profilo= tip.get("S4"); // legge il nome del profilo di configurazione
      profilo.ext("ini"); // aggiunge l'estensione al nome del file del profilo
      if (profilo.empty() || nomeform.empty()) {
        error_box("Nome profilo o form di stampa non valido nella tabella TIP");
        break;
      }
      TConfig config(profilo, "STAMPA"); // apre il file di configurazione del profilo
      TToken_string stati((const char*)config.get("STATIVALIDI"), ','); // legge gli stati validi di questo tipo di documento
      if (_definitiva && (stati.get_pos(doc.get("STATO"))== -1)) { // se lo stato del doc. corrente non <20> valido...
        if (_interattivo) error_box("Non <20> possibile stampare un documento con stato non valido"); // ...viene mostrato un messaggio (solo in modo interattivo)...
        break; // ...e la stampa viene interrotta
      }
      behaviour whattodo= go; // istanzia la variabile di comportamento

      TDocumentoEsteso * doc_est = new TDocumentoEsteso(cur.curr()); // istanzia TDocumentoEsteso sulla testata attuale
      
      _form = new TDocVen_Form(nomeform, *_firmrel, doc_est); // istanzia il form, passandogli il documento. (la delete del documento e' nel ditruttore
      const TString &modulo= _form->get_module_code(); // legge dal form il codice del modulo di carta per la stampa
      if (modulo_prec.empty()) modulo_prec= modulo; // se siamo al primo passaggio la variabile di modulo precedente viene riempita
      if (modulo != modulo_prec) whattodo= on_module_change(modulo, modulo_prec); // se il modulo <20> cambiato dalla stampa precedente interroga la funzione per sapere che comportamento tenere
      if (whattodo==cancel)   break; // se non si pu<70> procedere la stampa viene interrotta
      else if (whattodo==go) { // altrimenti prosegue
        TCursor &fcur= *(_form->cursor()); // ricava il riferimento al cursore originale del form
        TLocalisamfile &rdoc= fcur.file(LF_RIGHEDOC); // ricava il riferimento al file principale del cursore del form
        TRectype darec_r(rdoc.curr());  // istanzia il record di filtro per il cursore
        darec_r.zero(); // vuota il record
        darec_r.put("CODNUM", _codnum); // compone la chiave parziale per il filtro sul cursore dal file principale del cursore di selezione dei documenti
        darec_r.put("ANNO", _anno);
        darec_r.put("PROVV", _provv);
        darec_r.put("NDOC", doc.get("NDOC"));
        TRectype arec_r(darec_r); // istanzia il secondo record per il filtro sul cursore
        fcur.setregion(darec_r, arec_r); // setta il filtro sul cursore del form
        fcur.set_filterfunction(filter_rows); // setta il filtro per escludere alcuni tipi riga indicati nel form
        _form->print(); // stampa il form corrente
        if (_definitiva && (numerazione_definitiva(doc) != NOERR)) { // se la stampa <20> definitiva viene lanciata la procedura di rinumerazione
          if (_interattivo) error_box("Non <20> possibile completare la procedura di numerazione definitiva dei documenti");
          break;
        }
      }
      if (_form)
      {
        delete _form; 
        _form = NULL;
      }
    } else {
      error_box("Il documento corrente non <20> stato trovato nella tabella dei tipi di documento (errore %d)", err);
      break;
    }
  }
  if (_form)
  {
    delete _form; 
    _form = NULL;
  }
  printer().close(); // chiude la stampante
}

behaviour TStampa_Doc_Vendita::on_module_change(const TString &modulo, TString &modulo_prec) {
  if (!_interattivo) return skip; // se siamo in interattivo il documento viene saltato...
  else { // ...altrimenti viene chiesto all'utente il da farsi
    int risp= yesnocancel_box("Il modulo di carta <20> cambiato: inserisci il modulo '%s' e premi 'S<>' per continuare, 'No' per saltare il documento o 'Cancel' per interrompere la stampa", modulo);
    behaviour ret;
    switch (risp) {
      case K_YES:
        modulo_prec= modulo; // aggiorna l'inseguitore dei moduli
        ret= go; // la stampa pu<70> continuare
        break;
      case K_NO:
        ret= skip; // il documento viene saltato
        break;
      case K_ESC:
        ret= cancel; // la stampa viene interrotta
        break;
    }
    return ret;
  }
}

bool TStampa_Doc_Vendita::query_final_print() {
  if (_interattivo) { // se siamo in interattivo viene richiesto all'utente se la stampa <20> definitiva o meno
    if (yesno_box("E' una stampa definitiva?")) return TRUE;
    else return FALSE;
  } else return _definitiva; // altrimenti ritorna il valore letto dalla linea di comando
}



int ve1100(int argc, char* argv[]) {
  TStampa_Doc_Vendita a;
  a.run(argc, argv, "Stampa documenti di vendita");
  return (0);
}