//////////////////////////////////////////
// 771200.cpp - Quadro A   771mod -7 A  //
//            - Quadro A1  771mod -7 1  //
//            - Quadro A2  771mod -7 2  //
//            - Quadro A3  771mod -7 3  //
////////////////////////////////////////// 
#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, TString& quadro);

bool QA_cerca_codA(const long codditta, const long coddip, TString& quadro)
{
  TString16 c58("");
  bool Result = FALSE;
  TLocalisamfile qq(quadro == "A" ? LF_QUAA : LF_QUAA2);  
  qq.zero();
  qq.put(QUA_CODDITTA, codditta);
  qq.put(QUA_CODIP, coddip);
  TRectype dep(qq.curr());
  qq.read();    
  TRecnotype lPos = qq.recno();
  for ( ;!qq.eof(); qq.next())
  {
    if (qq.curr() > dep) break;
    c58 = qq.get(QUA_RETCON);
    if (c58 == "A")
    {
      Result = TRUE;
      break;
    }
  }
  qq.readat(lPos);
  return Result;
}

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 (A 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  
    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_comp_netti_hnd (TMask_field& f, KEY key);    
    static bool QA_tot_impon_hnd  (TMask_field& f, KEY key);    
    static bool QA_tot_detraz_hnd (TMask_field& f, KEY key);    
    static bool QA_cfdlprec_hnd   (TMask_field& f, KEY key);    
    static bool QA_chech_ritdatlav (TMask_field& f, KEY key);    
    static bool QA_calcola42			(TMask_field& f, KEY k);
    static bool QA_check_2527      (TMask_field& f, KEY key);            
    static bool QA_A2_check_58     (TMask_field& f, KEY key);            
    static bool QA_calcolo30       (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);        
    static bool QA3_nprog          (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"; }      
            
  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() {};
};                    

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_QUERY)
    return _mode != MODE_QUERY;
  else
    return TRUE;
}
        
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;                
      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;        
      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(QAF_NPROG,    QA3_nprog);
          m->set_handler(F_CODANAGDIP, QA3_codip_handler);
          m->set_handler(F_BASEOCCUPA, QA3_base_occupazionale);
        }                                                       
        else 
        { 
          if (QuadroA())
            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 (QuadroA())
        {                                               
// Calcola i compensi netti (c.23) e controllo c25-27
          m->set_handler(F_CODFISDL,   QA_cfdlprec_hnd);         
          m->set_handler(F_DENARO,     QA_comp_netti_hnd); 
          m->set_handler(F_NATURA,     QA_comp_netti_hnd); 
          m->set_handler(F_COBBDIP21,  QA_comp_netti_hnd);    
// Se immette un B controlla che ci sia almeno un rec con A
          m->set_handler(F_RETCON56,  QA_A2_check_58);        
// Se 27=0 => 25 deve = 0                
          m->set_handler(F_IACOBBCD25,  QA_check_2527);    
// Calcola il totale imponibile (c.27)
          m->set_handler(F_AMMLORDO24,  QA_tot_impon_hnd);    
          m->set_handler(QAF_SVNSOGRIT, QA_tot_impon_hnd);    
          m->set_handler(F_DETCC,      QA_tot_detraz_hnd);    
          m->set_handler(F_DETFC,      QA_tot_detraz_hnd);    
          m->set_handler(F_DETAF,      QA_tot_detraz_hnd);    
          m->set_handler(F_DETLD,      QA_tot_detraz_hnd);    
          m->set_handler(F_DETO,       QA_tot_detraz_hnd);    
// Controlla che 40 sia <= 30                              
          m->set_handler(F_AMRIODL38,  QA_chech_ritdatlav);    
// Calcola 42 = 39 + 40 - 41                    
			    m->set_handler(F_AMRIOT37,	 QA_calcola42);
			    m->set_handler(F_AMRIODL38,  QA_calcola42);           
			    m->set_handler(F_ECCRITRIMB, QA_calcola42);    
// Calcolo: 30 = 23+27+28+29                 
          m->set_handler(F_COMPNETTI,  QA_calcolo30);          
          m->set_handler(F_TOTIMP26,   QA_calcolo30);          
          m->set_handler(F_AIEREP23,   QA_calcolo30);          
          m->set_handler(F_CCTAMMCONT, QA_calcolo30);                              
        }
      }
      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 error_box("Il dipendente selezionato e' un erede: non e'\n possibile indicare piu' di un rigo sul quadro A");
    
  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())
  if (k == K_TAB)
  {
    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().QuadroA())  
    {
      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);              
    }
    kAll = app()._mskAllegati->run();
    if (kAll==K_ENTER)
    {
      if (app().QuadroA())
      {
        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();
    }
  }
  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_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 error_box("Il dipendente selezionato e' un erede: non e'\n possibile indicare piu' di un rigo sul quadro A");
    else                            
    {       
      app()._codip = coddip;
//      app().AA3SettaCognomeNome(f.mask());
      f.mask().stop_run(K_AUTO_ENTER); // entra in modo modifica (se il record che ha chiave specificata esiste gia') oppure
                                     // inserimento (se trova che non esiste)
    }                                   
  }                                   
  return TRUE;
}

bool TQuadroA::QA3_nprog(TMask_field& f, KEY key)
{
  if (key == K_TAB)   
  {
    const int nprog = atoi(f.get());
    if (nprog==0) 
      f.mask().set(QAF_NPROG, 1);
  }                                   
  return TRUE;
}

bool TQuadroA::QA3_codip_handler(TMask_field& f, KEY key)
{
  if (!f.mask().is_running()) return TRUE;

  if (key == K_ENTER)   
  {
    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");
  }
    
  if (key == K_TAB)   
  {
    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().stop_run(K_AUTO_ENTER); // entra in modo modifica (se il record che ha chiave specificata esiste gia') oppure
                                     // inserimento (se trova che non esiste)
  }                                   
  return TRUE;
}

// Se CF dat.lav.prec. e' vuoto => mette a ZERO il 19 e lo disabilita
// 26.6.96 azzera soltanto
bool TQuadroA::QA_cfdlprec_hnd(TMask_field& f, KEY k)
{
/*
  if (k == K_TAB)
  {
    TString tmp(f.get());
    if (tmp.empty())
      f.mask().set(F_CAUSA, 0L);
  } */
  return TRUE;
}

// Controlla che 40 NON sia > 30                              
bool TQuadroA::QA_chech_ritdatlav(TMask_field& f, KEY k)
{
  if (k == K_ENTER)
  {
    real RitDatLavoro(f.get());			// c40
    real TotImp(f.mask().get_real(F_TOTIMP29)); 	// c30
    if (RitDatLavoro > TotImp)
      return f.warning_box("Le ritenute del datore di lavoro non possono superare il totale imponibile");
  }
  return TRUE;
}

// Calcola che 42 = 39 + 40 - 41. Se il risultato e' negativo scrive 0
bool TQuadroA::QA_calcola42(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;
    TString c42s(c42.string());
    m.set(F_AMMRITDOV, c42s);
  }
  return TRUE;
}

bool TQuadroA::QA_check_2527  (TMask_field& f, KEY k)
{
// Se 27 == 0 => 25 = 0
  if (k == K_ENTER)
  {
    real c27 = f.mask().get_real(F_TOTIMP26);
    real c25(f.get());
    
    if (c27 == ZERO && c25 != ZERO)
      return f.warning_box("Valore non corretto: il totale imponibile è nullo");
  }
  return TRUE;
}

// Funziona sia col quadro A che con A2
bool TQuadroA::QA_A2_check_58(TMask_field& f, KEY k)
{             
//  if (k == K_TAB || k == K_ENTER)
  if (f.to_check(k,TRUE))
  {
    TMask& m = f.mask();
    TString16 cod(f.get());  
    cod.upper();
    const long codditta = m.get_long(QAF_CODDITTA);
    const long coddip   = m.get_long(F_CODIP);
    if (cod == "B")    
    {
      if (!QA_cerca_codA(codditta, coddip, app()._quadro))
        return error_box(app().QuadroA2() ? 
              "Non esiste nessun record con 9=A per questo dipendente" :
              "Non esiste nessun record con 58=A per questo dipendente");
      else
      {
// Nasconde prompt 770 mostra prompt 730      
        m.reset(-G_ALL);
        m.disable(-G_ALL);   
// reset anche dei campi calcolati disabilitati nel quadro A        
        if (app().QuadroA()) m.reset(-G_2342);
        m.hide(-G_770);
        m.show(-G_730);     
      }
    }
// Nasconde prompt 730 mostra prompt 770
    else
    {
      m.show(-G_770);
      m.hide(-G_730);
      m.enable(-G_ALL);
    }
  }
  return TRUE;
}

// calcola c23 = 20  + 21 -22  Se minore di 0 scrive 0
bool TQuadroA::QA_comp_netti_hnd  (TMask_field& f, KEY k)
{             
  if (k == K_TAB)
  {
    real denaro  = f.mask().get_real(F_DENARO);
    real natura  = f.mask().get_real(F_NATURA);
    real cobbdip = f.mask().get_real(F_COBBDIP21);
    real compnetti = denaro + natura - cobbdip;
    if (compnetti < ZERO) compnetti = ZERO;
    f.mask().set(F_COMPNETTI, compnetti); 
    f.send_key(K_TAB,F_COMPNETTI);
  }
  return TRUE;
}

// 27 = 24 - 26    
bool TQuadroA::QA_tot_impon_hnd   (TMask_field& f, KEY k)
{
  if (k == K_TAB || k == K_SPACE)
  {
    bool ForzaRicalcolo = f.focusdirty();
    real ammlordo  = f.mask().get_real(F_AMMLORDO24);
    real svnsrit   = f.mask().get_real(QAF_SVNSOGRIT);
    real tot_corr  = f.mask().get_real(F_TOTIMP26);
    if (tot_corr == ZERO || ForzaRicalcolo)
    {    
      real totimp29 = ammlordo - svnsrit;    
// c27 se < 0 scrivere 0 fax 15.7.96 p.1
      if (totimp29 < ZERO)
        totimp29 = ZERO;
      f.mask().set(F_TOTIMP26, totimp29);
    }
  }
  return TRUE;
}

bool TQuadroA::QA_tot_detraz_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 campo 37 se uno almeno da 32 a 36 e' compilato
    if (totdet36 != ZERO)
      m.disable(F_TOTDET36);
    else                    
      m.enable(F_TOTDET36);      
  }
  return TRUE;
}

bool TQuadroA::QA_calcolo30(TMask_field& f, KEY k)
{
  if (k == K_TAB)
  {
    TMask& m = f.mask();
    real c30 = m.get_real(F_TOTIMP29);
    real c23 = m.get_real(F_COMPNETTI);
    real c27 = m.get_real(F_TOTIMP26);
    real c28 = m.get_real(F_AIEREP23);
    real c29 = m.get_real(F_CCTAMMCONT);
    c30 = c23 + c27 + c28 + c29;
    if (c30 < ZERO) c30 = ZERO;
    m.set(F_TOTIMP29, c30);
  }
  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);
    
  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);

  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;      
    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 (QuadroA() || 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 (QuadroA() || 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;      
    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(QAF_NPROG));   
  }                                                                   
  m.send_key(K_SHIFT+K_CTRL+'h', -1);  // hide group 1 -nasconde DIPEND.
  m.send_key(K_SHIFT+K_CTRL+'s', -2);  // show group 2 -Ricerca su QUADRO A
}

void TQuadroA::init_query_insert_mode(TMask& m)
{ 
  m.set(QAF_ANNODIC, _anno_dic); 
  m.send_key(K_SHIFT+K_CTRL+'h', -2);  // group 2 Nasconde ricerca su QUADROA
  m.send_key(K_SHIFT+K_CTRL+'s', -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;      
    default:
      break;    
  }
  a.run(argc, argv, title);
  return TRUE;
}
