#include "ve0100.h"
#include "ve0100o.h"                                                      
#include "veini.h"

#include <execp.h>
#include <modaut.h>
#include <tabutil.h>
#include <urldefid.h>

#include "veuml.h"
#include "veuml1.h"
#include "verig.h"

#include "sconti.h"
#include "utility.h"
#include "..\mg\mglib.h"


void TMotore_application::init_query_mode( TMask& m )
{
  _msk->set( F_CODNUM, _codnum); 
  _msk->field(F_CODNUM).set_focusdirty(TRUE);
  _msk->field(F_CODNUM).on_key(K_TAB);
  _msk->field(F_CODNUM).set_dirty(FALSE);
       
  _msk->set( F_TIPODOC, _tipodoc, TRUE); 
}

void TMotore_application::init_insert_mode( TMask& m )
{
  TString tipocf( "A" );
  tipocf[ 0 ] = app().tipocf();  

  const TString16 codnum(m.get(F_CODNUM));
  const int anno = m.get_int(F_ANNO);
  const char provv = m.get(F_PROVV)[0];
  const long numdoc = m.get_long(F_NDOC);
  
  _doc->read(provv, anno, codnum, numdoc);
  _doc->set_tipo(m.get(F_TIPODOC));
  
  _codnum = codnum;
  _tipodoc = m.get(F_TIPODOC);
  

  m.field(F_CODNUM).set_focusdirty(TRUE);
  m.field(F_CODNUM).on_key(K_TAB);
  m.field(F_TIPODOC).set_focusdirty(TRUE);
  m.field(F_TIPODOC).on_key(K_TAB);   
  m.set(F_STATO, _doc->stato());
  const TString16 data_doc(m.get( F_DATADOC));
    
  const int pos = m.id2pos( F_DATACAMBIO1);
  
  if (pos >= 0 && m.fld(pos).active())
  {
    m.fld(pos).set(data_doc);    
    m.fld(pos).dirty();
  }
  m.disable(DLG_PRINT);
  _occas_mask->reset( );
  const int ndefaults = pro( ).get_int( "NDEFAULTS", "DEFAULT" );          // prof
  
  for( int i = 1; i <= ndefaults; i++ )
  {
     TString16 chiave;
     chiave.format( "%d", i );
     TToken_string valore( pro( ).get( chiave, "DEFAULT" ) );
     int campo( valore.get_int( 0 ) );
     TString default_val( valore.get( 1 ) );
     m.set( campo, default_val, TRUE );
  }
}

void TMotore_application::init_modify_mode( TMask& m )
{
  m.enable(DLG_PRINT);               
}

void TMotore_application::update_profile()
{
  TFilename fn(_doc->tipo().profile_name());
  
  fn.ext("ini");
  if (_pro && _pro->name() != fn) 
  {
    delete _pro;    
    _pro = NULL;
  }
  if (_pro == NULL) 
    _pro =  new TConfig( fn );
}

int TMotore_application::user_function(int index)
{
  switch(index)
  {  
    case 1:
      break;
    default:
      yesnofatal_box( "Chiamata ad una procedura utente non definita: %d", index );
      return NOERR;
      break;
  }
  return NOERR;      
}

// Funzione che dato il profilo di riga ottiene la maschera
// Serve per ottenere una maschera diversa per ogni riga
TMask * TMotore_application::ss_getmask( int numriga, TMask& fullmask)
{     
  const int n = numriga + 1;
  if (n <= app()._doc->physical_rows())
  {
    TRiga_documento & riga = (*(app()._doc))[numriga + 1];
      
    return ((TTipo_riga_documento &)riga.tipo()).mask(); 
  }
  else
    return &fullmask;
}

void TMotore_application::user_set_handler( int fieldid, int index, TMask* m )
{
  if ( !m )
    m = &edit_mask( );
  switch( index )
  { 
  case 1:
    m->set_handler( fieldid, ora_hndl );
    break;
  case 3:
    m->set_handler( fieldid, dummy_hndl );
    break;
  default:
    CHECK( FALSE, "Tentativo di installare un handler non definito" );
    break;
  }
}

bool TMotore_application::ss_handler( TSheet_field& ss, int r, KEY key )

{ 
  if ( key == K_ENTER ) // modifica
  {
    TRiga_documento & riga = (*(app()._doc))[r + 1];
    
    riga.autosave(ss);
  }
  else
    if ( key == K_DEL ) // Cancellazione 
    {
      app()._doc->destroy_row(r + 1, TRUE);
      if (r < app()._doc->rows())
      {
        TRiga_documento & riga = (*(app()._doc))[r + 1];
        if (riga.is_omaggio() && riga.is_generata())
        {
          ss.destroy(r + 1);
          app()._doc->destroy_row(r + 1, TRUE);
        }
      }
    }
    else
      if (key == K_INS) // Inserimento              
      {
        if (r < app()._doc->rows())
        {
          TRiga_documento & riga = (*(app()._doc))[r + 1];
          if (riga.is_omaggio() && riga.is_generata())
            return FALSE;
        }
        TMask & emask = app().edit_mask();             
        app()._doc->insert_row(r + 1, emask.get( F_LBTIPORIGA ));
      }
      else     
        if (key == K_CTRL + K_INS)
        {
          TRiga_documento & riga = (*(app()._doc))[r + 1];
          TRectype & ven_rec = app().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 = app()._std_mag;
            s.left_just(3);
            s << app()._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;
}

bool TMotore_application::num_handler( TMask_field& f, KEY key )
{                       
  // Ottengo la maschera             
  TMask& m = f.mask( ); 
  
  if (key == K_TAB && f.to_check(key, TRUE))
  {                          
    TTable & tabnum  = ((TTable &) ((TEdit_field &)f).browse()->cursor()->file());
    if ( tabnum.good()) 
    {         
      if (app()._cod_num)
       delete app()._cod_num;
      app()._cod_num = new TCodice_numerazione(tabnum.curr());
      TCodice_numerazione * c = app()._cod_num;
      m.set( F_DESNUM, c->descrizione());
      // Propone il primo tipo di documento come default
      m.set( F_TIPODOC, c->tipo_doc(0));
      m.send_key( K_TAB, F_TIPODOC );
      // Se per questa numerazione h abilitata le numerazione provvisoria
      if (c->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 TMotore_application::elabora_handler( TMask_field& f, KEY key )
{          
  if (key == K_SPACE)
  {
#ifndef DBG
    return message_box("Funzione in fase di implementazione");
#endif
    TString_array elabs;   
    TMask & m = f.mask();
    const TString16 tipo(m.get(F_TIPODOC));
    const TString16 stato(m.get(F_STATO));
    TLista_elaborazioni & elab = app().elab();
    
    const int items = elab.select(elabs, TRUE, m.insert_mode(), NULL, NULL, tipo, stato);   
    if (items == 0)
      return message_box("Non ci sono elaborazioni attive per questo documento");
    int selected = 0;
    if (items > 1)
    {  
      TMask selection("ve0100b");
      TList_field & f = (TList_field &) selection.field(F_SELECT);
      
      for (int i = 0; i < items; i++)
        f.add_item(format("%d|%s", i, (const char *)elab[elabs.row(i)].descrizione()));
    
      if (selection.run() == K_ENTER)
        selected = atoi(selection.get(F_SELECT));
    }            
    else
      selected = 1;  
    if (selected > 0)
      TElaborazione & e = elab[elabs.row(selected)];
  }
  return TRUE;
}

bool TMotore_application::print_handler( TMask_field& f, KEY key )

{
  if (key == K_SPACE)                       
  {
    TMask& m = f.mask();
    
    if (app().save(TRUE))   // Registra il record corrente
    {
      TString commandline("ve1 -0 ");
      
      commandline << m.get(F_CODNUM) << " " << m.get(F_ANNO) << " ";
      commandline << m.get(F_PROVV) << " " << m.get(F_NDOC);
      
      TExternal_app interattivo( commandline );
                         
      interattivo.run();
      if (app().doc().stampabile())  
      {
        const char s[2] = {app().doc().tipo().stato_finale_stampa(), '\0'}; 
        
        m.set(F_STATO, s, TRUE);   
      }
    }
  }
  return TRUE;
}

bool TMotore_application::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)
      {
        f.mask().autoload(occas);
        f.mask().send_key(K_TAB, O_COMUNE);         // Forza decodifica comuni
        f.mask().send_key(K_TAB, O_COMUNENAS);
      }  
    }
  } 
  return TRUE;
}  

bool TMotore_application::occas_handler( TMask_field& f, KEY key )
{
  TDocumento_mask & m = (TDocumento_mask &)f.mask();
  if ( key == K_SPACE && m.is_running( ) )
  {   
    TDocumento & doc = app().doc(); 
    TMask * occ_m = app()._occas_mask;
    TOccasionale & occ = doc.occas();  
    TCli_for & cli_for = doc.clifor();
    for (int i = occ_m->fields() - 1; i >= 0; i--)
    {
      TMask_field & f = occ_m->fld(i);
      const TFieldref * c = f.field();
      if (c)
        f.set(c->read(occ));
    } 
    if (occ_m->run() != K_ESC)         
    {            
      const TString80 ocfpi(occ_m->get(O_CODICE));
      doc.put("OCFPI", ocfpi);
      m.set(F_OCFPI, ocfpi);
      for (int i = occ_m->fields() - 1; i >= 0; i--)
      {
        TMask_field & f = occ_m->fld(i);
        TFieldref * c = (TFieldref *) f.field();
        if (c)
          c->write(f.get(), occ);
      } 
      m.occ2mask(occ);
    }
    f.set_focus( );
  }  
  return TRUE;
}


bool TMotore_application::tip_handler( TMask_field& f, KEY key )
{                       
  TMask& m = f.mask( );
  if ( key == K_TAB && m.is_running( ) && m.get(F_TIPODOC).not_empty())
  {                          
    const TString16 tipo(f.get());
    TCodice_numerazione * c = app()._cod_num;
    int last = c->ntipi_doc();
    for (int i = 0; i < last; i++ )
    {
      const TString16 curtipo(c->tipo_doc(i));
      if (curtipo == tipo)
       return TRUE;
    }
    return message_box( "Tipo non valido per la numerazione selezionata!" );
  }
  return TRUE;
}


bool TMotore_application::clifo_handler( TMask_field& f, KEY key )
{                
  if (key != K_ENTER && f.to_check(key, TRUE))        
  { 
    TDocumento & d = app().doc();
    TDocumento_mask & m = (TDocumento_mask &) f.mask();
    const TString & val = f.get();
  
    d.put("TIPOCF", app().tipocf());
    d.put("CODCF", atol(val));
                                               
    app().doc().clifor().put(CLI_CODCF, ""); // force reload
    TCli_for & cli_for = app().doc().clifor(); 
    TOccasionale & occas = app().doc().occas();
      
    if ( cli_for.get_bool("SOSPESO") )
      return f.error_box( "Il codice '%ld' e' sospeso e non puo' essere utilizzato", atol(val) );  
    m.cli2mask(cli_for, occas, *(app()._config_ditta));
    if (cli_for.occasionale())
    {
      if(m.id2pos(F_OCCASEDIT) > 0 && f.to_check(key) && *(occas.codice()) == '\0')
        m.send_key( K_SPACE, F_OCCASEDIT );   // Lancia maschera occasionali        
    }
    else      
      app().doc().zero("OCFPI");
  }  
  return TRUE;
}

bool TMotore_application::changing_mask( int mode )
{ 
  static int lastmode = NO_MODE;
  
  const bool change = ( mode != lastmode );
  lastmode = mode;
  return change;  
}

void TMotore_application::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);
  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_ditta->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);
     }
}

TMask* TMotore_application::get_mask( int mode )
{     
  switch ( mode )
  {
    case MODE_INS: 
    case MODE_MOD: 
      {                
        const TString16 tipodoc(_msk->get(F_TIPODOC)); 
        
        TDocumento_mask * msk1 = (TDocumento_mask *) _doc_masks.objptr(tipodoc);
        
        _doc->set_tipo(tipodoc);
        update_profile();
        
        TString tipocf( app( ).pro( ).get( "TIPOCF", "MAIN" ) );     //prof
        app( ).tipocf( tipocf[ 0 ] );
        if (msk1 == NULL)
        {
          msk1 = new TDocumento_mask(_doc->tipo().mask_name(), _doc, _rel); // prof
          _doc_masks.add(tipodoc, msk1);
          _sheet = &( TSheet_field& )msk1->field( F_SHEET );
           sheet( ).set_notify( ss_handler );
           sheet().set_append(FALSE);
          TList_field& listbox = ( TList_field& ) msk1->field( F_LBTIPORIGA );
          const int numtr = app( ).pro( ).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);
            TString tiporiga(app().pro().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, *_pro );
          ((TVariable_sheet_field&)sheet()).set_getmask( ss_getmask );
          if (msk1->id2pos( F_OCCASEDIT ) > 0 ) 
            msk1->set_handler( F_OCCASEDIT, occas_handler );
          msk1->set_handler( F_CODCF, clifo_handler );
          msk1->set_handler( F_CODPAG, condpag_hndl );
          msk1->set_handler( F_DATAINSC, condpag_hndl );
          msk1->set_handler( F_CODNOTE, note_hndl );
          msk1->set_handler( F_DATADOC, data_hndl );
          msk1->set_handler( 99, elabora_handler );        // cazzo !!!!!!
          msk1->set_handler( DLG_PRINT, print_handler );
          int numhandler = pro( ).get_int( "NHANDLER", "HANDLERS" ); // prof
          for ( i = 1; i <= numhandler; i ++ )
          { 
            TString chiave;
            chiave.format( "%d", i );
            TToken_string riga = pro( ).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

          const bool gesval   = _config_ditta->get_bool("GESVAL");          
          const bool gescambi = _config_ditta->get_bool("GESVALAC");   
             
          if (gesval)
          {
            msk1->show(F_CODVAL, !gescambi);
            msk1->show(F_DATACAMBIO, !gescambi);
            msk1->show(F_NOMEVAL, !gescambi); 
            msk1->show(F_CODVAL1, gescambi);
            msk1->show(F_DATACAMBIO1, gescambi);
            msk1->show(F_NOMEVAL1, gescambi); 
            msk1->show(F_CAMBIO);
          }
          else
          {
            msk1->disable(F_CODVAL);
            msk1->disable(F_DATACAMBIO);
            msk1->disable(F_NOMEVAL); 
            msk1->hide(F_CODVAL1);
            msk1->hide(F_DATACAMBIO1);
            msk1->hide(F_NOMEVAL1); 
            msk1->disable(F_CAMBIO);
          }

          const bool geslin   =  _config_ditta->get_bool("GESLIN");          

          msk1->enable(F_CODLIN, geslin); 
          msk1->enable(F_DESLIN, geslin); 

          const bool geslis         =  _config_ditta->get_bool("GES", "ve", 1);          
          const bool gesliscatven   =  _config_ditta->get_bool("GESLISCV");          
         
          if (geslis)             
          {
            msk1->show(F_CODLIST, !gesliscatven);
            msk1->show(F_CODLIST1, gesliscatven);
          }
          else
          {
            msk1->disable(F_CODLIST);
            msk1->hide(F_CODLIST1);
          }

          const bool gescontr       =  _config_ditta->get_bool("GES", "ve", 2);          
          const bool gescontrcli    =  _config_ditta->get_bool("GESCONCC");          

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

          const bool gesoff        =  _config_ditta->get_bool("GES", "ve", 3);          

          msk1->enable(F_CODCAMP, gesoff);

          const bool gessco        =  _config_ditta->get_char("GESSCO") != 'N';          

          msk1->enable(F_SCONTOPERC, gessco);

          const bool gesage        =  _config_ditta->get_bool("GESAGE");          

          msk1->enable(F_CODAG, gesage);
          msk1->enable(F_DESAG, gesage);
          msk1->enable(F_CODAGVIS, gesage);
          msk1->enable(F_DESAGVIS, gesage);    
          const bool has_movmag = app().has_module(MGAUT, CHK_DONGLE) && _doc->tipo().mov_mag();
          short pos = msk1->id2pos(F_CAUSMAG);
          if (pos >= 0)
            msk1->fld(pos).show(has_movmag);
          pos = msk1->id2pos(F_DESCRMAG);
          if (pos >= 0)
            msk1->fld(pos).show(has_movmag);
        }                           
        else
          _sheet = &( TSheet_field& )edit_mask( ).field( F_SHEET );
        return msk1;
      }
      break; 
    default:
      return _msk;
      break;
  }
}

const char* TMotore_application::get_next_key( )
{ 
  TToken_string key;
  TMask& m = curr_mask( );
  const TString16 value = m.get( F_CODNUM );

      // Se per questa numerazione h abilitata le numerazione automatica 
  if( _cod_num->auto_num())
  {
    TLocalisamfile doc(LF_DOC);
    doc.zero();
    doc.put("CODNUM", value);
    doc.put("ANNO", m.get(F_ANNO));
    doc.put("PROVV", m.get(F_PROVV));
      
    TRectype cmp_rec(doc.curr());   // record campione
  
    doc.put( "NDOC", 9999999L );
    if (doc.read(_isgreat) == NOERR) 
      doc.prev();                                                          
  
    const long num = ((doc.curr() == cmp_rec) ? doc.get_long( "NDOC" ) : 0) + 1;
      
    key.format( "%d|%d", F_NDOC, num);          
  }
  return key;
}

int TMotore_application::read(TMask& m)
{                            
//    m.autoload(*_rel);
    TRelation_application::read(m);
    *_doc = (TDocumento &) _rel->curr();
    _codnum = m.get(F_CODNUM);
    _tipodoc = m.get(F_TIPODOC);
    ((TDocumento_mask &)m).cli2mask(app().doc().clifor(), app().doc().occas(), *(app()._config_ditta));

    TSheet_field& f = ( TSheet_field& ) m.field( F_SHEET );

    f.destroy( ); 
    const int rows = _doc->physical_rows();
    for (int i = 1; i <= rows; i++)
    { 
      f.insert(-1, FALSE);                                   
      TToken_string & r = f.row(i-1);
      TRiga_documento & rec = (*_doc)[i];
      rec.autoload(f);   
      f.check_row(i - 1);
    }            
   return NOERR;
}

int TMotore_application::write( const TMask& m )  // C 90
{ 
  TDocumento & doc = (TDocumento &) _rel->curr();
  
  doc = *_doc;
  return TRelation_application::write(m);
}

int TMotore_application::rewrite( const TMask& m ) // C 90
{
  TDocumento & doc = (TDocumento &) _rel->curr();
  
  doc = *_doc;
  return TRelation_application::rewrite(m);
}

// Riempie lo sheet con le righe documento specificate nel .ini
void TMotore_application::ini2mask(TConfig& ini, TMask& msk, bool query)
{ 
  TRelation_application::ini2mask(ini, msk, query); // Default processing
  if (query)
  { 
  }
  else
  {
    TSheet_field& f = msk.sfield(F_SHEET);
    TTipo_riga_documento tr;
    
    // Scorre tutti i pragrafi delle righe documento
    for (int i = 1; ini.set_paragraph(format("%d,%d", LF_RIGHEDOC, i)); i++)
    {                                     
      // Considera solo i tipi riga validi
      const TString16 tipo = ini.get(RDOC_TIPORIGA);
      if (tr.read(tipo) == NOERR)
      {                                   
        // Crea una nuova riga documento
        TRiga_documento& rec = _doc->new_row(tipo);
        // Riempie i campi della nuova riga
        TAssoc_array& var = ini.list_variables();
        FOR_EACH_ASSOC_STRING(var, obj, key, val)
        {
          if (stricmp(key, RDOC_NRIGA) != 0)   // Ignora il numero riga
            rec.put(key, val);    
        }
        // solo la insert chiama la post_insert necessaria alla disabilitazione verifichiamo
        // l'autoload ??
//        f.insert(-1, FALSE);                                   
        // Aggiunge la riga allo sheet
        rec.autoload(f);
        f.check_row(rec.numero()-1);
      }  
    }            
  }
}


void TMotore_application::open_files(int logicnum, ...)  
{  
  va_list marker;
  va_start(marker, logicnum);
  while (logicnum > 0)
  {
    CHECKD(_file.objptr(logicnum) == NULL, "File gia' aperto: ", logicnum);
    _file.add(new TLocalisamfile(logicnum), logicnum);
    logicnum = va_arg(marker, int);
  }
}

void TMotore_application::on_firm_change()
{       
  if (_config_ditta != NULL)
    delete _config_ditta;
  _config_ditta = new TConfig(CONFIG_DITTA);
  condv().set_config(_config_ditta);
  _doc_masks.destroy();
  TApplication::on_firm_change();
}

bool TMotore_application::user_create( )
{  
  _config_ditta = new TConfig(CONFIG_DITTA);

  // Metto in relazione testata e righe
  _rel = new TRelation( LF_DOC );
  open_files(LF_RIGHEDOC, LF_CONDV, LF_RCONDV, LF_ANAMAG, LF_SCONTI, LF_UMART, LF_TAB, LF_TABCOM, LF_CLIFO,
             LF_CFVEN, LF_INDSP, LF_OCCAS, LF_MOVMAG, LF_RMOVMAG, 0);
  _doc = new TDocumento;
  _rel->lfile().set_curr(new TDocumento);
  _cod_num = NULL;
  
  _condv = new TCond_vendita(&doc().clifor(), _config_ditta);
  _doc->set_condv(_condv);
  ((TDocumento &) _rel->curr()).set_condv(_condv);
  _msk = new TMask("ve0100a");  
  set_search_field(F_NDOC);

  query_mask().set_handler( F_CODNUM, num_handler );
  query_mask().set_handler( F_TIPODOC, tip_handler );
  _occas_mask = new TMask("ve0100o"); 
  _occas_mask->set_handler( O_CODICE, occas_code_handler );
  TConfig utente( CONFIG_USER );

  _codnum = utente.get("CODNUM");
  _tipodoc = utente.get("TIPODOC");
  
  // La maschera di inserimento/modifica per ora non la so!
  // Viene letta dal profilo non appena trovato il record
  
  TMagazzini m;
  
  _ges_mag = m.gestmag();
  _ges_dep = m.gestdep();  
  
  _std_mag = m.standardmag();
  _std_dep = m.standarddep();

  return TRUE;
}

bool TMotore_application::user_destroy( )
{              
  // Registro l'ultimo tipo documento e l'ultima numerazione
  TConfig utente( CONFIG_USER );
  utente.set( "CODNUM", _codnum, "ve" );
  utente.set( "TIPODOC", _tipodoc, "ve" );

  if (_config_ditta != NULL)
    delete _config_ditta;
  // Distruggo la maschera di modifica
  if ( _msk != NULL )
    delete _msk;
  if (_cod_num)
    delete _cod_num;
  
  // Distruggo la relazione
  delete _doc;
  delete _rel;
  delete _condv;

  return TRUE;
}    

int TMotore_application::stato_corrente( )
{                                   
  return edit_mask().get_int(F_STATO);
}

int ve0100( int argc, char** argv )
{
  TMotore_application a;
  
  a.run( argc, argv, "Gestione documenti" );
  return 0;
}