// 771310.cpp  - Modello 770 - Gestione quadro L
#include <applicat.h>
#include <mask.h>
#include <msksheet.h>
#include <relapp.h>
#include <relation.h>
#include <tabutil.h>
#include <urldefid.h>
#include <config.h>      
#include <utility.h> 
#include <mailbox.h> 
#include <execp.h>

#include "771310.h" 
#include "774100.h"
#include "774200.h"
#include "77lib.h"
#include "scperc.h"
#include "rver.h"
#include "rpag.h"  
#include "quadrol.h"

class M71310_application : public TRelation_application
{
    TRelation* _rel;
    TMask*     _msk; 
    TGenera    _app;
    TConfig*   _cnf;
    int        _anno;
  
  protected:
    virtual bool user_create();
    virtual bool user_destroy();
    virtual TRelation*   get_relation() const { return _rel; }
    virtual TMask*       get_mask(int mode) { return _msk; }
    virtual bool         changing_mask(int mode) {return FALSE; }
    virtual void init_query_mode(TMask&);
    virtual void init_modify_mode(TMask&);
    virtual void init_insert_mode(TMask&); 
    virtual void on_config_change();  
    virtual int  rewrite(const TMask& m);
    virtual int  write(const TMask& m);  
    void   build_note(const TMask& m);
    void   set_field_note(TMask& m);                
    bool	 changed_anno_dic(TMask& m);
    real		arrotonda(const TMask& m);
    static bool generazione (TMask_field& f, KEY k);                  
    static bool genera_para (TMask_field& f, KEY k);                    
    static bool tipo        (TMask_field& f, KEY k);                  
    static bool luogo       (TMask_field& f, KEY k);
    static bool auto_premi  (TMask_field& f, KEY k);  
    static bool mese        (TMask_field& f, KEY k);
    static bool anno        (TMask_field& f, KEY k);                  
    static bool cod_tributo (TMask_field& f, KEY k);
    static bool codditta_hnd(TMask_field& f, KEY k);
    static bool artbil_hnd(TMask_field& f, KEY k);
  
  public:
    M71310_application() {}
};                     

M71310_application& app() { return (M71310_application&) main_app(); }

bool M71310_application::generazione(TMask_field& f , KEY k)
{
  if (k == K_SPACE)
    app()._app.set(get_firm_770(), app()._cnf);
    
  return TRUE;
}

bool M71310_application::genera_para(TMask_field& f , KEY k)
{
  if (k == K_SPACE)
  {    
    TString appname("776mod -4 d");
    TExternal_app a(appname);
    a.run();
    f.mask().set_focus();
  }
  return TRUE;
}

bool M71310_application::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 M71310_application::mese(TMask_field& f , KEY k)
{ 
// is_running() serve per fare il controllo solo quando la maschera sta andando
// In questo modo tutti i K_TAB che ricevono i campi durante la costruzione della maschera
// vengono ignorati.
// Il K_TAB mi fa scattare il controllo quando lascio il campo
// Il K_ENTER mi serve per fare i controlli quando uso uno dei tasti della bottoniera

  if (k == K_TAB || k == K_ENTER)
  {
    int mese = f.mask().get_int(F_QLMESEPAG);
    
    if (mese == 0)
    {
      f.error_box("Il mese di pagamento deve essere indicato obbligatoriamente");
      return FALSE;
    }
  }
  return TRUE;
}

bool M71310_application::anno(TMask_field& f , KEY k)
{ 
// is_running() serve per fare il controllo solo quando la maschera sta andando
// In questo modo tutti i K_TAB che ricevono i campi durante la costruzione della maschera
// vengono ignorati.
// Il K_TAB mi fa scattare il controllo quando lascio il campo
// Il K_ENTER mi serve per fare i controlli quando uso uno dei tasti della bottoniera

  if ((k == K_TAB && f.mask().is_running()) || k == K_ENTER)
  {
    int anno = f.mask().get_int(F_QLANNOPAG);
    
    if (anno == 0)
      return f.error_box("L'anno di pagamento deve essere indicato obbligatoriamente");
  }
  return TRUE;
}

bool M71310_application::cod_tributo(TMask_field& f , KEY k)
{
// is_running() serve per fare il controllo solo quando la maschera sta andando
// In questo modo tutti i K_TAB che ricevono i campi durante la costruzione della maschera
// vengono ignorati.
// Il K_TAB mi fa scattare il controllo quando lascio il campo
// Il K_ENTER mi serve per fare i controlli quando uso uno dei tasti della bottoniera

  if ((k == K_TAB && f.mask().is_running()) || k == K_ENTER)
  {
    int tributo = f.mask().get_int(F_QLCODTRIB);
    
    if (tributo == 0)
    {
      f.error_box("Il codice tributo deve essere indicato obbligatoriamente");
      return FALSE;
    }
  }
  return TRUE;
}

// "auto-premimento" 
// Sia da F_ABI che da F_NUMERO
bool M71310_application::auto_premi(TMask_field& f, KEY k)
{
  if (k == K_TAB && f.mask().is_running())
  {                               
    TMask&     m   = f.mask();    
    m.stop_run(K_AUTO_ENTER);
/*  
    TRelation* rel = app()._rel;
    TMask&     m   = f.mask();    
    m.autosave(rel);
    if (rel->read() == NOERR)
      m.stop_run(K_AUTO_ENTER);
    else
      m.stop_run(K_INS); */
  }
  return TRUE;
}
                                                 
bool M71310_application::tipo(TMask_field& f , KEY k)
{
  if (k == K_SPACE)
  {
    char tipo  = f.mask().get(F_QLTIPOVERS)[0];
    char luogo = f.mask().get(F_QLLUOVERS)[0];
    
    if (tipo == 'D' && luogo == 'T')
      f.mask().hide(F_QLSERIE);
    else
      f.mask().show(F_QLSERIE);
  }
  return TRUE;
}

bool M71310_application::luogo(TMask_field& f , KEY k)
{
  if (k == K_SPACE)
  {
    char tipo  = f.mask().get(F_QLTIPOVERS)[0];
    char luogo = f.mask().get(F_QLLUOVERS)[0];
    
    if (tipo == 'D' && luogo == 'T')
      f.mask().hide(F_QLSERIE);
    else
      f.mask().show(F_QLSERIE);  
  }
  return TRUE;
}

// Tenta di mandare il focus al campo visibile invece che a quello
// nascosto
bool M71310_application::artbil_hnd(TMask_field& f , KEY k) 
{
  if (k == K_TAB)
  {
    TMask& m = f.mask();    
    const char tipo  = m.get(F_QLTIPOVERS)[0];
    const char luogo = m.get(F_QLLUOVERS)[0];

// Determina chi ha il focus in questo momento
    TMask_field& fld = m.focus_field(); 

// Se il focus e' sull'ultimo campo prima di F_ABI
    if (fld.dlg() == F_ARTBIL)
    {
//      WINDOW	win;
// Determina chi ce lo dovrebbe avere dopo..    
      if (tipo == 'B')
      {                               
        TMask_field& fabi = m.field(F_ABI);
        fabi.set_focus();
//        win = m.field(F_ABI).win();
//        m.set_focus_win(win, TRUE);
      }
    }
  }
  return TRUE;
}

void M71310_application::on_config_change()
{
  TConfig conf(CONFIG_STUDIO);
  _anno = (int) conf.get_long(ANNO_SEL);
} 

// Determina se l'utente ha cambiato l'anno di dichiarazione
// impostato. Se si' non bisogna toccarlo
bool M71310_application::changed_anno_dic(TMask& m)
{
  const int anno_corr = m.get_int(F_ANNODIC);
  return anno_corr ? anno_corr != _anno : FALSE;
}

void M71310_application::init_insert_mode(TMask& m)
{
  if (!changed_anno_dic(m))
    m.set(F_ANNODIC, _anno);
  m.disable(F_ANNODIC);
  m.disable(F_GENERA);
  m.enable (F_QLRITEFF);
  m.enable (F_QLRITVER);
  m.enable (F_QLRSS);
  //m.enable (F_QLNOTE);
  m.enable (F_NOTEA);
  m.enable (F_NOTEB);
  m.enable (F_NOTEC);
  m.enable (F_NOTED);
  m.enable (F_NOTEE);
  m.enable (F_NOTEF);
  m.enable (F_NOTEG);
}
                               
void M71310_application::init_query_mode(TMask& m)
{         
  if (!changed_anno_dic(m))
    m.set(F_ANNODIC, _anno);
  m.enable(F_ANNODIC);
  m.enable (F_GENERA); 
  m.disable(F_QLRITEFF);
  m.disable(F_QLRITVER);
  m.disable(F_QLRSS);
  //m.disable(F_QLNOTE);
  m.disable(F_NOTEA);
  m.disable(F_NOTEB);
  m.disable(F_NOTEC);
  m.disable(F_NOTED);
  m.disable(F_NOTEE);
  m.disable(F_NOTEF);
  m.disable(F_NOTEG);
}

void M71310_application::init_modify_mode(TMask& m)
{         
  if (!changed_anno_dic(m))
    m.set(F_ANNODIC, _anno); 
  m.disable(F_ANNODIC);
  set_field_note(m);
  
  m.disable(F_GENERA);
  m.enable (F_QLRITEFF);
  m.enable (F_QLRITVER);
  m.enable (F_QLRSS);
  //m.enable (F_QLNOTE);
  m.enable (F_NOTEA);
  m.enable (F_NOTEB);
  m.enable (F_NOTEC);
  m.enable (F_NOTED);
  m.enable (F_NOTEE);
  m.enable (F_NOTEF);
  m.enable (F_NOTEG);  
}

void M71310_application::set_field_note(TMask& m)
{
  TString note = _rel->lfile().get(QUL_QLNOTE);
  
  if (note != "")
  { 
    char A,B,C,D,E,F,G;
             
    int p = note.len() - 1;

    A = note[0];
    if (p >= 1)
      B = note[1];
    if (p >= 2)  
      C = note[2];    
    if (p >= 3)
      D = note[3];
    if (p >= 4)
      E = note[4];
    if (p >= 5)
      F = note[5];
    if (p >= 6)
      G = note[6];
  
    if (A == 'A')
      m.set(F_NOTEA, "X");
    
    if (B == 'B')
      m.set(F_NOTEB, "X");
    
    if (C == 'C')
      m.set(F_NOTEC, "X");
    
    if (D == 'D')
      m.set(F_NOTED, "X");
    
    if (E == 'E')
      m.set(F_NOTEE, "X");
    
    if (F == 'F')
      m.set(F_NOTEF, "X");
    
    if (G == 'G')
      m.set(F_NOTEG, "X");
  }
}

void M71310_application::build_note(const TMask& m)
{
  char A = m.get(F_NOTEA)[0];
  char B = m.get(F_NOTEB)[0];
  char C = m.get(F_NOTEC)[0];
  char D = m.get(F_NOTED)[0];
  char E = m.get(F_NOTEE)[0];
  char F = m.get(F_NOTEF)[0];
  char G = m.get(F_NOTEG)[0];
  
  TString16 note;
  
  if (A == 'X')
    note[0] = 'A';
  else
    note[0] = ' ';
    
  if (B == 'X')
    note[1] = 'B';
  else
    note[1] = ' ';
    
  if (C == 'X')
    note[2] = 'C';
  else
    note[2] = ' ';
    
  if (D == 'X')
    note[3] = 'D';
  else
    note[3] = ' ';
    
  if (E == 'X')
    note[4] = 'E';
  else
    note[4] = ' ';
    
  if (F == 'X')
    note[5] = 'F';
  else
    note[5] = ' ';
    
  if (G == 'X')
    note[6] = 'G';
  else
    note[6] = ' ';   
    
  note [7] = '\0';
    
  _rel->lfile().put(QUL_QLNOTE, note);
}

// Arrotonda l'importo versato
real M71310_application::arrotonda(const TMask& m)
{
  real rImpVers = m.get_real(F_QLRITVER);
  real rImpArr = round_770(rImpVers);
  return rImpArr;
}

int M71310_application::rewrite(const TMask& m)
{
  real rImpVersArr;
  build_note(m);          
  m.autosave(_rel);
  rImpVersArr = arrotonda(m);
  _rel->lfile().put(QUL_QLRITVER, rImpVersArr);
  return _rel->rewrite();
}

int M71310_application::write(const TMask& m)
{                  
  real rImpVersArr;
  build_note(m);
  m.autosave(_rel);
  rImpVersArr =   arrotonda(m);                
  _rel->lfile().put(QUL_QLRITVER, rImpVersArr);  
  return _rel->write();
}

bool M71310_application::user_create()
{
  _cnf = new TConfig(CONFIG_STUDIO);
  _rel = new TRelation (LF_QUAL);
  _msk = new TMask("771310a");
  
  set_search_field(F_QLANNOPAG);
  _msk->set_handler (F_GENERA,     generazione);
  _msk->set_handler (F_PARAMETRI,  genera_para);
  _msk->set_handler (F_CODDITTA,   codditta_hnd);                    
  _msk->set_handler (F_QLTIPOVERS, tipo);
  _msk->set_handler (F_QLLUOVERS,  luogo);
  _msk->set_handler (F_QLMESEPAG,  mese);
  _msk->set_handler (F_QLANNOPAG,  anno);
  _msk->set_handler (F_QLCODTRIB,  cod_tributo);   
  _msk->set_handler (F_QLNUMERO,   auto_premi);
  _msk->set_handler (F_NPROG,      auto_premi);
  _msk->set_handler (F_ARTBIL,     artbil_hnd);
    
  return TRUE;
}

bool M71310_application::user_destroy()
{
  delete _msk;
  delete _rel;            
  delete _cnf;
  return TRUE;
}

int m71310(int argc, char* argv[])
{
  M71310_application a;
  a.run(argc, argv, "Gestione quadro L");
  return 0;
}