campo-sirio/ve/ve0100.cpp

#include <execp.h>
#include <defmask.h>
#include <tabutil.h>
#include <utility.h>

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

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

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

void TMotore_application::init_query_mode( TMask& m )
{
  disable_menu_item(M_FILE_PRINT);

  _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 )
{
  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);

  TDocumento_mask& dm = (TDocumento_mask&)m;
  TDocumento& curdo = dm.doc();

  curdo.read(provv, anno, codnum, numdoc);
  curdo.set_tipo(m.get(F_TIPODOC));

  const char stato = curdo.tipo().stato_finale_inserimento();
  curdo.stato(stato);

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

  // Giro per supplire alla mancanza di una TMask::set(short id, char c);
  char str_stato[2] = { stato, '\0' }; 
  m.set(F_STATO, str_stato);

  const TString16 data_doc(m.get(F_DATADOC));

  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);
  
  pos = m.id2pos(F_CAUSMAG);         
  
  if (pos >= 0)
  {
    m.fld(pos).set(curdo.tipo().caus_mov());
    m.fld(pos).dirty();
  }

  TTipo_documento& tp = (TTipo_documento&) curdo.tipo();
  tp.set_defaults(m);
  
  m.disable(DLG_ELABORA);
}

void TMotore_application::init_modify_mode( TMask& m )
{                
  static TString80 __last_key;

  enable_menu_item(M_FILE_PRINT);
  m.enable(DLG_PRINT);
  m.enable(DLG_ELABORA); 
  m.disable(F_STATO);
  TString80 key;
  key << m.get(F_CODNUM);
  key << m.get_int(F_ANNO);
  key << m.get(F_PROVV)[0];
  key << m.get_long(F_NDOC);
  if (!doc().modificabile()) 
  {     
    if (key != __last_key)
      warning_box("Documento non modificabile.");
    m.disable(DLG_SAVEREC);
  }   
  __last_key = key;
}

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

bool TMotore_application::changing_mask( int mode )
{
  static int lastmode = NO_MODE;

  const bool change = ( mode != lastmode );
  lastmode = mode;
  return change;
}

TMask* TMotore_application::get_mask( int mode )
{
  switch ( mode )
  {
    case MODE_INS:
    case MODE_MOD:
      {
        const TString16 tipodoc(_msk->get(F_TIPODOC));
        _docmsk = (TDocumento_mask*)_doc_masks.objptr(tipodoc);

        if (_docmsk == NULL)
        {
          _docmsk = new TDocumento_mask(tipodoc); 
          _doc_masks.add(tipodoc, _docmsk);
        }
      }
      return _docmsk;
      break;
    default:
      return _msk;
      break;
  }
}

const char* TMotore_application::get_next_key( )
{
  TMask& m = curr_mask( );
  TCodice_numerazione cod_num(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", cod_num.codice());
    doc.put("ANNO", m.get(F_ANNO));
    doc.put("PROVV", m.get(F_PROVV));
      
    const TRectype cmp_rec(doc.curr());   // record campione
  
    doc.put( "NDOC", 9999999L );
    if (doc.read(_isgreat) == NOERR)
      doc.prev();
    else
      doc.last();

    const long num = ((doc.curr() == cmp_rec) ? doc.get_long( "NDOC" ) : 0) + 1;
    key.format( "%d|%d", F_NDOC, num);          
  }
  return TRUE;
}

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).doc2mask();

  return NOERR;
}

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

int TMotore_application::rewrite( const TMask& m ) // C 90
{
  TDocumento& d = (TDocumento &) _rel->curr();
  d = ((TDocumento_mask&)m).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, LF_SVRIEP, LF_AGENTI, LF_PERCPROV, 0);
  _rel->lfile().set_curr(new TDocumento);

  _msk = new TMask("ve0100a");
  set_search_field(F_NDOC);

  query_mask().set_handler( F_CODNUM, TDocumento_mask::num_handler );
  query_mask().set_handler( F_TIPODOC, TDocumento_mask::tip_handler );
  
  TConfig utente( CONFIG_USER );
  _codnum = utente.get("CODNUM");
  _tipodoc = utente.get("TIPODOC");
  
  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;

  // Distruggo la relazione
  delete _rel;
//  delete _condv;

  return TRUE;
}

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

void TMotore_application::ini2mask(TConfig& ini, TMask& msk, bool query)
{
  TRelation_application::ini2mask(ini, msk, query); // Default processing

  TMask_field& campo = msk.field(F_TIPODOC);
  TString16 str = campo.field()->read(ini, format("%d", LF_DOC));
  if (str.not_empty())
    campo.set(str);

  if (query)
  {
  }
  else
  {
    TSheet_field& f = msk.sfield(F_SHEET);
    TTipo_riga_documento tr;

    // Scorre tutti i paragrafi delle righe documento
    TMaskmode oldmode= (TMaskmode)msk.mode();  

    msk.set_mode(MODE_MOD);  
    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 ..
            if (stricmp(key, RDOC_TIPORIGA) != 0)   // ... ed il tipo 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);
      }
    }
    msk.set_mode(oldmode);  
  }
}

void TMotore_application::print()
{
  if (save(TRUE))   // Registra il record corrente
  {
    TString commandline("ve1 -0 ");

    TDocumento_mask& m = edit_mask();
    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 (m.doc().stampabile())
    {
      const char s[2] = { m.doc().tipo().stato_finale_stampa(), '\0'};
      m.set(F_STATO, s, TRUE);
    }
  }
}

int ve0100( int argc, char** argv )
{
  TMotore_application a;

  a.run( argc, argv, "Gestione documenti" );
  return 0;
}