#include <automask.h>
#include <colors.h>
#include <controls.h>
#include <dongle.h>
#include <execp.h>
#include <printer.h>
#include <relapp.h>
#include <utility.h>

#include "../ca/calib01.h"
#include "../mg/mglib.h"
#include "../ve/velib.h"

#include "pe1400.h"
#include "pe1401.h"
#include "pe1500.h"

#include "../db/rdist.h"
#include "../mg/anamag.h"
#include "../ca/commesse.h"

static real ricarico2perc(const TString& exp)
{
  real val_perc = UNO;
  
  if (exp.full())
  {
    TString80 num;
    bool dec = false;      // Flag che indica se si attende l'inizio di un numero
    bool startnum = true;  // Flag che indica se siamo all'inizio di un numero   
    int errorchar =  ' ';
    bool valid = true;   
    // Flag che indica se sono nella parte decimale di un numero
    for (const char* s  = exp; *s  && errorchar == ' '; s++)
    { 
      const char c = *s;
      switch(c)
      {
      case '+': 
      case '-':
        // Se ero in in numero ...
        if( !startnum )
        {
          // Aggiunge il numero alla sequenza
          const real val = num;
          val_perc *= ( CENTO + val ) / CENTO;
        }
        // Inizia il nuovo numero
        num = (c == '-') ? "-" : "+";  
        startnum = true;
        dec = false;
        break;         
      case '0':  
      case '1':
      case '2':
      case '3':
      case '4':
      case '5':
      case '6':
      case '7':
      case '8':
      case '9':
        num << c;
        startnum = false;
        break;
      case '.':
      case ',':
        if(!dec)
        {
          if( startnum )
            num << '0';        // Se occorreva un numero ci metto lo 0
          num << '.';          // Interpreto la virgola come punto
          dec = true;       
          startnum = true;
        }
        else
          errorchar = c;        // Se siamo già nella parte decimale segnala un errore
        break;
      case ' ':
        break;
      default:
        errorchar = c;
        break;         
      }
    }
    // Controlla la validità
    valid = errorchar == ' ';
    
    if (valid)
    {
      // Aggiunge l'ultimo numero preso
      const real val = num; 
      val_perc *= ( CENTO + val ) / CENTO;
    }
  }
  
  return val_perc;
}

///////////////////////////////////////////////////////////
// TPreventivo_app
///////////////////////////////////////////////////////////

class TPreventivo_app : public TRelation_application
{
  TMask* _qmsk;
  TMask* _emsk;
  TRelation* _rel;
  bool _revisioning;
  TString8 _codelab;

protected:
  int save_rows(const TMask& m);
  virtual const char* extra_modules() const { return "ci"; }
  bool save_and_print(TPrtype mode);


public:
  virtual bool user_create();
  virtual bool user_destroy();
  virtual bool changing_mask(int mode) { return !(_revisioning && mode == MODE_INS); }
  virtual TMask* get_mask(int mode) { return mode == MODE_QUERY ? _qmsk : _emsk; }
  virtual TRelation* get_relation() const { return _rel; }
  virtual bool get_next_key(TToken_string& key);
  virtual bool has_filtered_cursor() const { return true; }
  virtual TCursor& get_filtered_cursor() const;

  virtual void init_insert_mode(TMask& m);
  virtual void init_modify_mode(TMask& m);
  virtual const char* record_description(const TRelation& rel) const;

  virtual int read(TMask& m);
  virtual int write(const TMask& m);
  virtual int rewrite(const TMask& m);
  virtual bool remove();

  virtual void print();
  virtual void preview();

  void update_tools(TMask& m);
  bool set_elab_code(const TString& cod) { _codelab = cod; return cod.full(); }
};

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

///////////////////////////////////////////////////////////
// TPreventivo_nmsk
///////////////////////////////////////////////////////////

class TPreventivo_nmsk : public TAutomask
{
  TString4 _codnum;

protected:
  virtual bool on_field_event(TOperable_field& o, TField_event e, long jolly);

public:
  TPreventivo_nmsk(const TString& codnum);
};

bool TPreventivo_nmsk::on_field_event(TOperable_field& o, TField_event e, long jolly)
{
  switch(o.dlg())
  {
  case F_ANNO:
    if (e == fe_modify && !o.empty())
      on_field_event(efield(F_NDOC), fe_init, 0L);
    break;
  case F_NDOC:
    if (e == fe_init)
    {
      long n = 1;
      TString query;
      query << "USE DOC"
            << "\nFROM PROVV=D ANNO=#ANNO CODNUM=#CODNUM"
            << "\nTO   PROVV=D ANNO=#ANNO CODNUM=#CODNUM";
      TISAM_recordset recset(query);
      recset.set_var("#ANNO", get(F_ANNO));
      recset.set_var("#CODNUM", _codnum);
      if (recset.move_last())
      {
        const TCodice_numerazione& num = cached_numerazione(_codnum);
        const int revlen = num.revision_len();
        TString8 ndoc = recset.get(DOC_NDOC).as_string();
        if (revlen > 0) ndoc.rtrim(revlen);
        n += atol(ndoc);
      }
      o.set(n);
    } else
    if (e == fe_modify || e == fe_close)
    {
      TString8 ndoc;
      const TCodice_numerazione& num = cached_numerazione(_codnum);
      const int revlen = num.revision_len();
      if (revlen > 0)
        ndoc.format("%d%0*d", atoi(o.get()), revlen, 1);
      else
        ndoc = o.get();

      TLocalisamfile doc(LF_DOC);
      doc.put(DOC_PROVV, "D");
      doc.put(DOC_ANNO, get(F_ANNO));
      doc.put(DOC_CODNUM, _codnum);
      doc.put(DOC_NDOC, ndoc);
      if (doc.read() == NOERR)
        return error_box("Preventivo già esistente");
    }
    break;
  default:
    break;
  }
  return true;
}

TPreventivo_nmsk::TPreventivo_nmsk(const TString& codnum) : TAutomask(TR("Nuovo preventivo"), 1, 30, 6), _codnum(codnum)
{
  const TCodice_numerazione& num = cached_numerazione(_codnum);
  const int revlen = num.revision_len();
  add_number(F_NDOC, 0, PR("Codice "), 13, 1, 7-revlen).check_type(CHECK_REQUIRED);
  add_number(F_ANNO, 0, PR("Anno "), 1, 1, 4, "A").check_type(CHECK_REQUIRED);
  add_button(DLG_OK,     0, "", -12, -1, 9, 2);
  add_button(DLG_CANCEL, 0, "", -22, -1, 9, 2);
  set_handlers();
}

///////////////////////////////////////////////////////////
// TPreventivo_msk
///////////////////////////////////////////////////////////

// Classe di base per maschere preventivi (query ed edit)
class TPreventivo_msk : public TAutomask
{
protected:
  virtual bool on_field_event(TOperable_field& o, TField_event e, long jolly);
  virtual TMask_field* parse_field(TScanner& s);

public:
  int revision_length() const;
  int split_ndoc(long ndoc, int& nprev, int& nrev) const;
  int join_ndoc(int nprev, int nrev, long& ndoc) const;
  
  TPreventivo_msk(const char* name) { read_mask(name, 0, 8); set_handlers(); }
};

TMask_field* TPreventivo_msk::parse_field(TScanner& s)
{
  if (s.key() == "TL")
    set_full_screen_interface(page_win(1), true);
  return TAutomask::parse_field(s);
}

int TPreventivo_msk::revision_length() const
{
  int rl = 0;
  const TString& codnum = get(F_CODNUM);
  if (codnum.full())
  {
    const TCodice_numerazione& num = cached_numerazione(codnum);
    rl = num.revision_len();
  }
  return rl;
}

int TPreventivo_msk::split_ndoc(long ndoc, int& nprev, int& nrev) const
{
  nprev = nrev = 0;
  const int revlen = revision_length();
  if (revlen > 0)
  {
    TString8 sdoc; sdoc << ndoc;
    if (sdoc.len() > revlen)
    {
      nrev  = atoi(sdoc.right(revlen));
      nprev = atoi(sdoc.rtrim(revlen));
    }
  }
  else
    nprev = ndoc;

  return revlen;
}

int TPreventivo_msk::join_ndoc(int nprev, int nrev, long& ndoc) const
{
  ndoc = 0L;
  const int revlen = revision_length();
  if (revlen > 0)
  {
    ndoc = nprev;
    for (int i = 0; i < revlen; i++)
      ndoc *= 10;
    ndoc += nrev > 0 ? nrev : 1;
  }
  else
    ndoc = nprev;
  
  return revlen;
}


bool TPreventivo_msk::on_field_event(TOperable_field& o, TField_event e, long jolly)
{
  switch (o.dlg())
  {
  case F_CODNUM:
    if (e == fe_init || e == fe_modify)
    {
      if (o.empty())
      {
        TCursor& c = *((TEdit_field&)o).browse()->cursor();
        c = 0L;
        o.set(c.curr().get("CODTAB"));
        o.check();
      }

      int revlen = 0;
      if (!o.empty())
      {
        const TCodice_numerazione& num = cached_numerazione(o.get());
        revlen = num.revision_len();
        set(F_TIPODOC, num.tipo_doc(0), 0x3);
      }
      if (revlen > 0)
      {
        RCT rct;

        TEdit_field& prv = efield(F_NPREV);
        prv.set_len(7-revlen);
        prv.get_rect(rct);
        rct.right = rct.left + CHARX * (8-revlen);
        prv.set_rect(rct);

        TEdit_field& rev = efield(F_NREV);
        rev.set_len(revlen);
        rev.get_rect(rct);
        rct.right = rct.left + CHARX * (revlen+1);
        rev.set_rect(rct);
        
        show(F_NREV);
      }
      else 
        hide(F_NREV);
    }
    break;
  case F_NDOC:
    if (!o.empty() && (e == fe_init || e == fe_modify))
    {
      const long ndoc = atol(o.get());
      int nprev = 0, nrev = 0;
      const int revlen = split_ndoc(ndoc, nprev, nrev);
      set(F_NPREV, nprev);
      set(F_NREV, nrev);
      if (revlen == 0)
        reset(F_NPREV);
    }
    break;
  default: 
    if ((e == fe_modify || e == fe_close) && (!o.empty() && o.is_edit()))
    {
      const TFieldref* fr = o.field();
      if (fr != NULL && fr->name() == RDOC_CODCMS)
      {
        TRelation rel(LF_RIGHEDOC);
        o.mask().autosave(rel);
        const TString& cms = rel.curr().get(RDOC_CODCMS);
        const TRectype& rec = cache().get(LF_COMMESSE, cms);
        if (rec.get_bool(COMMESSE_CHIUSA))
          return error_box(FR("Impossibile utilizzare la commesa chiusa %s"), (const char*)cms);
      }
    }
    break;
  }
  return true;
}

///////////////////////////////////////////////////////////
// TPreventivo_qmsk
///////////////////////////////////////////////////////////

class TPreventivo_qmsk : public TPreventivo_msk
{
protected:
  virtual bool on_field_event(TOperable_field& o, TField_event e, long jolly);
public:
  TPreventivo_qmsk() : TPreventivo_msk("pe1400a") {}
};

bool TPreventivo_qmsk::on_field_event(TOperable_field& o, TField_event e, long jolly)
{
  return TPreventivo_msk::on_field_event(o, e, jolly);
}

///////////////////////////////////////////////////////////
// TPreventivo_emsk
///////////////////////////////////////////////////////////

class TPreventivo_emsk : public TPreventivo_msk
{
  TPreventivo_tree* _tree;
  TString _idfase, _iddist;
  int _edit_dist, _edit_dett, _edit_misu;
  int _curr_dist, _curr_dett, _curr_misu;
  bool _locked, _has_db;

private:
  bool on_fasi_button(TOperable_field& btn, TField_event e, long jolly);
  bool on_fasi_event(TTree_field& s, TField_event e, long jolly);
  bool set_fase(const TString& idf);
  bool set_dist(const TString& idd);
  bool set_dist(int row);

  void update_dist(const real& val, int column);
  void update_dist_qta();
  void update_dist_costo();

  bool on_dett_event(TOperable_field& o, TField_event e, long jolly);
  bool on_misu_event(TOperable_field& o, TField_event e, long jolly);
  bool on_dist_event(TOperable_field& o, TField_event e, long jolly);

  real get_costo(const TString& codart, TString& um, TString& iva) const;

protected:
  virtual bool on_key(KEY k);
  virtual bool on_field_event(TOperable_field& o, TField_event e, long jolly);
  void set_sheet_color(short id, COLOR col);
  bool sync_tree();
  bool msk2rec(const TMask& msk, TRectype& rec) const;

public:
  TPreventivo_tree& tree(bool reset = false);

  TPreventivo_emsk();
};

TPreventivo_tree& TPreventivo_emsk::tree(bool reset)
{
  if (_tree == NULL)
  {
    _tree = new TPreventivo_tree(tfield(F_FASI));
    reset = true;
  }
  if (reset)
  {
    TRectype doc(LF_DOC);
    doc.put(DOC_PROVV,  'D');
    doc.put(DOC_ANNO,   get(F_ANNO));
    doc.put(DOC_CODNUM, get(F_CODNUM));
    doc.put(DOC_NDOC,   get(F_NDOC));
    _tree->append_row(doc);
    TTree_field& tf = tfield(F_FASI);
    tf.set_tree(_tree);
    tf.hide_leaves();
  }
  return *_tree;
}

static bool set_and_check(TMask_field& f, const TRectype& rec)
{
  const TFieldref* fr = f.field();
  if (fr == NULL)
  {
    if (f.ghost())
      return f.on_hit();
    return false;
  }

  if (fr->name() == RDOC_DESCR)
  {
    TString descr(255);
    descr = rec.get(RDOC_DESCR);
    if (rec.get_bool(RDOC_DESCLUNGA))
      descr << rec.get(RDOC_DESCEST);
    f.set(descr);
  }
  else
  {
    f.set(fr->read(rec));
    if (!f.empty() && f.is_edit() && f.shown())  
    {
      const TBrowse* b = ((TEdit_field&)f).browse();
      if (b != NULL)
      {
        const TFixed_string of = b->get_output_fields();
        if (of.find('|') > 0) // C'è un pipe nell'output, per cui ci sono almeno due campi di output
          f.check(STARTING_CHECK);
      }
    }
  }
  return true;
}


// Riempie gli sheet di articoli e misure della distinta selezionata
bool TPreventivo_emsk::set_dist(const TString& idd)
{
  TPreventivo_tree& t = tree();

  bool ok = idd.full();
  if (_iddist != idd)
  {
    _iddist = idd;

    // Svuota sheet articoli
    TSheet_field& a = sfield(F_ARTICOLI);
    a.hide();
    a.destroy();

    // Svuota sheet misure
    TSheet_field& m = sfield(F_MISURE);
    m.hide();
    m.destroy();

    // Scandisce i figli della distinta e li smista tra i due sheet
    ok = idd.full() && t.goto_node(idd);
    if (ok)
    {
      _locked = true;  // Diabilita ricalcolo prezzi
      int n = 0;
      for (bool ok = t.goto_firstson(); ok; ok = t.goto_rbrother())
      {
        const TRectype& rec = *t.curr_row();
        TSheet_field& s = rec.get(RDOC_TIPORIGA) == t.tipo_dett() ? a : m;
        TMask& m = s.sheet_row_mask(n);
        FOR_EACH_MASK_FIELD(m, i, f)
          set_and_check(*f, rec);
        s.update_row(n++);
      }
      _locked = false;
    }

    // Visualizza nuovamente i due sheet eventualemente riempiti
    a.force_update(); a.show();
    m.force_update(); m.show();
  }

  _curr_dist = -1;
  if (ok && t.goto_node(idd))
  {
    _curr_dist = 0;  
    while(t.goto_lbrother())
      _curr_dist++;
  }

  return ok;
}

bool TPreventivo_emsk::set_dist(int row)
{
  TPreventivo_tree& t = tree();
  bool ok = _idfase.full() && t.dist(_idfase, row) != NULL;
  if (ok)
  {
    TString16 idd; t.curr_id(idd);
    ok = set_dist(idd);
    CHECK(ok && row == _curr_dist, "Distinta sospetta");
  }
  return ok;
}

// Riempie lo sheet delle distinte della fase selezionata
bool TPreventivo_emsk::set_fase(const TString& idfase)
{
  _idfase = idfase;

  // Svuota lo sheet delle distinte
  TSheet_field& d = sfield(F_DISTINTE);
  d.destroy();

  TString idd;
  TPreventivo_tree& t = tree();
  bool ok = idfase.full() && t.goto_node(idfase);
  if (ok)
  {
    // Scandisce le distinte della fase corrente
    if (t.goto_firstson())
    {
      t.curr_id(idd); // Memorizza la prima distinta per dopo...
      int n = 0;
      do
      {
        const TRectype& rec = *t.curr_row();
        TMask& m = d.sheet_row_mask(n);
        FOR_EACH_MASK_FIELD(m, i, f)
          set_and_check(*f, rec);
        d.update_row(n++);
      } while (t.goto_rbrother());
    }
  }
  d.force_update();
  set_dist(idd);
  
  return ok;
}

bool TPreventivo_emsk::msk2rec(const TMask& msk, TRectype& rec) const
{
  TRelation rel(rec.num());
  rel.curr() = rec;
  msk.autosave(rel);
  rec = rel.curr();
  const TString& desc = msk.get(RDOC_DESCR);
  const int maxlen = rec.length(RDOC_DESCR);
  int spc = desc.find('\n');
  if (spc >= 0 || desc.len() > maxlen)
  {
    if (spc < 0 || spc > maxlen)
    {
      spc = desc.left(maxlen).rfind(' ');
      if (spc < maxlen/2)
        spc = maxlen;
    }
    rec.put(RDOC_DESCR, desc.left(spc));
    rec.put(RDOC_DESCLUNGA, "X");
    rec.put(RDOC_DESCEST, desc.mid(spc));
  }
  else
  {
    rec.put(RDOC_DESCR, desc);
    rec.zero(RDOC_DESCLUNGA);
    rec.put(RDOC_DESCEST, "");
  }
  return !rec.empty();
}

bool TPreventivo_emsk::on_key(KEY k)
{
  if (k == K_SHIFT + K_F12)
  {
    enable(F_STATO);
    return true;
  }
  return TAutomask::on_key(k);
}

bool TPreventivo_emsk::on_fasi_button(TOperable_field& o, TField_event e, long jolly)
{
  TPreventivo_tree& t = tree();
  TTree_field& fasi = t.owner();

  TPreventivo_level pl = pl_documento;
  if (fasi.goto_selected())
    pl = t.level();
  else
    return false;

  if (pl == pl_documento && o.dlg() == F_FASENEW)
    pl = pl_fase1;

  if (pl < pl_fase1 || pl > pl_distinta)
    return false;

  o.disable();
  switch (o.dlg())
  {
  case F_FASENEW:
    {
      TMask m("Nuovo", 1, 46, 7);
      m.add_string(S_CODART, 0, "Codice      ", 1, 1, 20).check_type(CHECK_REQUIRED);
      m.add_string(S_DESCR,  0, "Descrizione ", 1, 2, 50, "", 30).check_type(CHECK_REQUIRED);
      m.add_button(DLG_OK,     0, "", -12, -1, 10, 2);
      m.add_button(DLG_CANCEL, 0, "", -22, -1, 10, 2);
      if (m.run() == K_ENTER)
      {
        TRectype* rec = t.new_row(pl);
        rec->put(RDOC_CODART, m.get(S_CODART));
        rec->put(RDOC_DESCR, m.get(S_DESCR));
        if (tree().level() == pl)
          t.add_rbrother(rec);
        else
        {
          t.append_row(*rec);
          delete rec;
        }
      }
    }
    break;
  case F_FASEDIT:
    {
      TRectype& rec = *t.curr_row();
      TMask m("Modifica", 1, 46, 7);
      m.add_string(S_CODART, 0, "Codice      ", 1, 1, 20).check_type(CHECK_REQUIRED);
      m.add_string(S_DESCR,  0, "Descrizione ", 1, 2, 50, "", 30).check_type(CHECK_REQUIRED);
      m.add_button(DLG_OK,     0, "", -13, -1, 10, 2);
      m.add_button(DLG_DELREC, 0, "", -23, -1, 10, 2);
      m.add_button(DLG_CANCEL, 0, "", -33, -1, 10, 2);
      m.set(S_CODART, rec.get(RDOC_CODART));
      m.set(S_DESCR, rec.get(RDOC_DESCR));
      switch (m.run())
      {
      case K_ENTER:
        rec.put(RDOC_CODART, m.get(S_CODART));
        rec.put(RDOC_DESCR,  m.get(S_DESCR));
        break;
      case K_DEL:
        t.kill_node();
        break;
      default:
        break;
      }
    }
    break;
  case F_FASEUP:
    t.swap_left();
    if (pl == pl_distinta)
    {
      TString16 id; t.curr_id(id);
      set_fase(_idfase);
      t.goto_node(id);
    }
    break;
  case F_FASEDN:
    t.swap_right();
    if (pl == pl_distinta)
    {
      TString16 id; t.curr_id(id);
      set_fase(_idfase);
      t.goto_node(id);
    }
    break;
  case F_FASELT:
    if (pl > pl_fase1 && pl < pl_distinta && t.push_up())
      t.curr_row()->put(RPRV_LEVEL, t.curr_depth()-1);
    break;
  case F_FASERT:
    if (pl >= pl_fase1 && pl < t.last_fase_level() && t.push_down())
      t.curr_row()->put(RPRV_LEVEL, t.curr_depth()-1);
    break;
  default:
    break;
  }
  o.enable();
  fasi.select_current();
  fasi.force_update();
  return true;
}

bool TPreventivo_emsk::on_fasi_event(TTree_field& fasi, TField_event e, long jolly)
{
  bool modified = false;
  bool can_edit = false;
  bool can_goup = false;
  bool can_godn = false;
  bool can_golt = false;
  bool can_gort = false;

  switch (e)
  {
  case fe_modify:
    if (fasi.goto_selected())
    {
      modified = true;
      TPreventivo_tree& t = tree();
      TPreventivo_level td = t.level();
      if (td > pl_documento)
      {
        can_edit = true;
        can_goup = t.has_lbrother();
        can_godn = t.has_rbrother();
        if (td >= pl_fase1 && td < pl_distinta) // Cambio fase
        {
          can_golt  = td > pl_fase1;
          can_gort  = td < t.last_fase_level();
          TString16 id; 
          t.curr_id(id);
          set_fase(id);
        }
        else
        {
          while (td > pl_distinta)
          {
            t.goto_father();
            td = t.level();
          }
          TString idd; t.curr_id(idd);
          if (t.goto_father())
          {
            TString idf; t.curr_id(idf);
            if (idf != _idfase)
              set_fase(idf);
          }
          set_dist(idd);
        }
      }
    }
    break;
  default:
    break;
  }

  if (modified)
  {
    enable(F_FASEDIT, can_edit);
    enable(F_FASEUP,  can_goup);
    enable(F_FASEDN,  can_godn);
    enable(F_FASELT,  can_golt);
    enable(F_FASERT,  can_gort);
  }

  return true;
}

bool TPreventivo_emsk::on_dist_event(TOperable_field& o, TField_event e, long jolly)
{
  switch (o.dlg())
  {
  case D_CODDIS:
  case D_CODART:
    if (e == fe_modify && !o.empty())
    {
      const TString& codart = o.get();
      TRecord_array rdist(codart, LF_RDIST);
      if (rdist.rows() > 0 && sfield(F_ARTICOLI).empty())
      {
        TPreventivo_tree& t = tree();
        while (t.dett(_iddist, 0))
          t.kill_node();
        const int last = rdist.last_row();
        int n = 0;
        for (int r = rdist.first_row(); r > 0 && r <= last; r = rdist.succ_row(r))
        {
          const TRectype& rd = rdist.row(r);
          const TCodice_articolo codart = rd.get(RDIST_CODCOMP);
          TString80 desc = rd.get(RDIST_DESCR);
          if (desc.empty())
            desc = cache().get(LF_ANAMAG, codart, ANAMAG_DESCR);

          TRectype* rec = t.dett(_iddist, n++, true);
          rec->put(RDOC_CODART, codart);
          rec->put(RDOC_DESCR,  desc);
          rec->put(RDOC_UMQTA,  rd.get(RDIST_UM));
          rec->put(RDOC_QTA,    rd.get(RDIST_EXPR));
        }
        t.goto_node(_iddist);
        sync_tree();
        // Forza aggiornamento dello sheet
        const TString16 id = _iddist;
        _iddist.cut(0);
        set_dist(id);
      }

      TString4 um, iva;
      const real costo = get_costo(codart, um, iva);
      TMask& m = o.mask();
      m.set(D_UM, um);
      m.set(D_COSTO, costo, 0x3);
    }
    break;
  case D_COSTO:
    if (e == fe_modify && !o.empty())
    {
      const TString& ric = get(F_RICARICO);
      if (ric.full())
      {
        TMask& m = o.mask();
        const real k = ricarico2perc(ric);
  		  const real prezzo = real(o.get()) * k;
        m.set(o.dlg()+1, prezzo);
      }
    }
    break;
  case F_DISTINTE:
    switch (e)
    {
    case se_enter:
      _edit_dist = -1;
      set_dist(_curr_dist = jolly);
      break;
    case se_query_add:
      return _idfase.full();
    case se_notify_add:
      {
        TPreventivo_tree& t = tree();
        TRectype* rec = t.dist(_idfase, _curr_dist = jolly, true);
        if (rec != NULL)
          sync_tree();
      }
      break;
    case se_query_modify:
      if (jolly != _curr_dist)
        set_dist(jolly);
      _edit_dist = _curr_dist = jolly;
      break;
    case se_leave:
    case se_notify_modify:
      if (_edit_dist >= 0)
      {
        const int r = _edit_dist; // Memorizza numero riga corrente
        _edit_dist = -1;          // Annulla numero riga corrente
        TRectype* rec = tree().dist(_idfase, r, true);
        if (rec != NULL)
        {
          const TMask& m = ((TSheet_field&)o).sheet_row_mask(r);
          msk2rec(m, *rec);
          sync_tree();
        }
      }
      break;
    case se_notify_del:
      if (_curr_dist >= 0)
      {
        TPreventivo_tree& t = tree();
        TRectype* rec = t.dist(_idfase, _curr_dist);
        if (rec != NULL)
        {
          t.kill_node();
          sync_tree();
        }
      }
      break;
    default: break;
    }
    break;
  default: break;
  }
  return true;
}

real TPreventivo_emsk::get_costo(const TString& codart, TString& um, TString& iva) const
{
  real costo = ZERO;
  const int tc = get_int(F_TIPOCOSTO);
  const TArticolo_giacenza& art = cached_article_balances(codart);
  TEsercizi_contabili esc;
  const int annoes = esc.date2esc(get_date(F_DATADOC));
	switch (tc)
	{
	case 1 : costo = art.ultimo_costo(annoes); break;
	case 2 : costo = art.media_costi(annoes); break;
	case 4 : costo = art.costo_standard(annoes); break;
	case 5 : costo = art.costo_medio(annoes, "", ""); break;
	case 6 : costo = art.costo_mediopond(annoes, "", ""); break;
	default: break;
	}
  if (costo.is_zero())
    costo = art.get_real(ANAMAG_COSTSTD);

  um = art.um().row(1).get(UMART_UM);
  iva = art.get(ANAMAG_CODIVA);

  return costo;
}

bool TPreventivo_emsk::on_dett_event(TOperable_field& o, TField_event e, long jolly)
{
  switch (o.dlg())
  {
  case S_CODART:
    if (e == fe_modify && !o.empty() && !_locked)
    {
      const TString& codart = o.get();
      TString4 um, iva;
      const real costo = get_costo(codart, um, iva);
      TMask& m = o.mask();
      if (um.full())
        m.set(S_UMART, um, 0x3);
      if (iva.full() && m.get(S_CODIVA).blank())
        m.set(S_CODIVA, iva, 0x3);
      if (!costo.is_zero())
        m.set(S_COSTO, costo, 0x3);
    }
    break;
  case F_ARTICOLI:
    switch (e)
    {
    case se_query_add:
      return _iddist.full();
    case se_notify_add:
      {
        TPreventivo_tree& t = tree();
        TRectype* rec = t.dett(_iddist, _curr_dett = jolly, true);
        if (rec != NULL)
          sync_tree();
      }
      break;
    case se_enter:
      _edit_dett = -1;
      _curr_dett = jolly;
      break;
    case se_query_modify:
      _edit_dett = _curr_dett = jolly;
      break;
    case se_leave:
    case se_notify_modify:
      if (_edit_dett >= 0)
      {
        const int r = _edit_dett;
        _edit_dett = -1;
        TPreventivo_tree& t = tree();
        TRectype* rec = t.dett(_iddist, r, true);
        if (rec != NULL)
        {
          const TMask& m = ((TSheet_field&)o).sheet_row_mask(r);
          msk2rec(m, *rec);
          sync_tree();
          update_dist_costo();
        }
      }
      break;
    case se_notify_del:
      if (_curr_dett >= 0)
      {
        TPreventivo_tree& t = tree();
        TRectype* rec = t.dett(_iddist, _curr_dett);
        if (rec != NULL)
        {
          t.kill_node();
          update_dist_costo();
          sync_tree();
        }
      }
      break;
    default: break;
    }
    break;
  default:
    break;
  }
  return true;
}

bool TPreventivo_emsk::on_misu_event(TOperable_field& o, TField_event e, long jolly)
{
  switch (o.dlg())
  {
  case 102:
  case 103:
  case 104:
  case 105:
    if (e == fe_modify && _curr_misu >= 0 && _curr_dist >= 0)
    {
      TSheet_field& misure = *o.mask().get_sheet();
      TEdit_field& tot = o.mask().efield(106);
      tot.validate(K_TAB);
      misure.row(_curr_misu).add(tot.get(), 5);
      update_dist_qta();
    }
    break;
  case F_MISURE:
    switch (e)
    {
    case se_query_add:
      return _iddist.full();
    case se_notify_add:
      tree().misu(_iddist, _edit_misu = jolly, true);
      break;
    case se_enter:
      _edit_misu = -1;
      _curr_misu = jolly;
      break;
    case se_query_modify:
      _edit_misu = _curr_misu = jolly;
      break;
    case se_leave:
    case se_notify_modify:
      if (_iddist.full() && _edit_misu >= 0)
      {
        TPreventivo_tree& t = tree();
        TRectype* rec = t.misu(_iddist, _edit_misu, true);
        if (rec != NULL)
        {
          TSheet_field& sheet = ((TSheet_field&)o);
          const TMask& m = sheet.sheet_row_mask(_edit_misu);
          msk2rec(m, *rec);
          update_dist_qta();
        }
        _edit_misu = -1;
      }
      break;
    case se_notify_del:
      if (_curr_misu >= 0)
      {
        TPreventivo_tree& t = tree();
        TRectype* rec = t.misu(_iddist, _curr_misu);
        if (rec != NULL)
        {
          t.kill_node();
          update_dist_qta();
        }
      }
      break;
    default: break;
    }
  default:
    break;
  }
  return true;
}

void TPreventivo_emsk::update_dist(const real& val, int column)
{
  TSheet_field& dist = sfield(F_DISTINTE);
  dist.row(_curr_dist).add(val.string(), column);
  dist.update_mask(_curr_dist);
  TOperable_field& o = dist.sheet_row_mask(_curr_dist).efield(105);
  on_dist_event(o, fe_modify, 1);
  dist.force_update(_curr_dist);
  TRectype* rec = tree().dist(_idfase, _curr_dist);
  if (rec)
    msk2rec(dist.sheet_row_mask(_curr_dist), *rec);
}

void TPreventivo_emsk::update_dist_costo()
{
  if (_curr_dist >= 0)
  {
    TSheet_field& sheet = sfield(F_ARTICOLI);
    real costo, prezzo;
    FOR_EACH_SHEET_ROW(sheet, i, row)
    {
      const real q = row->get(3);
      const real c = row->get();
      const real p = row->get();
      costo  += q*c;
      prezzo += q*p;
    }
    if (!costo.is_zero())
      update_dist(costo, 4);
    if (!prezzo.is_zero())
      update_dist(prezzo, 5);
  }
}

void TPreventivo_emsk::update_dist_qta()
{
  if (_curr_dist >= 0)
  {
    TSheet_field& sheet = sfield(F_MISURE);
    real tot;
    FOR_EACH_SHEET_ROW(sheet, i, row)
      tot += real(row->get(5));  
    update_dist(tot, 3);
  }
}

bool TPreventivo_emsk::sync_tree()
{
  TPreventivo_tree& t = tree();
  TTree_field& tf = t.owner();
  tf.force_update();
  return true;
}

static bool ricarica(TTree& tree, void* jolly, word)
{
  const TPreventivo_tree& t = (const TPreventivo_tree&)tree;
  if (t.level() == pl_distinta)
  {
    TRectype* rec = t.curr_row();
    const real cos = rec->get(RPRV_COSTO);
    const real k = *(real*)jolly;
    rec->put(RDOC_PREZZO, cos * k);
  }
  return false;
}

bool TPreventivo_emsk::on_field_event(TOperable_field& o, TField_event e, long jolly)
{
  switch (o.dlg())
  {
  case F_STATO:
    if ((e == fe_init || e == fe_close) && o.empty())
      o.set("1");
    if (e == fe_modify && !o.empty())
      app().update_tools(*this);
    break;
  case F_FASI:
    return on_fasi_event((TTree_field&)o, e, jolly);
  case F_FASENEW:
  case F_FASEDIT:
  case F_FASEDEL:
  case F_FASEUP:
  case F_FASEDN:
  case F_FASERT:
  case F_FASELT:
    if (e == fe_button)
      return on_fasi_button(o, e, jolly);
    break;
  case F_DISTINTE:
    return on_dist_event(o, e, jolly);
  case F_ARTICOLI:
    return on_dett_event(o, e, jolly);
  case F_MISURE:
    return on_misu_event(o, e, jolly);
  case DLG_COPY:
    if (e == fe_button && edit_mode())
    {
      TPreventivo_nmsk m(get(F_CODNUM));
      if (m.run() == K_ENTER)
      {
        const TDate datadoc(TODAY);
        const int nprev = m.get_int(F_NDOC);
        const int nrev = 1;
        long ndoc = 0; join_ndoc(nprev, nrev, ndoc);
        set(F_NPREV, nprev);
        set(F_NREV, nrev);
        set(F_NDOC, ndoc);
        set(F_STATO, 1);
        set(F_DATADOC, datadoc);
        set(F_ANNO, m.get_int(F_ANNO));
        set_mode(MODE_INS);
        stop_run(K_SAVE);
      }
      return true;
    }
    break;
  case DLG_PRINT:
    if (e == fe_button)
      main_app().print();
    break;
  case DLG_PREVIEW:
    if (e == fe_button)
      main_app().preview();
    break;
  case DLG_ELABORA:
    if (e == fe_button)
    {
      const TString& cod = pe_trova_elaborazione(*this, 'O');
      if (cod.full())
      {
        TPreventivo_app& relapp = (TPreventivo_app&)main_app();
        if (relapp.set_elab_code(cod))
          stop_run(K_SAVE);
      }
    }
    break;
  case DLG_ARCHIVE:
    if (e == fe_button)
    {
      const TString& cod = pe_trova_elaborazione(*this, 'F');
      if (cod.full())
      {
        TPreventivo_app& relapp = (TPreventivo_app&)main_app();
        if (relapp.set_elab_code(cod))
          stop_run(K_SAVE);
      }
    }
    break;
  case F_RICARICO:
    if (e == fe_modify && !o.empty())
    {
      // Controllo che ci sia almeno una fase prima di ricalcolare tutto
      TPreventivo_tree& t = tree(); 
      if (t.goto_root() && t.has_son() && yesno_box(TR("Si desidera applicare il nuovo ricarico a tutte fasi?")))
      {
        if (t.goto_root())
        {
          const real perc = ricarico2perc(o.get());
          t.scan_depth_first(ricarica, (void*)&perc);
          sync_tree();
          set_fase("");
        }
      }
    }
    break;
  default:
    if (jolly > 0 && o.dlg() >= 101 && o.dlg() < 300) // Sheet mask events
    {
      if (e == fe_modify)
      {
        switch (jolly)
        {
        case  1: return on_dist_event(o, e, jolly);
        case  2: return on_dett_event(o, e, jolly);
        case  3: return on_misu_event(o, e, jolly);
        default: CHECK(false, "Unknown sheet field event"); break;
        }
      }
    }
    break;
  }
  return TPreventivo_msk::on_field_event(o, e, jolly);
}

void TPreventivo_emsk::set_sheet_color(short id, COLOR col)
{
  const COLOR rgb = blend_colors(NORMAL_BACK_COLOR, col, 0.75);
  TSheet_field& s = sfield(id); 
  s.set_back_and_fore_color(rgb, NORMAL_COLOR, -1);
}

TPreventivo_emsk::TPreventivo_emsk() : TPreventivo_msk("pe1400b"), _tree(NULL), _locked(false), _has_db(false)
{
  int yca = 21; // Riga del primo campo di analitica
  TMask_field* grp = find_by_id(F_CDC0);
  if (grp)
  {
    RCT rct0; grp->get_rect(rct0);
    yca = rct0.top / ROWY + 1; 
  }

  short idcdc = 0, idcms = 0, idfase = 0, idconto = 0;
  ca_create_fields_ext(*this, 0, 2, yca, F_CDC0+1, idcdc, idcms, idfase, idconto, 
                       DOC_CODCOSTO, DOC_CODCMS, NULL);  // Niente fasi qui!

  set_sheet_color(F_DISTINTE, COLOR_YELLOW); 
  set_sheet_color(F_ARTICOLI, COLOR_GREEN); 
  set_sheet_color(F_MISURE,   COLOR_GRAY); 

  _has_db = dongle().active(DBAUT);
  if (_has_db)
  {
    TISAM_recordset dist("USE DIST");
    _has_db = dist.items() >= 4;
  }
  TMask& dist = sfield(F_DISTINTE).sheet_mask();
  TList_field& tipoa = dist.lfield(D_TIPOA);
  const TToken_string cod = tipoa.get_codes();
  if (!_has_db && cod.items() >= 2)
  {
    TToken_string* m1 = tipoa.message(1);
    tipoa.replace_items("A", TR("Articolo"));
    if (m1 != NULL)
    {
      TToken_string* m0 = tipoa.message(0);
      if (m0 != NULL)
        *m0 = *m1;
    }
    tipoa.disable();
  }
}


///////////////////////////////////////////////////////////
// TPreventivo_app
///////////////////////////////////////////////////////////

bool TPreventivo_app::user_create()
{
  if (ca_config().get_int("Authorizations") < 2)
    return error_box("E' necessario configurare la contabilità analitica o industriale");

  open_files(LF_TAB, LF_TABCOM, LF_CLIFO, 
             LF_DOC, LF_RIGHEDOC, LF_COMMESSE, LF_FASI, 0);
  _rel = new TRelation(LF_DOC);
  _qmsk = new TPreventivo_qmsk;
  _emsk = new TPreventivo_emsk;
  return true;
}

bool TPreventivo_app::user_destroy()
{
  delete _emsk;
  delete _qmsk;
  delete _rel;
  return true;
}

TCursor& TPreventivo_app::get_filtered_cursor() const
{
  TEdit_field& f = _qmsk->efield(F_NDOC);
  TCursor& cur = *f.browse()->cursor();
  if (cur.items() == 0) // A volte deve scantarsi ...
    f.check();          // ... forzo ricalcolo elementi
  return cur;
}

bool TPreventivo_app::get_next_key(TToken_string& key)
{
  TPreventivo_msk& m = (TPreventivo_msk&)curr_mask();
  
  const TEdit_field& codnum = m.efield(F_CODNUM);
  if (codnum.empty())
    return codnum.error_box(TR("Inserire un codice numerazione"));

  const int revlen = m.revision_length();
  
  long ndoc = 0;
  int nprev = 0, nrev = 0;
  
  if (m.query_mode() || revlen == 0)
  {
    TCursor& cur = get_filtered_cursor();
    const TRecnotype i = cur.items();
    if (i > 0)
    {
      cur = i-1;
      ndoc = cur.curr().get_long(DOC_NDOC);
      m.split_ndoc(ndoc, nprev, nrev);
    }
    nprev++;
    nrev = 1;
    m.join_ndoc(nprev, nrev, ndoc);
  }
  else
  {
    // Trucchi per evitare l'azzeramento della maschera
    _revisioning = true;
    m.set_mode(MODE_QUERY);

    ndoc = m.get_long(F_NDOC);
    m.split_ndoc(ndoc, nprev, nrev);
    nrev++;
    m.join_ndoc(nprev, nrev, ndoc);
    m.set(F_NDOC, ndoc, 0x3);
  }
  key.format("%d|%ld", F_NDOC, ndoc);
  return true;
}

int TPreventivo_app::read(TMask& m)
{
  int err = TRelation_application::read(m);
  if (err == NOERR)
  {
    const TRectype& doc = get_relation()->curr();
    TToken_string keytok;
    keytok.add(doc.get(DOC_CODNUM));
    keytok.add(doc.get(DOC_ANNO));
    keytok.add(doc.get(DOC_PROVV));
    keytok.add(doc.get(DOC_NDOC));
    const TRecord_array rdoc(keytok, LF_RIGHEDOC);
    
    TPreventivo_tree& t = ((TPreventivo_emsk&)m).tree();
    t.append_row(doc);
    const int last_row = rdoc.last_row();
    for (int r = rdoc.first_row(); r > 0 && r <= last_row; r = rdoc.succ_row(r))
      t.append_row(rdoc[r]);

    t.shrink_all();
    t.goto_root();
    t.expand();
    t.owner().force_update();

    m.set(F_FASEMAX, pe_numero_fasi(rdoc));
  }
  _codelab.cut(0); // Azzera in ogni caso l'elaborazione
  return err;
}

static bool tree_save_row(TTree& tree, void* jolly, word /*flags*/)
{
  TPreventivo_tree& t = (TPreventivo_tree&)tree;
  const TRectype* rec = t.curr_row();
  if (rec && !rec->empty() && rec->num() == LF_RIGHEDOC)
  {
    const real costo = rec->get(RPRV_COSTO);
    const real price = rec->get(RDOC_PREZZO);
    const TString& descr = rec->get(RDOC_DESCR);
    if (descr.full() || !costo.is_zero() || !price.is_zero())
    {
      TDocumento& doc = *(TDocumento*)jolly;
      const TString4 tiporiga = rec->get(RDOC_TIPORIGA);
      TRectype& row = doc.new_row(tiporiga);
       
      const TString80 codart = rec->get(RDOC_CODART);
      TString80 codartmag;
      if (codart.full())
        codartmag = cache().get(LF_ANAMAG, codart, ANAMAG_CODART);

      for (int f = rec->items()-1; f > 5; f--)
      {
        const char* fld = rec->fieldname(f);
        if (rec->type(fld) == _memofld)
          break;
        const TString& src = rec->get(fld);
        if (src.full())
        {
          const TString& dst = row.get(fld);
          if (dst.blank())
            row.put(fld, src);
        }
      }

      row.put(RDOC_IDRIGA,    row.get(RDOC_NRIGA));
      row.put(RDOC_TIPORIGA,  rec->get(RDOC_TIPORIGA));    
      row.put(RDOC_QTA,       rec->get(RDOC_QTA));
      row.put(RDOC_DESCR,     rec->get(RDOC_DESCR));
      row.put(RDOC_DESCLUNGA, rec->get(RDOC_DESCLUNGA));
      row.put(RDOC_DESCEST,   rec->get(RDOC_DESCEST));
      row.put(RDOC_CODART,    codart);
      row.put(RDOC_CODARTMAG, codartmag);
      row.put(RDOC_CHECKED,   codartmag.full());
      row.put(RDOC_UMQTA,     rec->get(RDOC_UMQTA));
      row.put(RDOC_QTAGG1,    rec->get(RDOC_QTAGG1));
      row.put(RDOC_QTAGG2,    rec->get(RDOC_QTAGG2));
      row.put(RDOC_QTAGG3,    rec->get(RDOC_QTAGG3));
      row.put(RDOC_QTAGG4,    rec->get(RDOC_QTAGG4));
      row.put(RDOC_QTAGG5,    rec->get(RDOC_QTAGG5));
      row.put(RDOC_PREZZO,    rec->get(RDOC_PREZZO));

      // Make sure of coherent level on final record
      const TPreventivo_level pl = t.level(*rec);
      if (pl > pl_fase1 && pl < pl_distinta)
        row.put(RPRV_LEVEL, int(t.curr_depth() - 1)); // Don't assume RPRV_LEVEL = pl-pl_fase1
      else
        row.zero(RPRV_LEVEL);
    }
  }
  return false;  // Don't stop scan
}

int TPreventivo_app::save_rows(const TMask& m)
{
  TPreventivo_tree& tree = ((TPreventivo_emsk&)m).tree();

  TDocumento doc(get_relation()->curr());
  doc.destroy_rows();
  if (tree.goto_root() && tree.goto_firstson())
    tree.scan_depth_first(tree_save_row, &doc);

  // Estrae campi analitica da maschera principale e li riporta sulle righe
  TString cms, cos;
  FOR_EACH_MASK_FIELD(m, i, f) if (f->active() && f->is_edit() && f->dlg() >= F_CDC0)
  {
    const TFieldref* fref = f->field();
    if (fref != NULL)
    {
      if (fref->name() == DOC_CODCMS)
        cms << f->get();
      if (fref->name() == DOC_CODCOSTO)
        cos << f->get();
    }
  }

  TRecord_array& rdoc = doc.body();
  rdoc.renum_key(RDOC_CODCMS,   cms);
  rdoc.renum_key(RDOC_CODCOSTO, cos);
  
  const int err = doc.rewrite(get_relation()->file());
  if (err == NOERR && _codelab.full())
    pe_genera_documento(doc, _codelab, 'O');
  _codelab.cut(0); // Azzera in ogni caso l'elaborazione

  return err;
}

int TPreventivo_app::write(const TMask& m)
{
  int err = TRelation_application::write(m);
  if (err == NOERR)
    err = save_rows(m);
  return err;
}

int TPreventivo_app::rewrite(const TMask& m)
{
  int err = TRelation_application::rewrite(m);
  if (err == NOERR)
    err = save_rows(m);
  return err;
}

bool TPreventivo_app::remove()
{
  bool done = TRelation_application::remove();
  if (done)
  {
    const TRectype& rec = get_relation()->curr();
    TToken_string keytok;
    keytok.add(rec.get(DOC_CODNUM));
    keytok.add(rec.get(DOC_ANNO));
    keytok.add(rec.get(DOC_PROVV));
    keytok.add(rec.get(DOC_NDOC));
    TRecord_array rdoc(keytok, LF_RIGHEDOC);
    rdoc.remove();
  }
  return done;
}

void TPreventivo_app::update_tools(TMask& m)
{
  const bool is_edit = m.edit_mode();
  const bool can_ord = is_edit && pe_trova_elaborazione(m, 'O').full();
  const bool can_fab = is_edit && pe_trova_elaborazione(m, 'F').full();
  bool can_print = is_edit;
  if (can_print)
  {
    const TTipo_documento& tip = cached_tipodoc(m.get(DOC_TIPODOC));
    TFilename rep;
    can_print = tip.main_print_profile(rep, 0x2);
  }
  
  m.enable(DLG_COPY,    is_edit);
  m.enable(DLG_NEWREC,  is_edit);
  m.enable(DLG_ELABORA, can_ord);
  m.enable(DLG_ARCHIVE, can_fab);
  m.enable(DLG_PRINT,   can_print);
  m.enable(DLG_PREVIEW, can_print);
  m.disable(F_STATO); // Enable with F12
}

void TPreventivo_app::init_insert_mode(TMask& m)
{
  _revisioning = false;
  TRelation_application::init_insert_mode(m);
  m.set(F_DATADOC, TDate(TODAY));
  update_tools(m);

  const TMultilevel_code_info& fi = ca_multilevel_code_info(LF_FASI);
  const int fasemax = fi.levels() - fi.parent_levels();
  m.set(F_FASEMAX, fasemax);
}

void TPreventivo_app::init_modify_mode(TMask& m)
{
  _revisioning = false;
  TRelation_application::init_modify_mode(m);
  update_tools(m);
}

bool TPreventivo_app::save_and_print(TPrtype mode)
{
  static bool already_printing = false;
  if (already_printing)
    return false;
  already_printing = true;

  if (rewrite(*_emsk) != NOERR)
    return already_printing = false;

  TString commandline;
  commandline << "ve1 -2" << ' ' << _emsk->get(F_CODNUM) << ' ' 
              << _emsk->get(F_ANNO) << " D " << _emsk->get(F_NDOC);
  switch (mode)
  {
  case exportprinter: commandline << " E P"; break;
  case fileprinter  : commandline << " P P"; break;
  case screenvis    : commandline << " A P"; break;
  default           : commandline << " S D"; break;
  }

  TExternal_app interattivo( commandline );
  if (interattivo.run() == NOERR)
  {
    TLocalisamfile& f = _rel->file();
    f.zero();
    f.put(DOC_PROVV, 'D');
    f.put(DOC_ANNO,   _emsk->get(F_ANNO));
    f.put(DOC_CODNUM, _emsk->get(F_CODNUM));
    f.put(DOC_NDOC,   _emsk->get(F_NDOC));
    f.read();
    curr_mask().set(F_STATO, f.get(DOC_STATO));
  }
  already_printing = false;
  return true;
}

void TPreventivo_app::print()
{
  save_and_print(winprinter);
}

void TPreventivo_app::preview()
{
  save_and_print(screenvis);
}

const char* TPreventivo_app::record_description(const TRelation& rel) const
{
  const TString4 tipodoc = rel.curr().get(DOC_TIPODOC);
  const TString& desc = cache().get("%TIP", tipodoc, "S0");
  return desc.empty() ? title() : desc;
}

int pe1400(int argc, char* argv[])
{
  TPreventivo_app a;
  a.run(argc, argv, TR("Preventivi"));
  return 0;
}