#include <applicat.h>
#include <defmask.h>
#include <dongle.h>
#include <execp.h>
#include <modaut.h>
#include <tabutil.h>
#include <utility.h>

#include "velib.h"
#include "vepriv.h"
#include "verig.h"
#include "../mg/mglib.h"

#include "ve0100b1.h"
#include "ve0100o.h"
#include "veuml.h"
#include "veuml1.h"
#include "veini.h"

#include "sconti.h"             

TDocumento_mask::TDocumento_mask(const char* td)
               : TVariable_mask(), _progs_page(-1), _last_prog(-1), 
                 _condv(NULL)
{               
  CHECK(strlen(td) <= 4, "TDocumento_mask(TipoDocumento) not (MaskName)");

  {
    TMagazzini m;

    _ges_mag = m.gestmag();
    _ges_dep = m.gestdep();
    _std_mag = m.standardmag();
    _std_dep = m.standarddep();
  }
  _doc.set_tipo(td);
  const TString mname = _doc.tipo().mask_name();
  read_mask(mname, 0, MAX_PAGES);

  int pos = id2pos(BASE_PIEDE + 1);
  if (pos >= 0)
  {
    _progs_page = find_parent_page(fld(pos));
    _last_prog = 0;
    while (id2pos(BASE_PIEDE + _last_prog + 1) >= 0)
      _last_prog++;
  }

  _sheet = &sfield(F_SHEET);
  _sheet->set_notify( ss_notify );
  _sheet->set_append(FALSE);
  
  TList_field& listbox = ( TList_field& )field( F_LBTIPORIGA );

  TConfig& prof = _doc.tipo().profile();
  const int numtr = prof.get_int( "NTIPIRIGA", "RIGHE" ); //prof
  TToken_string keys, descrs;
  TRiga_documento r(&_doc);

  for ( int i = 1; i <= numtr; i ++ )
  {
    TString16 var;

    var.format("%d", i);
    TString16 tiporiga(prof.get(var, "RIGHE"));  // pro
    r.set_tipo(tiporiga);
    keys.add(r.tipo().codice());
    descrs.add(r.tipo().descrizione());
  }
  listbox.replace_items( keys, descrs );
  configura_sheet( *_sheet, prof );
  ((TVariable_sheet_field*)_sheet)->set_getmask( ss_getmask );
  if (id2pos( F_OCCASEDIT ) > 0 )
    set_handler( F_OCCASEDIT, occas_handler );
  set_handler( F_CODCF, clifo_handler );
  set_handler( F_CODPAG, condpag_hndl );
  set_handler( F_DATAINSC, condpag_hndl );
  set_handler( F_CODNOTE, note_hndl );
  set_handler( F_DATADOC, data_hndl );
  set_handler( F_CODLIST, codlist_handler ); 
  set_handler( F_CODLIST1, codlist_handler ); 
  set_handler( F_CODCONT, codcont_handler ); 
  set_handler( F_CODCONT1, codcont_handler ); 
  set_handler( F_CODCAMP, codcamp_handler ); 
  set_handler( DLG_ELABORA, elabora_handler );      
  set_handler( DLG_PRINT, print_handler );
  int numhandler = prof.get_int( "NHANDLER", "HANDLERS" ); // prof

  for ( i = 1; i <= numhandler; i ++ )
  {
    TString16 chiave;
    chiave.format( "%d", i );
    TToken_string riga = prof.get( chiave, "HANDLERS" );
    user_set_handler( riga.get_int( 0 ), riga.get_int( 1 ) );
  }

  TCodgiac_livelli l;

  for ( i = MAX_GIAC_LEVEL; i > 0; i--)
  {
    const short pos = _sheet->cid2index(FR_LIV1 + i -1);
    if (l.enabled(i))
    {
      const TString & header = l.name(i);
      const int len = header.len() + 1;
      const int f_len = l.code_length(i);
      _doc.set_liv_giac_len(i, f_len);

      _sheet->set_column_header(pos, l.name(i));
      _sheet->set_column_width(pos, (len > f_len ? len : f_len) * 8);
    }
    else
    {
      _sheet->delete_column(pos);
      _doc.set_liv_giac_len(i, 0);
    }
  }

// configurazione campi

  TConfig cfg(CONFIG_DITTA, "ve");
  const bool gesval   = cfg.get_bool("GESVAL");
  const bool gescambi = cfg.get_bool("GESVALAC");

  if (gesval)
  {
    show(F_CODVAL, !gescambi);
    show(F_DATACAMBIO, !gescambi);
    show(F_NOMEVAL, !gescambi);
    show(F_CODVAL1, gescambi);
    show(F_DATACAMBIO1, gescambi);
    show(F_NOMEVAL1, gescambi);
    show(F_CAMBIO);
  }
  else
  {
    disable(F_CODVAL);
    disable(F_DATACAMBIO);
    disable(F_NOMEVAL);
    hide(F_CODVAL1);
    hide(F_DATACAMBIO1);
    hide(F_NOMEVAL1);
    disable(F_CAMBIO);
  }

  const bool geslin   =  cfg.get_bool("GESLIN");

  enable(F_CODLIN, geslin);
  enable(F_DESLIN, geslin);

  const bool geslis         =  cfg.get_bool("GES", "ve", 1);
  const bool gesliscatven   =  cfg.get_bool("GESLISCV");

  if (geslis)
  {
    show(F_CODLIST, !gesliscatven);
    show(F_CODLIST1, gesliscatven);
  }
  else
  {
    disable(F_CODLIST);
    hide(F_CODLIST1);
  }

  const bool gescontr       =  cfg.get_bool("GES", "ve", 2);
  const bool gescontrcli    =  cfg.get_bool("GESCONCC");

  if (gescontr)
  {
    show(F_CODCONT1, gescontrcli);
    show(F_CODCONT, !gescontrcli);
  }
  else
  {
    disable(F_CODCONT);
    hide(F_CODCONT1);
  }

  const bool gesoff        =  cfg.get_bool("GES", "ve", 3);
  enable(F_CODCAMP, gesoff);

  const bool gessco        =  cfg.get_char("GESSCO") != 'N';
  enable(F_SCONTOPERC, gessco);

  const bool gesage        =  cfg.get_bool("GESAGE");
  enable(F_CODAG, gesage);
  enable(F_DESAG, gesage);
  enable(F_CODAGVIS, gesage);
  enable(F_DESAGVIS, gesage);

  const bool has_movmag = dongle().active(MGAUT) && _doc.tipo().mov_mag();
  pos = id2pos(F_CAUSMAG);
  if (pos >= 0)
    fld(pos).show(has_movmag);
  pos = id2pos(F_DESCRMAG);
  if (pos >= 0)
    fld(pos).show(has_movmag);
  pos = id2pos(F_CAUSMAGC);
  if (pos >= 0)
    fld(pos).show(has_movmag);
  pos = id2pos(F_DESCRMAGC);
  if (pos >= 0)
    fld(pos).show(has_movmag);

}

TDocumento_mask::~TDocumento_mask()
{
  if (_condv)
    delete _condv;
}

void TDocumento_mask::configura_sheet( TSheet_field& sheet, TConfig& config )
{
  TBit_array to_delete(MAX_COLUMNS);
  to_delete.set();
  int ncols = config.get_int( "NCOLS", "SHEET" );
  for ( int i = 1; i <= ncols; i ++ )
  {
    TString col;
    col.format( "%d", i );
    TToken_string sheet_col( config.get( col, "SHEET" ) );
    const int field_id = sheet_col.get_int(0);
    const int coltomove = sheet.cid2index(field_id);
    to_delete.reset(coltomove);

    const TString descr(sheet_col.get( 1 ));

    if (descr.not_empty() )
      sheet.set_column_header( field_id, descr);

    const int size( sheet_col.get_int(2));

    if (size != 0)
      sheet.set_column_width( field_id, size);

  }
  to_delete.reset(0);
  to_delete.reset(1);

  if (!to_delete[sheet.cid2index(FR_CODDEP)])
    sheet.enable_column(FR_CODDEP, _ges_dep && _ges_mag);
  if (!to_delete[sheet.cid2index(FR_CODMAG)])
    sheet.enable_column(FR_CODMAG, _ges_mag);
  if (!to_delete[sheet.cid2index(FR_CODDEPC)])
    sheet.enable_column(FR_CODDEPC, _ges_dep && _ges_mag);
  if (!to_delete[sheet.cid2index(FR_CODMAGC)])
    sheet.enable_column(FR_CODMAGC, _ges_mag);
  to_delete.set(sheet.cid2index(FR_CODARTMAG));
  to_delete.set(sheet.cid2index(FR_CHECKED));

  const int sconto_col = sheet.cid2index(FR_SCONTO);
  if (to_delete[sconto_col] == FALSE)
  {
    const bool del = config.get("GESSCORIGA") == "N";
    to_delete.set(sconto_col, del);
  }

  for ( i = MAX_COLUMNS - 1; i >= 0; i-- )
     if( to_delete[i] )
     {
       sheet.enable_column( i + FIRST_FIELD, FALSE);
       sheet.delete_column( i + FIRST_FIELD);
     }

/*  for ( i = 1; i <= ncols; i ++ )
  {
    TString col;
    col.format( "%d", i );
    TToken_string sheet_col( config.get( col, "SHEET" ) );
    const int field_id = sheet_col.get_int(0);

    sheet.move_column(field_id, i);
  } */
}


TCond_vendita& TDocumento_mask::condv() const
{
  if (_condv == NULL)
  {
    TDocumento_mask* myself = (TDocumento_mask*)this;
    myself->_condv = new TCond_vendita(myself, NULL);
  }
  return *_condv;
}

void TDocumento_mask::next_page(int p)
{     
  const bool was_normal_page = curr_page() < _progs_page;
  TMask::next_page(p);
  const bool is_calculated_page = curr_page() >= _progs_page;

  if (was_normal_page && is_calculated_page)
  {                    
    TWait_cursor hourglass;

    for (int f = id2pos(BASE_PIEDE + 1)-1; f >= 0; f--)
    {
      const TMask_field& mf = fld(f);
      const TFieldref* fr = mf.field();
      if (fr)
        _doc.put(fr->name(), mf.get());
    }

    for (int i = _last_prog; i > 0; i--)
    {
      const short id = BASE_PIEDE + i;
      const TString& name = field(id).field()->name();
      const TString& val = _doc.get(name);
      set(id, val); 
    }
  }
}

bool TDocumento_mask::on_key(KEY key)
{ 
  if (key == K_SHIFT + K_F12)
  {
    TMask_field& stato = field(F_STATO);
//    stato.enable(!stato.enabled());
    stato.enable();
    enable(DLG_SAVEREC);
    return TRUE;
  }
  return TVariable_mask::on_key(key); 
}

void TDocumento_mask::occ2mask()
{  
  const TOccasionale& o = doc().occas();

  reset(F_COFI);
  reset(F_PAIVA);
  set(F_OCFPI, o.get(OCC_CFPI));   
  const TString & ragsoc = o.get(OCC_RAGSOC);
  set(F_RAGSOC, ragsoc);
  set(F_RAGSOCSP, ragsoc);
  const TString & indir = o.get(OCC_INDIR);
  set(F_INDCF, indir);
  set(F_INDSP, indir);
  const TString & civ = o.get(OCC_CIV);
  set(F_CIVCF, civ);
  set(F_CIVSP, civ);
  const TString & cap = o.get(OCC_CAP);
  set(F_CAPCF, cap);
  set(F_CAPSP, cap);
  const TString & com = o.get(OCC_COM);
  set(F_COMCF, com);    
  set( F_COMSP, com);
  const TString & stato = o.get(OCC_STATO);
  set(F_STATOCF, stato);  
  set( F_STATOSP, stato);
  if (id2pos(F_CODINDSP) >= 0)
    reset(F_CODINDSP);
  // Sugli occasionali non c'è la località
  const TString & localita = o.get(OCC_LOCALITA);
  set(F_LOCALITACF, localita);
  set(F_LOCALITASP, localita);
  check_field(F_COMSP);
  check_field(F_STATOSP);
}

void TDocumento_mask::cli2mask()
{  
 TCli_for & c = doc().clifor(); 
 TOccasionale & o = doc().occas();

  const bool onload = !is_running();
  const TString16 codval(get(F_CODVAL));
  const TString16 datacambio(get(F_DATACAMBIO1));
  
  // Setta i campi che appartengono al file LF_CLIFO  
  const bool occas = c.occasionale();

  show(F_OCCASEDIT, occas);
  if (!occas)
    reset(F_OCFPI);
  show(F_OCFPI, occas);
  // In forse per l'Occasionale, sicuri per il Normale
  show(F_COFI, !occas);
  show(F_STATOPAIVA, !occas);
  show(F_PAIVA, !occas);    
  set(F_RAGSOC, c.get(CLI_RAGSOC));
  enable(F_RAGSOC, !occas);
  
  const TRectype & ven_rec = c.vendite();

  if(!onload)    
  {                       
    short pos = id2pos(F_CODVAL);                
    const TString & codval = c.get(CLI_CODVAL);
    
    if (pos >= 0 && fld(pos).active())
      fld(pos).set(codval);
    pos = id2pos(F_CODVAL1);              
    if (pos >= 0 && fld(pos).active())
      fld(pos).set(codval);
    pos = id2pos(F_CODLIN);              
    if (pos >= 0 && fld(pos).active())
      fld(pos).set(c.get(CLI_CODLIN));
    set(F_CODPAG, c.get(CLI_CODPAG));
    set(F_CODABIA, c.get(CLI_CODABI));
    set(F_CODCABA, c.get(CLI_CODCAB));
    // Setta i campi che appartengono al file LF_CFVEN
    set(F_CODABIP, ven_rec.get(CFV_CODABIPR));
    set(F_CODCABP, ven_rec.get(CFV_CODCABPR));
    set(F_RAGGR, ven_rec.get(CFV_RAGGDOC));
    set(F_RAGGREFF, ven_rec.get(CFV_RAGGEFF));
    set(F_CODINDSP, ven_rec.get(CFV_CODINDSP));
    set(F_CODAG, ven_rec.get(CFV_CODAG));
    set(F_CODSPMEZZO, ven_rec.get(CFV_CODSPMEZZO));
    set(F_CODPORTO, ven_rec.get(CFV_CODPORTO));
    set(F_CODNOTESP1, ven_rec.get(CFV_CODNOTESP1));
    set(F_CODNOTESP2, ven_rec.get(CFV_CODNOTESP2));
    set(F_CODNOTE, ven_rec.get(CFV_CODNOTE));
    set(F_CODVETT1, ven_rec.get(CFV_CODVETT1));
    set(F_CODVETT2, ven_rec.get(CFV_CODVETT2));
    set(F_CODVETT3, ven_rec.get(CFV_CODVETT3));
    set(F_SPESEINC, ven_rec.get(CFV_PERCSPINC));  
    set(F_ADDBOLLI, ven_rec.get(CFV_ADDBOLLI));
    set(F_CATVEN, ven_rec.get(CFV_CATVEN));
    pos = id2pos(F_CODLIST);              
    const TString & codlist = ven_rec.get(CFV_CODLIST);
    if (pos >= 0 && fld(pos).active())
    {   
      TEdit_field & f = (TEdit_field&) fld(pos);
      
      f.set(codlist);
      f.check();
      f.on_hit();
    }
    pos = id2pos(F_CODLIST1);              
    if (pos >= 0 && fld(pos).active())
    {   
      TEdit_field & f = (TEdit_field&) fld(pos);
      
      f.set(codlist);
      f.check();
      f.on_hit();
    }
    pos = id2pos(F_CODAG);              
    if (pos >= 0 && fld(pos).active())
      fld(pos).set(ven_rec.get(CFV_CODAG));
    set(F_CODZON, ven_rec.get(CFV_CODZONA));
    set(F_RAGGR, ven_rec.get(CFV_RAGGDOC));
    sconto_testa2mask();
    spese2mask();
  }
  enable( F_CODINDSP , !occas);      
  if (occas) 
    occ2mask();
  else           
  {        
    set(F_COFI, c.get(CLI_COFI));
    set(F_INDCF, c.get(CLI_INDCF));
    set(F_CIVCF, c.get(CLI_CIVCF));
    set(F_STATOPAIVA, c.get(CLI_STATOPAIV));
    set(F_PAIVA, c.get(CLI_PAIV));
    set(F_LOCALITACF, c.get(CLI_LOCCF));
    set(F_CAPCF, c.get(CLI_CAPCF));
    set(F_COMCF, c.get(CLI_COMCF));
    set(F_STATOCF, c.get(CLI_STATOCF));
    check_field( F_CODINDSP );
  }
  const TString16 newcodval(get(F_CODVAL));
  const TString16 newdatacambio(get(F_DATACAMBIO1));

  short pos = id2pos(F_CAMBIO);                           
  if ((pos >= 0) && (newcodval.empty() || newdatacambio.empty()))
    fld(pos).reset();  
  pos = id2pos(F_CODVAL);                           
  if (pos >= 0 && fld(pos).active())
    fld(pos).check();
  pos = id2pos(F_CODVAL1);                           
  if (pos >= 0 && fld(pos).active())
    fld(pos).check();
  pos = id2pos(F_DATACAMBIO1);                           
  if (pos >= 0 && fld(pos).active() &&
     (codval != newcodval || datacambio != newdatacambio))
    fld(pos).check();
  check_field(F_COMCF);
  check_field(F_STATOCF);
  check_field( F_CODPAG );
  pos = id2pos(F_CODLIN);                           
  if (pos >= 0 && fld(pos).active())
    fld(pos).check();
  check_field( F_CODCABA );
  pos = id2pos(F_CODLIST);                           
  if (pos >= 0 && fld(pos).active())
    fld(pos).check();
  pos = id2pos(F_CODLIST1);                           
  if (pos >= 0 && fld(pos).active())
    fld(pos).check();
  check_field( F_CODCABP );
  pos = id2pos(F_CODAG);                           
  if (pos >= 0 && fld(pos).active())
    fld(pos).check();
  check_field( F_CODSPMEZZO );
  check_field( F_CODPORTO );
  check_field( F_CODNOTESP1 );
  check_field( F_CODNOTESP2 );
  check_field( F_CODNOTE );
  check_field( F_CODVETT1 );
  check_field( F_CODVETT2 );
  check_field( F_CODVETT3 );    
  check_field( F_CATVEN );    
  check_field( F_CODZON );
  
  const bool contr_enabled = ven_rec.get_bool(CFV_GESTCONTR);
  bool gescontr = FALSE;
  if (contr_enabled)
  {
    TConfig ditta(CONFIG_DITTA, "ve");
    gescontr = ditta.get_bool("GES", "ve", 2);          
  }
  
  enable(F_CODCONT1, contr_enabled && gescontr);
  enable(F_CODCONT, contr_enabled && gescontr);
}

void TDocumento_mask::sconto_testa2mask()
{
  TCli_for & c = doc().clifor(); 
  TConfig ditta(CONFIG_DITTA, "ve");
  const char tipogestione = ditta.get("GESSCO", "ve")[ 0 ];
  switch( tipogestione )
  {
    case 'N':  // Sconti non gestiti: pussa via!
      break;
    case 'P':  // Percentuale su anagrafica cliente
      set( F_SCONTOPERC, c.vendite().get(CFV_SCONTO));
      break;
    case 'T':  // Gestione tabella sconti
      {
        const TString16 codsconto(c.vendite().get(CFV_CODSCC));
        
        if (codsconto.not_empty())
        {
          TTable sconti("%SCC");
          sconti.setkey(1);
          sconti.zero();
          sconti.put("CODTAB", codsconto);
          if (sconti.read( ) == NOERR)
            set(F_SCONTOPERC, sconti.get("S1"));
        }
      }
      break;
    case 'A':  // Gestione archivio sconti
      {
        TString16 cod;               
        const TRectype & ven_rec = c.vendite();
        TLocalisamfile sconti(LF_SCONTI );
                                     
        sconti.setkey(1);
        sconti.zero();
        sconti.put("TIPO", "I");
        if(ditta.get_bool("SCOKEY", "ve", 1))
          sconti.put("CODCAT", ven_rec.get(CFV_CATVEN));
        if(ditta.get_bool("SCOKEY", "ve", 2))
          cod.format("%-2s", (const char *)ven_rec.get(CFV_CODSCC));
        else
          cod = "  ";
        if( ditta.get_bool("SCOKEY", "ve", 3))
          cod << format("%-2s", (const char *)ven_rec.get(CFV_CODZONA));
        else
          cod << "  ";
        if( ditta.get_bool("SCOKEY", "ve", 4))
          cod << c.get(CLI_CODPAG);
        sconti.put("CODART", cod);
        if(sconti.read() == NOERR)
          set(F_SCONTOPERC, sconti.get( "SCONTO"));
      }
      break;    
    default:
      break;  
  }  
  return;
}

void TDocumento_mask::spese2mask()
{
  TSheet_field & sh = (TSheet_field &) field(F_SHEET);
  TCli_for & c = doc().clifor(); 
  
  TString16 name("CODSP0");
  TString_array spese;        
  TRectype & ven_rec = c.vendite();
  for (int i = 1; i <= 4; i++)
  {                     
    name.rtrim(1); name << i;
    const TString16 s(ven_rec.get(name));
    
    if (s.not_empty()) 
      spese.add(s);
  }               
//  autosave(*_rel);   
  doc().put("SPESEUPD", FALSE);
  doc().update_spese_aut(spese, FALSE, &sh);
  sh.force_update();
} 

void TDocumento_mask::doc2mask()
{ 
  for (int p = id2pos(BASE_PIEDE + 1)-1; p >= 0; p--)
  {
    TMask_field& f = fld(p);
    const TFieldref* fr = f.field();
    if (fr)
      f.set(fr->read(doc()));
  }

  cli2mask();      

  TSheet_field& s = sfield(F_SHEET);
  s.destroy( );
  for (int i = 0; i < doc().physical_rows(); i++)
  {
    s.insert(-1, FALSE);
    TToken_string& r = s.row(i);
    doc()[i+1].autoload(s);
    s.check_row(i );
  }
  s.force_update();
}

void TDocumento_mask::mask2doc()
{
  for (int p = fields()-1; p >= 0; p--)
  {
    TMask_field& f = fld(p);
    const TFieldref* fr = f.field();
    if (fr)
      fr->write(f.get(), doc());
  }
}


///////////////////////////////////////////////////////////
// Handlers and notifiers
///////////////////////////////////////////////////////////

bool TDocumento_mask::ss_notify( TSheet_field& ss, int r, KEY key )
{
  TDocumento_mask& m = (TDocumento_mask&)ss.mask();
  TDocumento& doc = m.doc();

  if ( key == K_ENTER ) // modifica
  {
    TRiga_documento & riga = doc[r + 1];
    riga.autosave(ss);
  }
  else
    if ( key == K_DEL ) // Cancellazione
    {
      doc.destroy_row(r + 1, TRUE);
      if (r < doc.rows())
      {
        TRiga_documento & riga = doc[r + 1];
        if (riga.is_omaggio() && riga.is_generata())
        {
          ss.destroy(r + 1);
          doc.destroy_row(r + 1, TRUE);
        }
      }
    }
    else
      if (key == K_INS) // Inserimento
      {
        if (r < doc.rows())
        {
          TRiga_documento & riga = doc[r + 1];
          if (riga.is_omaggio() && riga.is_generata())
            return FALSE;
        }
        doc.insert_row(r + 1, m.get( F_LBTIPORIGA ));
      }
      else
        if (key == K_CTRL + K_INS)
        {
          TRiga_documento & riga = doc[r + 1];
          TRectype & ven_rec = doc.clifor().vendite();
          TString16 s(ven_rec.get(CFV_CODMAG));
          if (s.not_empty())
          {
            s.left_just(3);
            s << ven_rec.get(CFV_CODDEP);
          }
          else
          {
            s = m._std_mag;
            s.left_just(3);
            s << m._std_dep;
          }
          riga.put("CODMAG", s);
          riga.autoload(ss);
          ss.check_row(r);
          ss.select(r);
        }
        else
          if ( key == K_TAB ) // modifica
            set_curr_um(ss.sheet_mask());

  return TRUE;
}

// Funzione che dato il profilo di riga ottiene la maschera
// Serve per ottenere una maschera diversa per ogni riga
TMask* TDocumento_mask::ss_getmask(int numriga, TMask& fullmask)
{
  TSheet_field* sf = fullmask.get_sheet();
  TDocumento_mask& m = (TDocumento_mask&)sf->mask();
  const TDocumento& doc = m.doc();

  const int n = numriga + 1;
  if (n <= doc.physical_rows())
  {
    const TRiga_documento& riga = doc[numriga + 1];
    return riga.tipo().mask();
  }
  else
    return &fullmask;
}

bool TDocumento_mask::occas_code_handler(TMask_field& f, KEY key)
{
  if (key == K_TAB && f.focusdirty())
  {
    const char* code = f.get();
    if (*code)
    {
      TRelation occas(LF_OCCAS);
      occas.lfile().put("CFPI", code);
      if (occas.read(_isequal) == NOERR)
      {
        TMask& m = f.mask();
        m.autoload(occas);
        m.send_key(K_TAB, O_COMUNE);         // Forza decodifica comuni
        m.send_key(K_TAB, O_COMUNENAS);
      }
    }
  }
  return TRUE;
}

bool TDocumento_mask::occas_handler( TMask_field& f, KEY key )
{
  TDocumento_mask & m = (TDocumento_mask &)f.mask();
  if ( key == K_SPACE && m.is_running( ) )
  {
    TDocumento& doc = m.doc();
    TOccasionale& occ = doc.occas();

    TMask occas_mask("ve0100o");
    occas_mask.set_handler( O_CODICE, occas_code_handler );

    for (int i = occas_mask.fields() - 1; i >= 0; i--)
    {
      TMask_field & f = occas_mask.fld(i);
      const TFieldref * c = f.field();
      if (c)
        f.set(c->read(occ));
    }
    if (occas_mask.run() != K_ESC)
    {
      const TString ocfpi(occas_mask.get(O_CODICE));
      doc.put("OCFPI", ocfpi);
      m.set(F_OCFPI, ocfpi);
  
      for (int i = occas_mask.fields() - 1; i >= 0; i--)
      {
        TMask_field & f = occas_mask.fld(i);
        TFieldref * c = (TFieldref *) f.field();
        if (c)
          c->write(f.get(), occ);
      }
      m.occ2mask();
    }
    f.set_focus( );
  }
  return TRUE;
}

bool TDocumento_mask::clifo_handler( TMask_field& f, KEY key )
{
  if (key != K_ENTER && f.to_check(key, TRUE))
  {
    TDocumento_mask & m = (TDocumento_mask &) f.mask();
    TDocumento & d = m.doc();
    const TString & val = f.get();

    d.put("TIPOCF", d.tipo().tipocf());
    d.put("CODCF", atol(val));

    TCli_for & cli_for = d.clifor();
    cli_for.put(CLI_CODCF, ""); // force reload

    if ( cli_for.get_bool("SOSPESO") )
      return f.error_box( "Il codice '%ld' e' sospeso e non puo' essere utilizzato", atol(val) );
    m.cli2mask();
    if (cli_for.occasionale())
    {
      TOccasionale & occas = d.occas();
      if(m.id2pos(F_OCCASEDIT) > 0 && f.to_check(key) && *(occas.codice()) == '\0')
        m.send_key( K_SPACE, F_OCCASEDIT );   // Lancia maschera occasionali
    }
    else
      d.zero("OCFPI");
  }
  return TRUE;
}

///////////////////////////////////////////////////////////
// TElabora_mask
///////////////////////////////////////////////////////////

class TElabora_mask : public TMask
{         
  TMask * _main;
  TLista_elaborazioni _elab;
  // @access Public Member
public:        
  void update_list();
  void update_ndoc_filter();
  bool elabora();  
  TElaborazione * curr_elab();
  static bool tipo_elaborazione_handler( TMask_field& f, KEY key );
  static bool tipo_documento_handler( TMask_field& f, KEY key );
  static bool codnum_handler( TMask_field& f, KEY key );
  // @cmember Costruttore (crea la maschera leggendo la descrizione dal file .msk)
  TElabora_mask(const char* title, TMask * main_mask);
  // @cmember Distruttore
  virtual ~TElabora_mask() {} 
};

void TElabora_mask::update_list()
{
  TString_array elabs;
  const TString16 tipo(_main->get(F_TIPODOC));
  const TString16 stato(_main->get(F_STATO));
  const TString16 tipo_elab(get(F_TIPODOC_ELAB));
  const TString16 stato_elab(get(F_STATODOC_ELAB));
  const bool from_elab = !get_bool(F_TYPE);   
  int items = 0;
    
  if (from_elab)
    items = _elab.select(elabs, tipo, stato, tipo_elab, stato_elab) ;
  else
    items = _elab.select(elabs, tipo_elab, stato_elab, tipo, stato) ;

  const bool ok = items > 0;

  enable(DLG_OK, ok);
  enable(F_ELAB, ok);

  TList_field & f = (TList_field &) field(F_ELAB);
  TToken_string codes;
  TToken_string descrs;

  if (ok)
    for (int i = 0; i < items; i++)
    {
      codes.add(format("%s", (const char *)_elab[elabs.row(i)].codice()));
      descrs.add((const char *)_elab[elabs.row(i)].descrizione());
    }
  f.replace_items(codes, descrs);
}


/* TLista_elaborazioni TElabora_mask::_elab; */
  
bool TElabora_mask::elabora()
{   
  bool update_mask = FALSE;

  TLista_documenti in;
  TLista_documenti out;                                 
  TDocumento & app_doc = ((TDocumento_mask *)_main)->doc();
  long numdoc = get_long(F_NDOC_ELAB);
  
  TDocumento d(*get(F_PROVV_ELAB), get_int(F_ANNO_ELAB), get(F_CODNUM_ELAB), numdoc);

  if (numdoc <= 0)                   
  {            
    TDocumento::copy_data(d.head(), app_doc.head());
    d.put(DOC_TIPODOC, get(F_TIPODOC_ELAB));  
  }
  
  const bool from_elab = !get_bool(F_TYPE);   
  TElaborazione * e = curr_elab();
  
  if (e == NULL)
    return FALSE;
      
  if (from_elab)
  {
    in.add(app_doc);
    out.add(d);
    if (e->elabora(in, out, TDate(TODAY), TRUE))
    {                    
      if (out[0] != d)
        out.rewrite();
      if (in[0] != app_doc)
      {
        in.rewrite();
        app_doc = in[0];
        update_mask = TRUE;
      }  
    }
  }
  else
  {
    out.add(app_doc);
    in.add(d);
    if (e->elabora(in, out, TDate(TODAY), TRUE))
    {
      if (out[0] != app_doc)
      {
        out.rewrite();
        app_doc = out[0];
        update_mask = TRUE;
      }            
      if (in[0] != d)
        in.rewrite();
    }
  }         
  return update_mask;
}

TElaborazione * TElabora_mask::curr_elab()
{
  const TString16 cod_elab(get(F_ELAB));
   return cod_elab.not_empty() ? &_elab[cod_elab] : NULL;
}     

void TElabora_mask::update_ndoc_filter()
{
  TString filter(80);
  filter.format("(TIPOCF==\"%s\")&&(CODCF==\"%s\")", (const char *)get(F_TIPOCF_ELAB), (const char *)get(F_CODCF_ELAB));
  const TString16 tipo(get(F_TIPODOC_ELAB));
  TElaborazione * e = curr_elab();
                        
  if (e != NULL)
  {
	  if (tipo.not_empty())
	  {
	    filter << format("&&(TIPODOC==\"%s\")", (const char *)tipo);
	    const int stato = get_int(F_STATODOC_ELAB);
	    if (stato != 0)
	      filter << format("&&(STATO==\"%d\")", stato);
	    else
	    {
		    bool almost_one = FALSE;
		                                     
		    for (int i = 0; i < TElaborazione::_max_tipi_doc_elab; i++)
		    {
		      const TString16 tipo_in(e->tipo_iniziale(i));
	        const char stato_in = e->stato_iniziale(i);
		        
		      if (tipo == tipo_in && stato_in > '0')
		      {                       
		        if (almost_one)
		          filter << "||";
		        else
		          filter << "&&(";
		        almost_one = TRUE;
		        
           filter << format("(STATO==\"%c\")", stato_in);
		      }
		    }
		    if (almost_one)
		      filter << ')';
	    }
	  }
	  else
	  {  
	    bool almost_one = FALSE;
	                                     
	    for (int i = 0; i < TElaborazione::_max_tipi_doc_elab; i++)
	    {
	      const TString16 tipo_in(e->tipo_iniziale(i));
	        
	      if (tipo_in.not_empty())
	      {                       
	        if (almost_one)
	          filter << "||";
	        else
	          filter << "&&(";
	        almost_one = TRUE;
	        filter << format("((TIPODOC==\"%s\")", (const char *)tipo_in);
	          
	        const char stato_in = e->stato_iniziale(i);
	        
	        if (stato_in > '0')
	          filter << format("&&(STATO==\"%c\")", stato_in);
	        filter << ')';
	      }
	    }
	    if (almost_one)
	      filter << ')';
	  }
  }
  efield(F_NDOC_ELAB).browse()->set_filter(filter);
}

bool TElabora_mask::tipo_elaborazione_handler( TMask_field& f, KEY key )
{                               
  if (key == K_SPACE)
  {
    TElabora_mask & m = (TElabora_mask &) f.mask();
    m.update_list();
    m.update_ndoc_filter();
  }
  return TRUE;
}

bool TElabora_mask::tipo_documento_handler( TMask_field& f, KEY key )
{                               
  if (f.to_check(key, TRUE))      
  {
    TElabora_mask & m = (TElabora_mask &) f.mask();
    m.update_list();
    m.update_ndoc_filter();
  }
  return TRUE;
}

bool TElabora_mask::codnum_handler( TMask_field& f, KEY key )
{                               
  if (f.to_check(key, TRUE))      
  {
    TElabora_mask & m = (TElabora_mask &) f.mask();
    m.update_ndoc_filter();
  }
  return TRUE;
}

TElabora_mask::TElabora_mask(const char* title, TMask * main_mask)
             : TMask(title), _main(main_mask)
{
  set_handler(F_TYPE, tipo_elaborazione_handler);
  set_handler(F_TIPODOC_ELAB, tipo_documento_handler);
  set_handler(F_STATODOC_ELAB, tipo_documento_handler);
  set_handler(F_CODNUM_ELAB, codnum_handler);
 
  set(F_ANNO_ELAB, _main->get(F_ANNO));                                                 
	set(F_TIPOCF_ELAB, _main->get(F_TIPOCF));                                                 
	set(F_CODCF_ELAB, _main->get(F_CODCF));
}

bool TDocumento_mask::elabora_handler( TMask_field& f, KEY key )
{
  if (key == K_SPACE)
  {
    TDocumento_mask& m = (TDocumento_mask&)f.mask();
    if (m.check_fields()) // Check values
    {
      TElabora_mask selection("ve0100b", &m);                                             
      if (selection.run() == K_ENTER)
      {
        m.mask2doc();
        bool update_mask = selection.elabora();
        if (update_mask)
          m.doc2mask();
 	    }     
    }
  }
  return TRUE;
}

bool TDocumento_mask::print_handler( TMask_field& f, KEY key )
{
  if (key == K_SPACE)
    main_app().print();
  return TRUE;
}

void TDocumento_mask::user_set_handler(int fieldid, int index)
{
  switch( index )
  {
  case 1:
    set_handler( fieldid, ora_hndl );
    break;
  case 3:
    set_handler( fieldid, dummy_hndl );
    break;
  default:
    CHECK( FALSE, "Tentativo di installare un handler non definito" );
    break;
  }
}

bool TDocumento_mask::num_handler( TMask_field& f, KEY key )
{
  if (key == K_TAB && f.to_check(key, TRUE))
  {
    // Ottengo la maschera
    TDocumento_mask& m = (TDocumento_mask&)f.mask( );
    
    TTable & tabnum  = ((TTable &) ((TEdit_field &)f).browse()->cursor()->file());
    if ( tabnum.good())
    {
      TCodice_numerazione cod_num(tabnum.curr());
      m.set( F_DESNUM, cod_num.descrizione());
      // Propone il primo tipo di documento come default
      m.set( F_TIPODOC, cod_num.tipo_doc(0));
      m.send_key( K_TAB, F_TIPODOC );
      // Se per questa numerazione h abilitata le numerazione provvisoria
      if (cod_num.num_provv())
      {
        // Setta di default la numerazione provvisoria
        m.set( F_PROVV, "P" );
        // Abilita il campo per la selezione della numerazione
        m.enable( F_PROVV );
      }
      else // Altrimenti ...
      {
        // Setta la numerazione a definitiva
        m.set( F_PROVV, "D" );
        // Disabilita il campo per la selezione della numerazione
        m.disable( F_PROVV );
      }
    }
    else
    {
      m.set( F_DESNUM, "" );
      m.set( F_TIPODOC, "" );
    }
  }
  return TRUE;
}

bool TDocumento_mask::tip_handler( TMask_field& f, KEY key )
{
  TDocumento_mask& m = (TDocumento_mask&)f.mask( );
  if ( key == K_TAB && m.is_running() && m.get(F_TIPODOC).not_empty())
  {
    TCodice_numerazione cod_num(m.get(F_CODNUM));
    const TString& tipo = f.get();
    int last = cod_num.ntipi_doc();
    for (int i = 0; i < last; i++ )
    {
      const TString16 curtipo(cod_num.tipo_doc(i));
      if (curtipo == tipo)
        return TRUE;
    }
    return f.error_box( "Tipo non valido per la numerazione selezionata!" );
  }
  return TRUE;
}

bool TDocumento_mask::codlist_handler( TMask_field& f, KEY key )
{
  if (key == K_TAB && f.focusdirty())
  {
    TLocalisamfile & list = ((TEdit_field &) f).browse()->cursor()->file();
    const TDate datadoc(f.mask().get(F_DATADOC));
    const TDate datascad(list.get_date("VALFIN"));
    
    if (datascad.ok() && datadoc > datascad)
    {     
      const TString16 codsucc(list.get("CODLISSUCC"));
      
      if (codsucc.empty())
        return error_box("Listino scaduto il %s", datascad.string());
      else    
      {
        f.set(codsucc);
        f.set_focusdirty();
        ((TEdit_field &)f).check();
      }
    }
  }
  return TRUE;
}

bool TDocumento_mask::codcont_handler( TMask_field& f, KEY key )
{
  if (key == K_TAB && f.focusdirty())
  {            
    TLocalisamfile & cont = ((TEdit_field &) f).browse()->cursor()->file();
    const TDate datadoc(f.mask().get(F_DATADOC));
    const TDate datascad(cont.get_date("VALFIN"));
    
    if (datascad.ok() && datadoc > datascad)
      return error_box("Contratto scaduto il %s", datascad.string());
  }
  return TRUE;
}

bool TDocumento_mask::codcamp_handler( TMask_field& f, KEY key )
{
  if (key == K_TAB && f.focusdirty())
  {
    TLocalisamfile & camp = ((TEdit_field &) f).browse()->cursor()->file();
    const TDate datadoc(f.mask().get(F_DATADOC));
    const TDate datascad(camp.get_date("VALFIN"));
    
    if (datascad.ok() && datadoc > datascad)
      return error_box("Offerta scaduta il %s", datascad.string());
  }
  return TRUE;
}