campo-sirio/m770/771200.cpp

//////////////////////////////////////////
// 771200.cpp - Quadro A   771mod -7 A  //
//            - Quadro A1  771mod -7 1  //
//            - Quadro A2  771mod -7 2  //
//            - Quadro A3  771mod -7 3  // 
//            - Quadro AB  771mod -7 4  //
////////////////////////////////////////// 
#include <relapp.h>
#include <config.h>
#include <msksheet.h>
#include <sort.h>
#include <tabutil.h>
#include <progind.h>   
#include <execp.h>  
#include <nditte.h>
#include <defmask.h>
#include "77lib.h"
#include "dipend.h"
#include "quadroa.h"
#include "quadroa3.h" 
#include "soctrasf.h"
#include "771200.h" 
#include "774200.h"
#include "77qaall.h"

bool QA_cerca_codA(const long codditta, const long coddip, const int curprog, TString16 ret, TString quadro);

bool QA_cerca_codA(const long codditta, const long coddip, const int curprog, TString16 ret, TString quadro)
{
  TLocalisamfile qq(quadro == "AB" ? LF_QUAAB : LF_QUAA2);  
  qq.zero();
  qq.put("CODDITTA", codditta);
  qq.put("CODDIP", coddip);
  TRectype dep(qq.curr());
  for (qq.read() ;!qq.eof() && qq.curr() == dep ; qq.next())
  {
    // non prendo in considerazione se stesso
    if (qq.get_int("NPROG") == curprog)
    	continue;    
    	
    // leggo rettifica conguaglio
    TString16 retx(qq.get("RETCON"));
    
    // se rettifica A controllo se esiste un record con rettifica A,C,D,E,F	
    if (ret == "A")
    	if (retx == "A" || retx == "C" || retx == "D" || retx == "E" || retx == "F")
      	return TRUE;                                                        
    // se rettifica C,D,E,F controllo se esiste un qualsiasi altro record
    if (ret == "C" || ret == "D" || ret == "E" || ret == "F")
     	return TRUE;
  }
  return FALSE;
}

class TQuadroA : public TRelation_application
{
  private:                                             
    TString          _quadro;    // Codice del quadro in gestione        
    bool             _registra;  // Se TRUE fa i riporti
    TRelation*       _rel;
    TMask*           _msk[2];
    TMask*					 _mskAllegati;  // maschera allegati 730 (AB e A2)
    long             _coddip;
    char             _tipoq;
    int              _nproga;
    int              _mode;
    int              _anno_dic;  // anno dichiarazione
    TLocalisamfile*  _qd, *_base;
    TRiporti         _rip;
    int              _file;
    bool             _soc_trasf; 
    TString          _cognome,_nome;	// dati soc.trasf.
    
  private:                                    
// Handler relativi ai quadri A - A1 - A2 - A3 - AB  
    static bool nprog_handler     (TMask_field& f, KEY key);
    static bool codanagr_handler  (TMask_field& f, KEY key);
    static bool codditta_hnd      (TMask_field& f, KEY key);    
    static bool setta_nprog       (TMask_field& f);
    static bool QAA2alleg_handler (TMask_field& f, KEY key);    
    
// Handler relativi alla manutenzione quadro A              
		static bool QA_qaqualif_hnd   (TMask_field& f, KEY key);
    static bool QA_cfdlprec_hnd   (TMask_field& f, KEY key);
    static bool QA_totdet_hnd 		(TMask_field& f, KEY key);
    static bool QA_ammritdov_hnd	(TMask_field& f, KEY k); 
    static bool QA_qatitolo_hnd		(TMask_field& f, KEY k);
    static bool QA_A2_check_58    (TMask_field& f, KEY key);
// Handler relativi alla manutenzione quadro A3      
    static bool QA3_codip_handler     (TMask_field& f, KEY key);
    static bool QA3_base_occupazionale(TMask_field& f, KEY key);     
    void 	AA3SettaCognomeNome(TMask& m);
    
  protected:
    TString			_sCognome, _sNome;  // dati dipendente
    int				_iNprog;
    long      _codditta,_codip;

    virtual bool user_create();
    virtual bool user_destroy();
    virtual int  rewrite(const TMask& m);
    virtual int  write  (const TMask& m);  
    virtual bool remove();
    virtual TRelation* get_relation() const { return _rel; }
    virtual TMask* get_mask(int mode);
    virtual bool changing_mask(int mode);  
    virtual void init_query_mode (TMask&);
    virtual void init_query_insert_mode (TMask&);    
    virtual void init_modify_mode (TMask&);  
    virtual void init_insert_mode(TMask& m);      
    virtual void on_config_change();    
    TMask* load_mask(int n);
    int 	anno_dic() const { return _anno_dic; }
    bool	QuadroA()  const { return _quadro == "A"; }      
    bool	QuadroA1() const { return _quadro == "A1"; }      
    bool	QuadroA2() const { return _quadro == "A2"; }      
    bool	QuadroA3() const { return _quadro == "A3"; }       
    bool	QuadroAB() const { return _quadro == "AB"; }      
            
  public:                    
    bool is_societa_trasformata(TMask& m);
    void carica_record2_A3(TMask& m);
    char tipo_trasformata(long codditta);
    void registra_record2_A3(const TMask& m);
    void cancella_record2_A3();
        
    TQuadroA(char tipo);
    virtual ~TQuadroA() {};
};                    
              
// Implementazione classe TQuadroA              
              
inline TQuadroA& app() { return (TQuadroA&) main_app(); }

TQuadroA::TQuadroA(char tipo): _rel(NULL), _mode(0), _tipoq(tipo)
{  
  memset(_msk, 0, sizeof(_msk));  
}

bool TQuadroA::changing_mask(int mode)
{
 if ((mode == MODE_MOD) && (_mode == MODE_INS))
	return FALSE; 
 else	              
  return _mode != mode;
}
        
TMask* TQuadroA::get_mask(int mode)
{
  const int m = (mode == MODE_QUERY) ? 0 : 1;
  _mode = mode;
  return load_mask(m);
}

TMask* TQuadroA::load_mask(int n)
{
  if (_msk[n] != NULL) 
    return _msk[n]; 
    
  TFilename name("771200"); 
  
  if (n == 0) 
  { 
    switch (_tipoq) 
    {
      case 'A':       // Manutenzione quadro A
        name << 'a';  
        break; 
      case '1':       // Manutenzione quadro A1
        name << 'c';  
        break;
      case '2':       // Manutenzione quadro A2
        name << 'e';  
        break;        
      case '3':       // Manutenzione quadro A3
        name << 'g';  
        break;                                 
      case '4':       // Manutenzione quadro AB
        name << 'l';  
        break;                  
      default:
        break;
    }
  }
  else 
  {
    switch (_tipoq)
    {
      case 'A':       // Manutenzione quadro A
        name << 'b';
        break;
      case '1':       // Manutenzione quadro A1
        name << 'd';
        break;
      case '2':       // Manutenzione quadro A2
        name << 'f';
        break;
      case '3':       // Manutenzione quadro A3
        name << 'h';
        break;                                 
      case '4':       // Manutenzione quadro AB
        name << 'm';
        break;          
      default:
        break;
    }
  }  
  
  TMask* m = new TMask(name);

  switch (n)
  {                                   
    case 0:
      if (m)
      {        
        m->set_handler(QAF_CODDITTA,   codditta_hnd); 
        if (QuadroA3())
        {
          m->set_handler(F_CODANAGDIP,  QA3_codip_handler); 
          m->set_handler(F_CODIPQUADRO, QA3_codip_handler);
          m->set_handler(F_BASEOCCUPA, QA3_base_occupazionale);
        }                                                       
        else 
        { 
          if (QuadroAB())
            m->set_handler(QAF_ALLEG_A,   QAA2alleg_handler);
          if (QuadroA2())
            m->set_handler(QA2F_ALLEG_A2, QAA2alleg_handler);
          m->set_handler(QAF_NPROG,         nprog_handler);
          m->set_handler(F_CODANAGDIP,      codanagr_handler);  
          m->set_handler(F_CODANAGDIPQA,    codanagr_handler);  
        }
      }
      break;
    case 1:                                 
      m->disable(DLG_FINDREC);    
      if (m)
      { 
        if (QuadroA2())
          m->set_handler(QA2F_RETCON,  QA_A2_check_58);    
        if (QuadroAB())
          m->set_handler(F_RETCON56,  QA_A2_check_58);         
          
        if (QuadroA())
        {
          m->set_handler(F_CODFISDL,   QA_cfdlprec_hnd);    
          m->set_handler(F_QAQUALIF,   QA_qaqualif_hnd);
          m->set_handler(F_DETCC,      QA_totdet_hnd);    
          m->set_handler(F_DETFC,      QA_totdet_hnd);    
          m->set_handler(F_DETAF,      QA_totdet_hnd);    
          m->set_handler(F_DETLD,      QA_totdet_hnd);    
          m->set_handler(F_DETO,       QA_totdet_hnd);
			    m->set_handler(F_AMRIOT37,	 QA_ammritdov_hnd);
			    m->set_handler(F_AMRIODL38,  QA_ammritdov_hnd);           
			    m->set_handler(F_ECCRITRIMB, QA_ammritdov_hnd); 
			    m->set_handler(F_COBBDIP44,	 QA_qatitolo_hnd); 
			    m->set_handler(F_AMMIMP45,	 QA_qatitolo_hnd); 
			    m->set_handler(F_DETIMPOS46, QA_qatitolo_hnd); 
			    m->set_handler(F_RITESEG47,  QA_qatitolo_hnd);
        }
      }
      break;
    default:
      break;  
  }           
  if (QuadroA3()) 
    set_search_field(F_CODIPQUADRO);
  else
    set_search_field(QAF_NPROG);
  return _msk[n] = m;
}
			
        
bool TQuadroA::is_societa_trasformata(TMask& m)
{
  TLocalisamfile soc (LF_SOCTRASF);
  soc.setkey(1);
  soc.zero();
  soc.put(SOC_CODDITTA, m.get_long(QAF_CODDITTA));
  if (soc.read() == NOERR)
  {
    _cognome = soc.get(SOC_DENOMIN);
    _nome    = soc.get(SOC_NOME);
    return TRUE;
  }
  return FALSE;
}

// Ricerca e output dell'ultimo nprog del percipiente scelto
bool TQuadroA::setta_nprog(TMask_field& f)
{
  long  nprog = 0L;
  const long coddip   = atol(f.get());
  const long codditta = get_firm_770();
  
  TLocalisamfile quadro(app()._file);
    
  quadro.zero();
  quadro.put("CODDITTA", codditta);
  quadro.put("CODDIP",    coddip);
    
  TRectype rec(quadro.curr());
    
  quadro.read();
    
  if (quadro.curr() > rec) 
  {
    f.mask().set(QAF_NPROG, nprog+1);
    return TRUE;
  }
      
  for ( ; !quadro.eof(); quadro.next())   
  {
    if (quadro.curr() > rec) break;
    nprog = quadro.get_long("NPROG");
  }

  if ( (is_erede(codditta,coddip)) && (nprog + 1) > 1)
    return f.error_box("Il dipendente selezionato e' un erede: non e'\n possibile indicare piu' di un rigo");
    
  f.mask().set(QAF_NPROG, nprog+1);
  return TRUE;
}

bool TQuadroA::codditta_hnd(TMask_field& f, KEY k)
{         
  if (k == K_TAB && !f.mask().is_running())
  {
    TString16 codditta; codditta << app()._codditta;
    if (codditta != "0")        
    {
      f.set(codditta);
      f.check();
    }
  }   
  return TRUE;                                           
}

bool TQuadroA::codanagr_handler(TMask_field& f, KEY k)
{
  if (!f.mask().is_running())
    return TRUE;
  
  if (k == K_TAB && f.focusdirty())
  {
    const long coddip   = atol(f.get());
    if (coddip != 0L)   
    {
      const long codditta = get_firm_770();
      if (!esiste_dipendente(codditta, coddip))
        return f.warning_box("Dipendente inesistente");
      else
        setta_nprog(f);
    }
  }
  return TRUE;
}

void TQuadroA::AA3SettaCognomeNome(TMask& m)
{
  const int iDlgCognome = QAF_COGNOME;
  const int iDlgNome    = QAF_NOME;
  const int iDlgNProg   = QAF_NPROG;
  const int iProg  = m.get_int(iDlgNProg);
  TString sCognome(m.get(iDlgCognome));
  TString sNome;
  if (app()._codip != 0L) 
  {
    TLocalisamfile dip (LF_DIPEND);
    dip.zero();
    dip.put(DIP_CODDITTA, app()._codditta);
    dip.put(DIP_CODIP,    app()._codip);
    if (dip.read() == NOERR)
    {
      sCognome = dip.get("COGNOME");
      sNome    = dip.get("NOME");    
      app()._sCognome = sCognome;
      app()._sNome    = sNome;
      app()._iNprog   = iProg;
      m.set(iDlgCognome, sCognome);
      m.set(iDlgNome,    sNome);
    }
  }  
}

bool TQuadroA::QAA2alleg_handler(TMask_field& f, KEY k)
{
  if (k==K_SPACE)       
  {        
    KEY kAll;
    if (app().QuadroAB())  
    {
      const long lNumAllA = app()._base->get_long("N730ALLA");
      TString sNumAll; sNumAll << lNumAllA;      
      app()._mskAllegati->hide(QA2_ANNO_ALL);
      app()._mskAllegati->show(QA_ANNO_ALL);      
      app()._mskAllegati->hide(QA2_NUM_ALL);
      app()._mskAllegati->set(QA_NUM_ALL, sNumAll);                    
      app()._mskAllegati->show(QA_NUM_ALL);                              
    }
    else                                                       
    {
      const long lNumAllA2 = app()._base->get_long("N730ALLA2");    
      TString sNumAll; sNumAll << lNumAllA2;
      app()._mskAllegati->hide(QA_ANNO_ALL);
      app()._mskAllegati->show(QA2_ANNO_ALL);      
      app()._mskAllegati->hide(QA_NUM_ALL);    
      app()._mskAllegati->set(QA2_NUM_ALL, sNumAll);                    
      app()._mskAllegati->show(QA2_NUM_ALL);              
    }
    app()._mskAllegati->open_modal(); 
    kAll = app()._mskAllegati->run();    
    
    if (kAll == K_ESC && 
    		app()._mskAllegati->dirty() &&
    		!yesno_box("Annullare i dati inseriti"))
			kAll = K_ENTER;   
			 
    if (kAll==K_ENTER)
    {
      if (app().QuadroAB())
      {
        TString sAll (app()._mskAllegati->get(QA_NUM_ALL));
        app()._base->put("N730ALLA", sAll);
      }                                                    
      else
      {
        TString sAll (app()._mskAllegati->get(QA2_NUM_ALL));
        app()._base->put("N730ALLA2", sAll);
      }
      app()._base->rewrite();
    }
    app()._mskAllegati->close_modal(); 
  }
  return TRUE;
}

// Passa al modo inserimento/modifica.
bool TQuadroA::nprog_handler(TMask_field& f, KEY key)
{
  if (!f.mask().is_running()) return TRUE;

  if (key == K_CTRL+K_TAB)
  {
    f.set_dirty();
    return TRUE;
  }
  
  if (key == K_TAB)   
  {
    const int nprog = atoi(f.get());
    if (nprog==0) 
      return TRUE;

    const long coddip   = f.mask().get_long(F_CODIP);
    const long codditta = get_firm_770();

    if ( (is_erede(codditta,coddip)) && nprog > 1)
      return f.error_box("Il dipendente selezionato e' un erede: non e'\n possibile indicare piu' di un rigo");
    else                            
    {       
      app()._codip = coddip;
    }                                   
  }                                   
  return TRUE;
}

bool TQuadroA::QA3_codip_handler(TMask_field& f, KEY key)
{
  if (!f.mask().is_running()) return TRUE;
    
  if ((key == K_TAB) && f.shown)   
  {
    const long coddip   = atol(f.get());
    if (coddip==0) return TRUE;    
    const long codditta = get_firm_770();
    if (!esiste_dipendente(codditta, coddip))
      return f.warning_box("Dipendente inesistente");
    f.mask().set(QAF_NPROG, 1);                           
  }                                   
  return TRUE;
}


// handler QAQUALIF
bool TQuadroA::QA_qaqualif_hnd(TMask_field& f, KEY k)
{
  // forzo qualifica 11 se il dipendente ha indicato il deceduto 
  // e disabilito il campo
  if (k == K_TAB) 
  {
    TLocalisamfile dip(LF_DIPEND);
    dip.setkey(1);
    dip.zero();
    dip.put("CODDITTA", app()._codditta);
    dip.put("CODDIP", app()._codip);
    long dipdec = 0L;
    if (dip.read() == NOERR)
      dipdec = dip.get_long("CODDIPDEC");
    if (dipdec)
    {
    	f.set(11); 
    	f.disable();
    }	
  }  	   
  return TRUE;
}

// handler CFDLPREC
bool TQuadroA::QA_cfdlprec_hnd(TMask_field& f, KEY k)
{
  // obbligatorio se qualifica 11
  if (k == K_TAB)
    if (f.mask().get_int(F_QAQUALIF) == 11)
    {
    	TString tmp = f.get();
    	if (tmp.empty())
      	return f.warning_box("Codice fiscale precedente datore di lavoro obbligatorio");                
    }   
  return TRUE;
}

// handler AMMRITDOV
bool TQuadroA::QA_ammritdov_hnd(TMask_field& f, KEY k)
{
  if (k==K_TAB)
  { 
    TMask& m = f.mask();
    real c39 = m.get_real(F_AMRIOT37);
    real c40 = m.get_real(F_AMRIODL38);           
    real c41 = m.get_real(F_ECCRITRIMB);    
    real c42 = c39 + c40 - c41;
    if (c42 < ZERO) c42 = ZERO;
    m.set(F_AMMRITDOV, c42);
  }
  return TRUE;
}
                    
// handler QATITOLO
bool TQuadroA::QA_qatitolo_hnd(TMask_field& f, KEY k)
{
  if (k==K_TAB)
  { 
    TMask& m = f.mask();
    real A45 = m.get_real(F_COBBDIP44);
    real A46 = m.get_real(F_AMMIMP45);           
    real A47 = m.get_real(F_DETIMPOS46);     
    real A48 = m.get_real(F_RITESEG47);    
    real TOT = A45 + A46 + A47 + A48;
    if (TOT != ZERO)
    	m.enable(F_QATITOLO);
    else
    	m.disable(F_QATITOLO);
  }
  return TRUE;
}                    

bool TQuadroA::QA_A2_check_58(TMask_field& f, KEY k)
{
  if (f.to_check(k,TRUE))
  {
    TMask& m = f.mask();
    TString16 cod(f.get());
    const long codditta = m.get_long(QAF_CODDITTA);
    const long coddip   = m.get_long(F_CODIP);     
    const int  curprog	= m.get_int(QAF_NPROG);	
    
    // controllo se st<73> immettendo un quadro con rettifica A
    // che non ne esista gi<67> uno con rettifica A,C,D,E,F
    if (cod == "A")
      if (QA_cerca_codA(codditta, coddip, curprog, cod, app()._quadro))
        return f.error_box("Esiste gi<67> un quadro con rettifica A,C,D,E oppure F per questo dipendente");
      
    // controllo se st<73> immettendo un quadro con rettifica C,D,E,F
    // che non ne esista nessun altro record
    if (cod == "C" || cod == "D" || cod == "E" || cod == "F")
      if (QA_cerca_codA(codditta, coddip, curprog, cod, app()._quadro))
        return f.error_box("Esiste gi<67> un altro quadro per questo dipendente");
    
    // se rettifica A abilito pagina relativa operazioni di conguaglio 
    if (cod == "A") 
    {    
    	m.enable_page(5);
    	// controllo se compilato pagina operazioni di conguaglio
    	real ABB19 = m.get_real(F_QABRCB19);   
    	real ABB20 = m.get_real(F_QABRCB20);  
    	real ABB21 = m.get_real(F_QABRCB21);  
    	real ABB22 = m.get_real(F_QABRCB22);  
    	real ABB23 = m.get_real(F_QABRCB23);  
    	real ABB24 = m.get_real(F_QABRCB24);  
    	real ABB25 = m.get_real(F_QABRCB25);  
    	real ABB26 = m.get_real(F_QABRCB26);  
    	real ABB27 = m.get_real(F_QABRCB27);  
    	real ABB28 = m.get_real(F_QABRCB28);  
    	real ABB29 = m.get_real(F_QABRCB29);
    	real ABBTOT = ZERO;   
    	ABBTOT += ABB19+ABB20+ABB21+ABB22+ABB23+ABB24;  
      ABBTOT += ABB25+ABB26+ABB27+ABB28+ABB29; 
      if (ABBTOT == ZERO)
      	f.warning_box("Compilare la pagina relativa alle operazioni di conguaglio"); 
    }
    else 
    	m.disable_page(5);    	 
  }
  return TRUE;
}

// handler TOTDET
bool TQuadroA::QA_totdet_hnd  (TMask_field& f, KEY k)
{
  if (k == K_TAB)
  {
    TMask& m = f.mask();
    real totdet36 = m.get_real(F_TOTDET36);
    real detcc = m.get_real(F_DETCC);
    real detfc = m.get_real(F_DETFC);
    real detaf = m.get_real(F_DETAF);
    real detld = m.get_real(F_DETLD);
    real deto  = m.get_real(F_DETO);
    totdet36 = detcc + detfc + detaf + detld + deto;
    m.set(F_TOTDET36, totdet36);
		
		// disabilita il totale se almeno un dettaglio <20> compilato
    if (totdet36 != ZERO)
      m.disable(F_TOTDET36);
    else                    
      m.enable(F_TOTDET36);   
  }
  return TRUE;
}

bool TQuadroA::QA3_base_occupazionale(TMask_field& f , KEY k)
{
  if (k == K_SPACE) 
  {
    TString appname(30);
    appname.format("773mod -1 771200i 37 \"%s\" 0", "Base occupazionale");
    TExternal_app a(appname);
    a.run();
  }               
  return TRUE;
} 

void TQuadroA::registra_record2_A3(const TMask& m)
{
  TLocalisamfile quaa3 (LF_QUAA3);      
  TDate di;      
  long  ng1,ng2;
  real  rd1,rd2;

  di  = m.get_date(F_DIRAPTI_2);
  ng1 = m.get_long(F_NGINC15_2);
  ng2 = m.get_long(F_NGINC17_2);
  rd1 = m.get_real(F_REDCOR16_2);
  rd2 = m.get_real(F_REDCOR18_2);
  
  long codditta = m.get_long(QAF_CODDITTA);
  long codip    = m.get_long(F_CODIP);
  
  quaa3.setkey(1);
  quaa3.zero();
  quaa3.put(QA3_CODDITTA, codditta);
  quaa3.put(QA3_NPROG,    2);
  quaa3.put(QA3_CODIP,    codip);
  if (quaa3.read() == NOERR)
  {
    quaa3.put(QA3_CODDITTA, codditta);
    quaa3.put(QA3_NPROG,    2);
    quaa3.put(QA3_CODIP,    codip);
    quaa3.put(QA3_DIRAPTI,  di);
    quaa3.put(QA3_NGINC15,  ng1);
    quaa3.put(QA3_REDCOR16, rd1);
    quaa3.put(QA3_NGINC17,  ng2);
    quaa3.put(QA3_REDCOR18, rd2);
    quaa3.rewrite();
  }
  else
  {
    quaa3.put(QA3_CODDITTA, codditta);
    quaa3.put(QA3_NPROG,    2);
    quaa3.put(QA3_CODIP,    codip);
    quaa3.put(QA3_DIRAPTI,  di);
    quaa3.put(QA3_NGINC15,  ng1);
    quaa3.put(QA3_REDCOR16, rd1);
    quaa3.put(QA3_NGINC17,  ng2);
    quaa3.put(QA3_REDCOR18, rd2);
    quaa3.write();  
  }
}

int TQuadroA::rewrite(const TMask& m)
{                     
  if (QuadroA3() && _soc_trasf)       
    registra_record2_A3(m);
    
  // azzero campi operazioni di conguaglio
  // se rettifica diversa da A
  TMask& mx = (TMask&)m;
  if (QuadroAB())
  	if (m.get(F_RETCON56) != "A") 
    	mx.reset(-G_OPECONG); 
  if (QuadroA2())
  	if (m.get(QA2F_RETCON) != "A") 
    	mx.reset(-G_OPECONG);  	
                                  
  m.autosave(*_rel);
  const int err = _rel->rewrite();
  _registra = TRUE;

  return err;
}

int TQuadroA::write(const TMask& m)
{
  if (QuadroA3() && _soc_trasf)       
    registra_record2_A3(m);
                                          
	// azzero campi operazioni di conguaglio
  // se rettifica diversa da A
  TMask& mx = (TMask&)m;
  if (QuadroAB())
  	if (m.get(F_RETCON56) != "A") 
    	mx.reset(-G_OPECONG); 
  if (QuadroA2())
  	if (m.get(QA2F_RETCON) != "A") 
    	mx.reset(-G_OPECONG);  	
    	                                          
  m.autosave(*_rel);
  const int err = _rel->write();
  _registra = TRUE;
  
  return err;
}

void TQuadroA::cancella_record2_A3()
{
  TLocalisamfile quaa3 (LF_QUAA3);      
  
  quaa3.setkey(1);
  quaa3.zero();
  quaa3.put(QA3_CODDITTA, _codditta);
  quaa3.put(QA3_NPROG,    2);
  quaa3.put(QA3_CODIP,    _codip);
  if (quaa3.read() == NOERR)
    quaa3.remove();
}

bool TQuadroA::remove()
{
  if (QuadroA3() && _soc_trasf)       
    cancella_record2_A3();
  _registra = TRUE;
  return TRelation_application::remove();
}

bool TQuadroA::user_create()
{                      
  switch (_tipoq)
  {
    case 'A':
      _file   = LF_QUAA;
      _quadro = "A";
      break;
    case '1':
      _file   = LF_QUAA1;
      _quadro = "A1";
      break;
    case '2':
      _file   = LF_QUAA2;
      _quadro = "A2";
      break;
    case '3':
      _file   = LF_QUAA3;
      _quadro = "A3";
      break;            
    case '4':
      _file   = LF_QUAAB;
      _quadro = "AB";
      break;        
    default:
      break;
  }
     
  _qd   = new TLocalisamfile(_file);
  _rel  = new TRelation(_file);
  _base = new TLocalisamfile(LF_BASE);
  _codditta = get_firm_770();

// posiziona il base (per leggere allegati)
  _base->zero();
  _base->put("CODDITTA", _codditta);
  _base->read();

  set_search_field(F_CODANAGDIP);
  _registra = FALSE;

  load_mask(0); 

  if (QuadroAB() || QuadroA2())
    _mskAllegati = new TMask("77qaall");

  _soc_trasf = FALSE;                                  

  return TRUE;
}

bool TQuadroA::user_destroy()
{ 
  if (_msk[1] != NULL) delete _msk[1];
  if (_msk[0] != NULL) delete _msk[0];

  if (QuadroAB() || QuadroA2()) 
    delete _mskAllegati;
    
  delete _base;
  
  TString16 quadro = "";
  
  switch (_tipoq)
  {
    case 'A':
      quadro << "A";
      break;
    case '1':
      quadro << "A1";
      break;
    case '2':
      quadro << "A2";
      break;
    case '3':
      quadro << "A3";
      break; 
    case '4':
      quadro << "AB";
      break;        
    default:
      break;
  }
  
  if (_registra)
    _rip.set(quadro);

  delete _rel; 
  delete _qd;
  
  return TRUE;
}

void TQuadroA::on_config_change()
{                                
  TConfig conf(CONFIG_STUDIO);
  _anno_dic = (int)conf.get_long(ANNO_SEL, NULL); 
}

char TQuadroA::tipo_trasformata(long codditta)
{ 
  TLocalisamfile ditta (LF_NDITTE);         
  char tipo;
  
  ditta.setkey(1);
  ditta.zero();
  ditta.put(NDT_CODDITTA, codditta);
  if (ditta.read() == NOERR)
    tipo = ditta.get_char(NDT_TIPOA);
      
  return tipo;
}

void TQuadroA::carica_record2_A3(TMask& m)
{ 
  TLocalisamfile quaa3 (LF_QUAA3);      
  TDate di;      
  char  tipo;
  long  ng1,ng2;
  real  rd1,rd2;
  
  ng1 = 0;
  ng2 = 0;
  rd1 = ZERO;
  rd2 = ZERO;
  
  long codditta = m.get_long(QAF_CODDITTA);
  long codip    = m.get_long(F_CODIP);
  
  quaa3.setkey(1);
  quaa3.zero();
  quaa3.put(QA3_CODDITTA, codditta);
  quaa3.put(QA3_NPROG,    2);
  quaa3.put(QA3_CODIP,    codip);
  if (quaa3.read() == NOERR)
  {
    di  = quaa3.get_date(QA3_DIRAPTI);
    ng1 = quaa3.get_long(QA3_NGINC15);
    rd1 = quaa3.get_real(QA3_REDCOR16);
    ng2 = quaa3.get_long(QA3_NGINC17);
    rd2 = quaa3.get_real(QA3_REDCOR18);
  }
         
  tipo = tipo_trasformata(codditta);
  
  if (tipo == 'F')
  { 
    m.hide(F_DENTRASF);
    m.show(F_COGNTRASF);
    m.show(F_NOMETRASF);
    m.set(F_COGNTRASF, _cognome);
    m.set(F_NOMETRASF, _nome);
  }
  else
    if (tipo == 'G')
    {
      m.show(F_DENTRASF);
      m.hide(F_COGNTRASF);
      m.hide(F_NOMETRASF);
      m.set(F_DENTRASF, _cognome);
    }                 
    
  m.set(F_NPROG_2,    2);
  m.set(F_DIRAPTI_2,  di);
  m.set(F_NGINC15_2,  ng1);
  m.set(F_REDCOR16_2, rd1);
  m.set(F_NGINC17_2,  ng2);
  m.set(F_REDCOR18_2, rd2);
}

void TQuadroA::init_query_mode(TMask& m)
{ 
  m.set(QAF_ANNODIC, _anno_dic); 
  if (QuadroA3())
  {
    _soc_trasf = is_societa_trasformata(m);
    if (_soc_trasf)
      carica_record2_A3(m);
  }
  else                               
  {                           
    // forza il ricalcolo dell'ultimo numero disponibile
    TString16 dummy(m.get(QAF_NPROG));
    if (dummy.not_empty())
      setta_nprog(m.field(F_CODIP));   
  }                                                                   
  m.hide(-1);  // hide group 1 -nasconde DIPEND.
  m.show(-2);  // show group 2 -Ricerca su QUADRO A
}

void TQuadroA::init_query_insert_mode(TMask& m)
{ 
  m.set(QAF_ANNODIC, _anno_dic); 
  m.hide(-2);  // group 2 Nasconde ricerca su QUADROA
  m.show(-1);  // group 1 Ricerca su ANAGR.DIPENDENTI
}

void TQuadroA::init_modify_mode(TMask& m)
{                  
  if (QuadroA1())
    m.set(QA1F_ANNORIF, _anno_dic);
  if (QuadroA3())
  { 
    _codditta = m.get_long(QAF_CODDITTA);
    _codip    = m.get_long(F_CODIP);

    _soc_trasf = is_societa_trasformata(m);
    if (_soc_trasf)        
    {
      carica_record2_A3(m); 
      m.enable_page(1);
    }
    else
      m.disable_page(1);
  }             
}

void TQuadroA::init_insert_mode(TMask& m)
{ 
  if (QuadroA1())
    m.set(QA1F_ANNORIF, _anno_dic);

  if (QuadroA3())
  { 
    _codditta = m.get_long(QAF_CODDITTA);
    _codip    = m.get_long(F_CODIP);

    _soc_trasf = is_societa_trasformata(m);
    if (_soc_trasf)        
    {
      carica_record2_A3(m); 
      m.enable_page(1);
    }
    else
      m.disable_page(1);
  }             
}

int quadriA_A3(int argc, char* argv[])
{
  const char tipo = toupper(*argv[2]); 
  const char* title = "";
  TQuadroA a(tipo);
  switch (tipo)
  {
    case 'A':
      title = "Quadro A";
      break;
    case '1':
      title = "Quadro A1";
      break;
    case '2':
      title = "Quadro A2";
      break;
    case '3':
      title = "Quadro A3";
      break; 
    case '4':
      title = "Quadro A bis";
      break;        
    default:
      break;    
  }
  a.run(argc, argv, title);
  return TRUE;
}