//////////////////////////////////////////
// 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"

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());
    
  for (qq.read(); !qq.eof(); qq.next())
  {
    if (qq.curr() > dep) break;
    c58 = qq.get(QUA_RETCON);
    if (c58 == "A")
    {
      Result = TRUE;
      break;
    }
  }
  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];
    long             _coddip;
    char             _tipoq;
    int              _nproga;
    int              _mode;
    int              _anno_dic;  // anno dichiarazione
    TLocalisamfile*  _qd;
    TRiporti         _rip;
    int              _file;
    bool             _soc_trasf; 
    TString          _cognome,_nome;
    long             _codditta,_codip;

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

// 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_check_ritdovute (TMask_field& f, KEY key);            
    static bool QA_check_2527      (TMask_field& f, KEY key);            
    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);        
    static bool QA3_nprog          (TMask_field& f, KEY key);        

  protected:
    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,      nprog_handler);
          m->set_handler(F_CODIP,      codanagr_handler);  
        }
        else 
        {                                                  
          m->set_handler(QAF_NPROG,    QA3_nprog);
          m->set_handler(F_CODIP,      QA3_codip_handler);
          m->set_handler(F_BASEOCCUPA, QA3_base_occupazionale);
        }
      }
      break;
    case 1:                                 
      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);    
// Controlla che 42 = 39 + 40 - 41                         
          m->set_handler(F_AMMRITDOV,  QA_check_ritdovute);    
        }
      }
      break;
    default:
      break;  
  }        
  m->disable(DLG_FINDREC);
  
  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("CODIP",    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 << get_firm_770();
    if (codditta != "0")        
    {
      f.set(codditta);
      f.check();
    }
  }   
  return TRUE;                                           
}

bool TQuadroA::codanagr_handler(TMask_field& f, KEY k)
{
  if (k == K_TAB && f.focusdirty())
  {
    TString16 dummy(f.get());
    if (dummy.not_empty())   
      setta_nprog(f);
  }
  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");
    
    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_TAB)   
  {
    const long coddip   = atol(f.get());
    if (coddip==0) return TRUE;    
    
    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
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);
      f.mask().disable(F_CAUSA);    
    }
    else
      f.mask().enable(F_CAUSA);
  }
  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;
}

// Controlla che 42 = 39 + 40 - 41                         
bool TQuadroA::QA_check_ritdovute(TMask_field& f, KEY k)
{
  if (k == K_ENTER)
  {
    real ritterzi = f.mask().get_real(F_AMRIOT37);
    real ritdatlav = f.mask().get_real(F_AMRIODL38);
    real eccrit = f.mask().get_real(F_ECCRITRIMB);
    real c42(f.get());
    real ritdovute = ritterzi + ritdatlav - eccrit;

    if (c42 != ritdovute)
      f.warning_box("Correggere l'importo delle ritenute dovute");    
  }
  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)
  {
    TMask& m = f.mask();
    TString16 cod(f.get());
    const long codditta = f.mask().get_long(QAF_CODDITTA);
    const long coddip = f.mask().get_long(F_CODIP);
    if (cod == "B")    
    {
      if (!QA_cerca_codA(codditta, coddip, app()._quadro))
        return error_box("Non esiste nessun record con 58=A per questo dipendente");
// Nasconde prompt 770 mostra prompt 730
      m.hide(-6);
      m.show(-7);
    }
// Nasconde prompt 730 mostra prompt 770
    else
    {
      m.hide(-7);
      m.show(-6);
    }
  }
  return TRUE;
}

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;
    
    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;    
      f.mask().set(F_TOTIMP26, totimp29);
    }
  }
  return TRUE;
}

bool TQuadroA::QA_tot_detraz_hnd  (TMask_field& f, KEY k)
{
  if (k == K_TAB)
  {
    bool ForzaRicalcolo = FALSE;
    real totdet36 = f.mask().get_real(F_TOTDET36);
    
    ForzaRicalcolo = f.focusdirty();

    if (ForzaRicalcolo) 
    {
      real detcc = f.mask().get_real(F_DETCC);
      real detfc = f.mask().get_real(F_DETFC);
      real detaf = f.mask().get_real(F_DETAF);
      real detld = f.mask().get_real(F_DETLD);
      real deto  = f.mask().get_real(F_DETO);
      
      totdet36 = detcc + detfc + detaf + detld + deto;
      f.mask().set(F_TOTDET36, 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 occupati");
    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 (_tipoq == '3' && _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 (_tipoq == '3' && _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 (_tipoq == '3' && _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);

  set_search_field(F_CODANAGDIP);
  
  _registra = FALSE;
  
  load_mask(0); 
  
  _soc_trasf = FALSE;                                  

  return TRUE;
}

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

  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 (_tipoq == '3')
  {
    _soc_trasf = is_societa_trasformata(m);
    if (_soc_trasf)
      carica_record2_A3(m);
  }
                               
  if (_tipoq != '3')
  {                           
    // 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);  // nasconde (hide) group 1 - Scelta ANAGR
  m.send_key(K_SHIFT+K_CTRL+'s', -2);  // abilita (show) group 2 - Ricerca su DATI PERC    
}

void TQuadroA::init_query_insert_mode(TMask& m)
{ 
  m.set(QAF_ANNODIC, _anno_dic);
  
  m.send_key(K_SHIFT+K_CTRL+'h', -2);  // group 3 Nasconde ricerca su PERC
  m.send_key(K_SHIFT+K_CTRL+'s', -1);  // group 1 Ricerca su ANAGR  
}

void TQuadroA::init_modify_mode(TMask& m)
{ 
  if (_tipoq == '3')
  { 
    _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 (_tipoq == '3')
  { 
    _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;
}