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 <progind.h>

#include <doc.h>
#include <rdoc.h>

#include "ve1100.h"
#include "ve0100b.h"
#include "velib.h"
#include "sconti.h"

#define LISTADOC  "listadoc"
#define Usage "Usage: ve1 -0 {[codnum anno {D|P} dalnum alnum {D|P} [ncopie]] | [L]}"

// Queste classi (TDocisamfile e TRDocisamfile) servono nel costruttore di TDocumento_form
// in modo da sostituire i file della relazione, ovvero LF_DOC e LF_RIGHEDOC.
// Facendo in questo modo ogni get() del record, viene reindirizzata alla get() dei
// TVariable_recfield, in modo da utilizzare nel form le istruzioni FIELD anche per i campi
// virtuali.

class TDocisamfile : public TLocalisamfile
{
  TDocumentoEsteso *_doc;
public:
  virtual TRectype& curr() const { return (TRectype&) *_doc; }
  virtual int readat(TRecnotype nrec, word lockop = _nolock);
  TDocisamfile(TDocumentoEsteso* doc)  : TLocalisamfile(LF_DOC) { _doc = doc;}
  virtual ~TDocisamfile() {};
};

int TDocisamfile::readat(TRecnotype nrec, word lockop)
{
  int err = TBaseisamfile::readat(nrec, _nolock);
  if (err == NOERR)
    if ((err=_doc->read(curr())) == NOERR)
    {
      _doc->summary_reset(TRUE); // forza il ricalcolo perche' trattasi di documento diverso
      _doc->summary_filter(1);
    }
  return err;
  //return err == NOERR ?  _doc->read(curr()) : err;
}
class TRDocisamfile : public TLocalisamfile
{
  TDocumento *_doc;
  int _row;
protected:
  TDocumento& doc() const { return *_doc;}  
public:
  virtual TRectype& curr() const {return (TRectype&) doc()[_row>0 ? _row : 1];}
  void set_row(int r) { _row = r;}
  TRDocisamfile(TDocumento* doc) : TLocalisamfile(LF_RIGHEDOC)  { _doc = doc; _row = 1;}
  virtual ~TRDocisamfile() {};
};

////////////////////////////////////////////////////////////////////////////
// classe TDocumento_form customizzata dalla Form per i documenti 
////////////////////////////////////////////////////////////////////////////
class TDocumento_form : public TForm 
{ 

  static TDocumento_form* _form;
  TDocisamfile* _docfile;
  TRDocisamfile* _rdocfile;
  TLocalisamfile *_tab;
  TTable *_tip;
  TRelation &_firmrel; // relazione di gestione dei dati della ditta corrente
  TString _module; // codice del modulo di carta associato a questo al form
  TCond_vendita * _condv;
  TString_array _exclude_array; // array di coppie tipo/articolo da escludere dalla stampa
  TDocumentoEsteso * _doc; // Documento da stampare
  int  _final_status;      // stato finale del documento
  bool _valid, _cli_loaded; // flag che indica se il form e' valido | se l'oggetto cliente <20> gi<67> stato caricato
  bool _is_lista;           // flag che indica se il form e' usato per la stampa della lista documenti
  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
  void edit_picture(TForm_item & f, const int dec);
  void modify_pictures();
  bool print_on_body(int r); // Trascrive la riga 'r' del documento sul body. Ritorna TRUE se va stampata, FALSE se va saltata
  
  void print_header(TPrinter& p); // Stampa la testata
  void print_footer(TPrinter& p); // Stampa la pedata

  static void doc_header_handler(TPrinter& p);
  static void doc_footer_handler(TPrinter& p);

public:
  void print_documento();
  bool valid() { return _valid; }
  bool doc_arrange();
  const int final_status() { return _final_status; }
  int ncopie() { return _doc->tipo().ncopie(); }
  const TString &get_module_code() { return _module; } // ritorna il codice del modulo di carta
  TString_array & exclude_list()   { return _exclude_array; }
  TDocumentoEsteso& doc() { return *_doc; }
  TDocumento_form(TRectype&/*TDocumentoEsteso **/ doc, TRelation& rel, const bool definitiva, const bool interattivo);
  TDocumento_form(const char* form, TRelation& rel);
  virtual ~TDocumento_form();
};

TDocumento_form* TDocumento_form::_form = NULL;

TDocumento_form::TDocumento_form(TRectype&/*TDocumentoEsteso**/ doc, TRelation& rel, const bool definitiva, const bool interattivo): TForm(), _firmrel(rel), _valid(FALSE) 
{
  _form = this;
  
  //_doc = doc;
  _tip = new TTable("%TIP");
  _tab = new TLocalisamfile(LF_TAB);
  TString nomeform;
  TFilename profilo;
  TString codnum(doc.get(DOC_CODNUM));
  TString numdoc(doc.get(DOC_NDOC));
  
  _tip->put("CODTAB", doc.get(DOC_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");
      return;
    }
    TConfig config(profilo, "STAMPA"); // apre il file di configurazione del profilo
    _final_status = config.get_int("STATOFINALE");
    TToken_string stati((const char*)config.get("STATIVALIDI"), ','); // legge gli stati validi di questo tipo di documento
    if (definitiva && (stati.get_pos(doc.get(DOC_STATO))== -1))
      // se lo stato del doc. corrente non <20> valido...
      if (interattivo)
      {
        error_box("Non <20> possibile stampare il documento %s %s con stato non valido", (const char*) codnum, (const char*) numdoc); // ...viene mostrato un messaggio (solo in modo interattivo)...
        return;
      }
  }
  else
  {
    error_box("Il documento %s %s non <20> stato trovato nella tabella dei tipi di documento (errore %d)",
              (const char*) codnum,(const char*) numdoc,err);
    return;
  }
  _valid = TRUE;

  
  read(nomeform);
  _cli_loaded= FALSE;
  _is_lista = FALSE;
  _condv = new TCond_vendita(NULL);
  _doc =  new TDocumentoEsteso(doc, _condv); // istanzia TDocumentoEsteso
  _condv->set_clifo(&_doc->clifor());
  _docfile = new TDocisamfile(_doc);
  _rdocfile = new TRDocisamfile(_doc);
  relation()->replace(_docfile,0);
  relation()->replace(_rdocfile,1);
  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);

  TPrinter& pr = printer();
  
  pr.setheaderhandler(doc_header_handler);
  TPrint_section& head = section('H');
  pr.headerlen(head.height());
  
  pr.setfooterhandler(doc_footer_handler);
  const TPrint_section& foot = section('F');
  pr.footerlen(foot.height());
}

// costruttore per stampa lista documenti (uso convenzionale dei forms)
TDocumento_form::TDocumento_form(const char* form, TRelation& rel): TForm(form), _firmrel(rel), _valid(FALSE) 
{
  _is_lista = TRUE;
  _rdocfile=NULL;
  _tip = new TTable("%TIP");
  _tab = new TLocalisamfile(LF_TAB);
  _cli_loaded= FALSE;
  _doc = new TDocumentoEsteso;
  _docfile = new TDocisamfile(_doc);
  relation()->replace(_docfile,0);
}

TDocumento_form::~TDocumento_form()
{
  //if (_doc) delete _doc;
  if (_tip) delete _tip;
  if (_tab) delete _tab;
  if (_docfile) delete _docfile;
  if (_rdocfile) delete _rdocfile;
}

bool TDocumento_form::doc_arrange()
{
  TPrinter& pr = printer();
  
  if (char_to_pos() != '\0' || (ipx()+ipy()+fpx()) != 0)
  {
    if (offset_x() != 0 || offset_y() != 0)
    {
      error_box("Non e' possibile settare contemporaneamente gli offset"
                " e i parametri di posizionamento del modulo %s.", (const char*)name());
      return FALSE;
    }
    else
      if (pr.printtype() == winprinter) 
        _form->arrange_form();
  }
  else
    pr.set_offset(_form->offset_x(),_form->offset_y());
  return TRUE;
}

void TDocumento_form::print_documento()
{
  // stampa tutte le righe 
  TPrint_section& body = section('B');
  TPrint_section& foot = section('F');
  TPrinter& pr = printer();

  
  const int righe = _doc->rows();
  
  set_last_page(FALSE); // E' importante settare questo flag, per evitare "Falli di Piede" eheh :-)
  for (int r=1; r<=righe; r++)
  {
    _rdocfile->set_row(r);
    if (pr.rows_left() <= (body.height()+1))   // salto pagina
      pr.formfeed();
    
    if (!print_on_body(r)) continue;
    
    const word h = body.height();
    for (word j = 0; j < h; j++)
      pr.print(body.row(j));
  }
  
  set_last_page(TRUE); // Cosi' stampera' l'ultima pagina del footer
  pr.formfeed();      
  // Rimette ad 1 il numero della pagina
  pr.setcurrentpage(1);
}

void TDocumento_form::print_header(TPrinter& pr)
{
  TPrint_section& head = section('H');

  head.update(); 

  const word r = head.height()-1;
  
  for (word j = 0; j <= r; j++)
    pr.setheaderline(j, head.row(j));
}


void TDocumento_form::print_footer(TPrinter& pr)
{
  const bool p = _form->page(pr)>0;
  TPrint_section& foot = section('F',p ? odd_page : last_page);

  foot.update();
  const word r = foot.height()-1;
  
  for (word j = 0; j <= r; j++)
    pr.setfooterline(j, foot.row(j));

}

void TDocumento_form::doc_header_handler(TPrinter& pr)
{
  pr.resetheader();
  _form->print_header(pr);    
}

void TDocumento_form::doc_footer_handler(TPrinter& pr)
{                    
  pr.resetfooter();
  _form->print_footer(pr);
} 

void TDocumento_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 TDocumento_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
            }
          }
        }
    }
  }
}

bool TDocumento_form::print_on_body(int r)
{
  TPrint_section& body = section('B');
  
  TRiga_documento& riga = doc()[r];

  TString tiporiga(riga.get(RDOC_TIPORIGA));
  TString codart(riga.get(RDOC_CODART));
  const int items = _exclude_array.items();
  bool ok = TRUE;
  
  for (int i = 0; i < items && ok; i++)
  {
    TToken_string& s=_exclude_array.row(i);
    TString tr(s.get(0));
    TString ar(s.get(1));
    tr.trim();ar.trim();
    if (tr.empty() && ar.empty()) continue;
    if (tr.empty() && ar == codart) ok = FALSE;
    else if (tr == tiporiga)
      if (ar.empty() || (ar.not_empty() && ar == codart)) ok = FALSE;
  }  
  
  if (ok)
    body.update(); // Crea la vera riga di stampa, eventuali allineamenti avverranno nella validate(), come al solito.
  
  return ok;
}

void TDocumento_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 TDocumento_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.put_paragraph(dat);
        } 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.put_paragraph(dat);
            }
          } else {
            TForm_item &fi= cf.find_field(fld);
            fi.put_paragraph(dat);
          }
        }
      }
    }
    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.put_paragraph(valore);
    }
    return (TRUE);
  } // fine _TABLEREAD
  
  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") 
        valore = _firmrel.lfile().get("RAGSOC");
      if (in=="IND") {
        if (_fisc) 
          valore = _firmrel.lfile(6).get("INDRF");
        else 
          valore = _firmrel.lfile(6).get("INDRES");
      }
      if (in=="NUM") {
        if (_fisc)
          valore = _firmrel.lfile(6).get("CIVRF");
        else 
          valore = _firmrel.lfile(6).get("CIVRES");
      }
      if (in=="CAP") {
        if (_fisc) 
          valore = _firmrel.lfile(6).get("CAPRF");
        else 
          valore  = _firmrel.lfile(6).get("CAPRES");
      }
      if (in=="COM") {
        if (_fisc)
          valore = _firmrel.lfile(-213).get("DENCOM");
        else 
          valore = _firmrel.lfile(-113).get("DENCOM");
      }
      if (in=="PROV") {
        if (_fisc)
          valore = _firmrel.lfile(-213).get("PROVCOM");
        else 
          valore = _firmrel.lfile(-113).get("PROVCOM");
      }
      if (in=="IVA")
        valore = _firmrel.lfile(6).get("PAIV");
      if (in=="CF") 
        _firmrel.lfile(6).get("COFI");
      if (in=="TEL") {
        valore = _firmrel.lfile().get("PTEL");
        valore << "/" << _firmrel.lfile().get("TEL");
      }
      if (in=="FAX") {
        valore = _firmrel.lfile().get("PFAX");
        valore << "/" << _firmrel.lfile().get("FAX");
      }
      if (in=="REGSOC") {
        valore = _firmrel[LF_UNLOC].get("REGTRIB");
        valore << " Vol. " << _firmrel[LF_UNLOC].get("VOLTRIB");
        valore << " Fasc. " << _firmrel[LF_UNLOC].get("FASCTRIB");
      }
      if (in=="CCIAA") {
        valore = _firmrel[LF_UNLOC].get("NUMCCIAA");
        valore << " del " << _firmrel[LF_UNLOC].get("DATAICCIAA");
      }
    } else {
      TFieldref fref(s.get(), 0);
      valore = fref.read(_firmrel);
    }
    cf.put_paragraph(valore);
    return (TRUE);
  } // fine _DITTA

  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)
    TCli_for & cli_for = _doc->clifor();
    TString in(s.get()); // prende la macro o il fieldref
    if (in[0] != '!')
      valore = cli_for.get(s.get()); 
    else
    {
      in.ltrim(1);
      if (in=="INDNUM")
      {
        valore = cli_for.get(CLI_INDCF);
        valore << " " << cli_for.get(CLI_CIVCF);
      }                                    
      else
        if (in.find("COM") == 0)
        {
          in.ltrim(3);
          TLocalisamfile com(LF_COMUNI);
          const bool nascita = in[0] == 'N';
          if (nascita)
          {
            in.ltrim(3);
            com.put("STATO", cli_for.get(CLI_STATOCF));
            com.put("COM", cli_for.get(CLI_COMCF));
          }
          else
          {
            in.ltrim(2);
            com.put("STATO", cli_for.get(CLI_STATONASC));
            com.put("COM", cli_for.get(CLI_COMNASC));
          } 
          if (com.read() == NOERR)
            valore = com.get(in);
        }
        else
         if (in.find("TEL") == 0)
         { 
           if (in.len() == 3)
             in << "1";           
           const TString num(cli_for.get(in));
           in.insert("P");
           valore = cli_for.get(in);
           valore << "/" << num;
         }
        else
        if (in=="FAX")
        {
          valore = cli_for.get("PFAX");
          valore << "/" << cli_for.get("FAX");
        }
        else
          if (in=="RAGSOC") 
          {
            valore = cli_for.get(in);
            valore.strip_d_spaces();
          }
    }
    cf.put_paragraph(valore);
    return (TRUE);
  } // fine _CLIENTE

  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)
    {
      const TString & s = rdoc.get("DESCEST");
    
      descrizione << s;
    }
    cf.put_paragraph(descrizione);
    // Setta l'altezza effettiva del body, per evitare sprechi di righe
    cf.section().set_height(cf.effective_height());
  }

  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

  // Messaggio per stampare il numero di pagina corrente
  if (code== "_PAGENO")
  {
    TString16 pg; pg << int(printer().getcurrentpage() );
    cf.put_paragraph(pg);
  } 
  
  // Messaggio per stampare la data di oggi
  if (code== "_DATA")
  {
    TString16 pg(TDate(TODAY).string());
    cf.put_paragraph(pg);
  } 
  
  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 (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();
        
        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);
      }
    }
    else
     error_box("Numero di parametri non corretto in _RIEPILOGOIVA");
    return (TRUE);
  } // fine _RIEPILOGOIVA
  
  if (code == "_TOTIMPONIBILI")
  {
    // sintassi: _TOTIMPONIBILI,<selettore>
    // dove: <selettore> funge da filtro per la somma degli imponibili
    // se selettore vale 0 restituisce il tot. imponibili con le spese
    // vedi _RIEPILOGOIVA per la spiegazione dei filtri selettivi
    byte sel = atoi(s.get());
    real x = sel == 0 ? _doc->imponibile(TRUE): _doc->tot_imponibili(sel);

    TString picture(cf.picture());
    if (x != 0.0)
      valore = x.string(picture); // Riformatta il valore
    else 
      valore = "";
    cf.put_paragraph(valore);
    return (TRUE);
  } // fine _TOTIMPONIBILI

  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));
        
      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);
    }
  }

  return TForm::validate(cf, s); // se il codice del messaggio non <20> identificato viene passato alla funzione standard
}

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

    
enum behaviour
{
  skip,
  go,
  cancel
};

// Chiavi di ordinamento LF_DOC:
// Chiave 1: ordinamento per Provvisorio + Anno + Codice numerazione + Numero documento
// Chiave 3: ordinamento per Data documento + Provvisorio + Anno + Codice numerazione + Numero documento

#define BY_NUM_KEY   1
#define BY_DATE_KEY  3


class TStampaDoc_application: public TApplication
{
  TString _codnum; // codice di numerazione
  char _provv; // stampa documenti provvisiori o definitivi (D o P)
  int _anno; // anno della documentazione
  int _key;  // chiave per scorrere i documenti (1 o 3, vedi sopra)
  int _ncopie; // numero di copie per ogni documento
  long _dalnum, _alnum; // estremi di numerazione dei documenti
  TDate _dadata, _adata; // estremi di data dei documenti
  bool _interattivo; // flag che indica se il prog. funziona in interattivo o in batch
  bool _is_lista;    // flga che indica se e' stata selezionata la lista documenti
  bool _definitiva; // flag che indica se la stampa <20> definitiva o no
  TRelation *_firmrel; // puntatore alla relazione che gestisce i dati della ditta corrente
  TDocumento_form *_form; // puntatore al form di stampa
protected:
  virtual bool create();
  virtual bool destroy();
  virtual bool menu(MENU_TAG);
  bool select(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);
public:
  TDocumento_form& form() { return *_form; }
  void print_documento();
  void print_selected();   
  TStampaDoc_application() : _key(BY_NUM_KEY) {};
  virtual ~TStampaDoc_application() {};
};


void TStampaDoc_application::print_selected()
{
  TRelation rel(LF_DOC);
  rel.add(LF_RIGHEDOC,"CODNUM==CODNUM|ANNO==ANNO|PROVV==PROVV|NDOC==NDOC");
  TCursor cur(&rel);
  TLocalisamfile& doc = cur.file();
  cur.setkey(_key);
  TRectype darec(LF_DOC),arec(LF_DOC); // Estremi filtro
  TString modulo_prec;
  const bool order_by_num = _key == BY_NUM_KEY;
  
  doc.put(DOC_CODNUM, _codnum); // compone la chiave per il record di inizio cursore
  doc.put(DOC_ANNO, _anno);
  doc.put(DOC_PROVV, _provv);
  doc.put(DOC_NDOC, _dalnum);
  if (!order_by_num) doc.put(DOC_DATADOC, _dadata);
  doc.setkey(_key);
  doc.read(); // trova il record iniziale
  darec = doc.curr();
  doc.put(DOC_NDOC, _alnum);
  if (!order_by_num) doc.put(DOC_DATADOC, _adata);
  int err = doc.read(); // trova il record finale
  if (err == _iseof) doc.last();
  else if (err == _iskeynotfound) doc.prev();
  arec = doc.curr();
  
  if (arec < darec)
  {
    error_box("Non vi sono documenti da stampare nell'intervallo indicato");
    return;
  }
  if (!_is_lista) _definitiva= query_final_print(); // legge il flag di stampa definitiva

  TPrinter& pr =  printer();
  pr.open();

  TProgind* pi = pr.printtype() != screenvis ? 
                   new TProgind(cur.items(),"Stampa documenti in corso...",FALSE,TRUE,10) :
                   NULL;
  if (!_is_lista)
  {
    cur.setregion(darec, arec);
    const long items = cur.items();
    behaviour whattodo = go;
    bool first_inst = TRUE;
    //TDocumentoEsteso  *documento = new TDocumentoEsteso;
    //cur.file().set_curr(documento);
    for (long i = 0; i < items; i++)
    {
      cur = i; // Posiziona il documento
      _form  = new TDocumento_form(cur.curr()/*documento*/, *_firmrel, _definitiva, _interattivo); // Istanzia il form
      
      if (!_form->valid()) break; // interrompe la stampa se il doc corrente non e' tra i tipi validi
      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
      else first_inst = FALSE;
      const bool module_changed = modulo != modulo_prec;
      if (first_inst || module_changed)
        if (!_form->doc_arrange())  // Setta l'offset o posiziona manualmente
          break; // Se vi sono errori interrompe la stampa
      if (module_changed) 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
      if (whattodo==skip) continue; // Salta il documento corrente
      // altrimenti prosegue
  
      // Carica il numero di copie da stampare per questo form
      int ncopie  = _ncopie == 0 ? _form->ncopie() : _ncopie; // Numero di copie da stampare per questo documento
      if (ncopie == 0) ncopie = 1;
      
      for (int n=0; n < ncopie; n++)
      {
        print_documento();
        _form->doc().summary_reset();
        _form->doc().scadenze_reset();
      }
      if (_definitiva && (numerazione_definitiva(doc,_form->final_status()) != 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;
      }
      delete _form;
    }
    
    // Non viene fatta la delete documento perche' gia' presente nella distruzione del cursore, avendo fatto una set_curr()
  }
  else // Lista documenti
  {
    _form = new TDocumento_form(LISTADOC,*_firmrel);
    _form->cursor()->setregion(darec,arec);
    _form->print();
    delete _form;
  }
  
  if (pi != NULL) delete pi;
  printer().close();
}

void TStampaDoc_application::print_documento()
{
  CHECK(_form,"Nessun form istanziato!");
  TDocumento_form& f = form();
  TLocalisamfile& doc = f.cursor()->file();
  const bool is_vis = printer().printtype() == screenvis;
  if (!is_vis)
  {
    TString status("Documento: ");
    status << doc.get(DOC_CODNUM);
    status << '\\' << doc.get(DOC_NDOC);
    xvt_statbar_set(status);
  }
  f.print_documento();
  
  if (!is_vis)
    xvt_statbar_set(NULL);
}

behaviour TStampaDoc_application::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 TStampaDoc_application::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
}

bool TStampaDoc_application::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 TStampaDoc_application::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 TStampaDoc_application::create()
{
  TApplication::create();
  _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);
  const int argc = TApplication::argc();
  
  _is_lista = argc == 3 && argv(2)[0] == 'L';
  if (argc>3)
  { // 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)[0]; // il terzo <20> il flag di numerazione provvisoria
    _dalnum= atol(argv(5)); // il quarto <20> il numero di documento di partenza
    _alnum = _dalnum;
    _definitiva = FALSE;
    _ncopie = 1;
    _interattivo= FALSE;
    if (argc > 6)
    {
      _alnum= atol(argv(6)); // il quinto <20> il numero di documento di fine
      if (argc > 7)
      {
        _definitiva= (strcmp(argv(7), "D")==0); // il sesto <20> se la stampa <20> definitiva (rinumerazione dei documenti)
        if (argc > 8)
          _ncopie = atoi(argv(8));
      }
      else _interattivo = TRUE;
    }  
    print_selected(); 
    return FALSE;
  }
  else
  {
    if (argc == 2 || _is_lista)
    { // oppure lancio della maschera
      _interattivo= TRUE;
      dispatch_e_menu(BAR_ITEM(1));
    }
    else              
      return error_box(Usage);
  }
  return TRUE;
}

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

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

bool TStampaDoc_application::select()
{
  TMask m("ve1100a");
  
  if (_is_lista)
  {
    m.hide(F_NCOPIE);
    m.set_caption("Lista Documenti");
  }
  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)[0];
    _dalnum= m.get_long(F_DA_NDOC);
    _alnum= m.get_long(F_A_NDOC);
    _ncopie = m.get_int(F_NCOPIE);
    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; 
    _key = BY_NUM_KEY;
    if (m.get(F_DATA_O_NUM) != "N") _key = BY_DATE_KEY;
    return TRUE;
  } else return FALSE;
}

bool TStampaDoc_application::menu(MENU_TAG)
{
  while (select()) print_selected(); 
  return FALSE;
}

// Do all the work!
int ve1100(int argc, char** argv)
{
  
  TStampaDoc_application a;
  const bool cond = argc == 4 && argv[2][0] == 'L'; // List documenti
  a.run(argc, argv, cond ? "Lista documenti" : "Stampa documenti di vendita");
  return (0);
}