campo-sirio/m770/776100.cpp

// 776100.cpp - Menu manutenzione quadri 
  
// menu manutenzione quadri               (GROUP 1 alias MENU_MAIN)    
// sottomenu manutenzione dati anagrafici (GROUP 2 alias MENU_DATIANAG)       
// sottomenu stampe                       (GROUP 3 alias MENU_STAMPE) 
// sottomenu soggetto dichiarante         (GROUP 4 alias MENU_SOGGDICH)
// sottomenu stampe dichiarzioni          (GROUP 5 alias MENU_STAMPEDICH) 
#include <execp.h>
#include <mailbox.h>
#include <relapp.h>                
#include <utility.h>

#include "776.h"
#include "776100a.h"
#include "776100b.h"
#include "77lib.h"
#include "../ba/ba4600.h"

HIDDEN TString80 __tmp;
HIDDEN const int NUM_QUADRI = 30;

typedef enum { grassetto=0, sottolineato, piano } stile;

class TManutenzione_quadri : public TSkeleton_application
{
  private:
    TRelation*      _rel;
    TMask*          _msk[2];
    int             _mode;
    TLocalisamfile*  _base, *_basebis;
    int             _anno_dic;
    bool            _soci;
    long            _coddic;  
    TString         _qcomp_prev;
    
  protected:
    virtual bool create();
    virtual void main_loop(); 
    virtual bool destroy();
    virtual void on_config_change();
    static bool filtra_ditte(const TRelation * r); 
    static bool show_menu(TMask_field& fld, KEY k);
    static bool hide_menu(TMask_field& fld, KEY k);
    static bool codditta_handler(TMask_field& fld, KEY k);
    static bool leggi_quadri(TMask_field& f, KEY k);
    static bool exec_soci(TMask_field& fld, KEY k);
            
    void        init_mask(TMask&);
    TMask*      load_mask(int n);

    void        enphasize(TString& qcomp, TMask& m);     
    void        inibith(TString& qric, TMask& m);

    const char* make_prompt(TMask_field& f, stile st);    

    bool        query_mask();    

    void        init_query_mask (TMask&);
    void        init_menu (TMask&);
    bool    lock(const bool lok=TRUE);
    
  public:
    TManutenzione_quadri (); 
    virtual bool firm_change_enabled() const;
};

inline TManutenzione_quadri& app() { return (TManutenzione_quadri&) main_app(); }

TManutenzione_quadri::TManutenzione_quadri(): _soci(FALSE),_rel(NULL) {memset(_msk, 0, sizeof(_msk));}

bool TManutenzione_quadri::filtra_ditte(const TRelation * r)
{           
  const TRectype& ditte_rec = r->lfile().curr();
  const long codditta = ditte_rec.get_long("CODDITTA");
  long  coddic = 0L;
  bool ok = FALSE;
  TLocalisamfile& base = *(app()._base);
  TString16 tipoq;
  
  base.zero();
  base.put("CODDITTA", (long)codditta);
  ok = base.read() == NOERR;
  
  if (ok)
  {
    coddic = base.get_long("CODDITTA");  
    tipoq  = base.get("TIPOQUA");
    ok = tipoq != "D" ? coddic == codditta : FALSE;
  }
  return ok;
}

void TManutenzione_quadri::on_config_change()
{
  _anno_dic = ini_get_int(CONFIG_STUDIO, "77", ANNO_SEL, TDate(TODAY).year());
}
   
bool TManutenzione_quadri::firm_change_enabled() const
{ return false; }   
                                    
// Lancia la gestione soci passando la ditta                                    
bool TManutenzione_quadri::exec_soci(TMask_field& f, KEY k)
{
  if (k == K_SPACE)
  {           
    TString appname("ba4 -5");
    TString body(16);
    const long ditta = get_firm_770();         
    body << FLD_SC1_CODDITTA << "|";
    body << FLD_SC1_CODDITTA << "=";
    body << ditta;        
    TMessage  msg(cmd2name(appname), MSG_FS, (const char*) body);          
                                                                               
    TMailbox mb;                                                           
    mb.send(msg);                                                          

    TExternal_app a(appname);                                                
    a.run();                                                                 
  }                        
  return TRUE;
}

bool TManutenzione_quadri::codditta_handler(TMask_field& f, KEY k)
{
  if (k == K_TAB && !(f.mask().is_running()) )
  {
    f.set(get_firm_770());
    f.check();
  }   
  
  if (f.to_check(k))
  {
    const long codditta = atol(f.get());
// controlla se e' gia' stata inserita una dich. per la ditta
    if (!exist_dichiar_770(codditta))
      return f.warning_box("Dichiarazione non presente");
    else
      set_firm_770(codditta);
  }
  
  return true;
}

TMask* TManutenzione_quadri::load_mask(int n)
{
  if (_msk[n] != NULL)
    return _msk[n];

  TFilename name("776100"); name << char(n == 0 ? 'a' : 'b');
  TMask* m = new TMask(name);

  switch (n)
  {
    case 0:
    {
      m->set_handler(F_CODDITTA, codditta_handler);  
      TEdit_field& rag = m->efield(F_RAGDITTA);
      rag.browse()->cursor()->set_filterfunction(filtra_ditte);
    }
    break;
    case 1:
      m->set_handler(RILEGGI_QUADRI, leggi_quadri);
      break;
    default:
      CHECKD(0, "Che strano genere di maschera e' la ", n);
      break;
  }
  return _msk[n] = m;
}

bool TManutenzione_quadri::create()
{
  _base      = new TLocalisamfile(LF_BASE);
  _basebis   = new TLocalisamfile(LF_BASEBIS);
  _rel       = new TRelation(LF_BASE);
  _rel->add(LF_BASEBIS, "CODDITTA=CODDITTA");                  
  
  // inizializza stato precedente quadri per ottimizzazione enphasize
  _qcomp_prev.spaces(NUM_QUADRI); 

  load_mask(0);
  return TSkeleton_application::create();
}

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

  lock(FALSE);  // release lock  

  delete _rel;
  delete _base; delete _basebis;

  return TApplication::destroy();
}


const char* TManutenzione_quadri::make_prompt(TMask_field& f, stile vivid)
{ 
  __tmp.cut(0);
  
  switch(vivid)
  {
  case sottolineato: __tmp = "@u"; break;
  case grassetto   : __tmp = "$[b]"; break;
  default          : __tmp.cut(0); break;
  }
    
  TString prompt = f.prompt();
  if (prompt[0] == '@')  
    prompt.ltrim(2);
  else
  {
    if (prompt[0] == '$')  
    {
      int pos = prompt.find(']');
      prompt.ltrim(pos+1);
    }
  }  
  __tmp << prompt;
  return __tmp;
}

//
// Disabilito i quadri gia' ricevuti via supp. magnetico
//
void TManutenzione_quadri::inibith(TString& qric, TMask& m)
{
  int   start_dlg   = DLG_STOPREC_A;
  int   dlg;
  
  // quadri fino al quadro U non compreso
  for (int i = 0; i < (NUM_QUADRI-1); i++)
    if (qric[i] == 'X')
    {
      dlg = start_dlg + (i * 2);
      m.field(dlg).disable();
    }
}

// Metto in grassetto  i quadri gia' compilati        
// ma solo quelli variati dal ciclo precedente
// Il quadro L non ha il flag di compilato sul base.
void TManutenzione_quadri::enphasize(TString& qcomp,TMask& m)
{
  // quadri fino al quadro U non compreso
  for (int i = 0; i < (NUM_QUADRI-1); i++)
  {
    if (qcomp[i] != _qcomp_prev[i])
    {
      const short dlg = DLG_NULL_A + (i * 2);                 
      if (m.id2pos(dlg) > 0)
      {      
        TMask_field& f = m.field(dlg);
        const char* prompt = make_prompt(f, qcomp[i] == 'X' ?  grassetto : piano);
        f.set_prompt(prompt);
        _qcomp_prev[i] = qcomp[i];
      }
    }
  }
}

bool TManutenzione_quadri::show_menu(TMask_field& f, KEY k)
{
if (k == K_SPACE)  
  {
    if (f.dlg() == DLG_MANUTENZ)                      // enter su menu
    {                                                 // dati anagrafici  
      f.mask().hide(-MENU_MAIN);
      f.mask().show(-MENU_DATIANAG); 
      f.mask().set_focus_field(DLG_STOPREC_DICH);
      f.mask().set_caption("Manutenzione dati anagrafici");  
      return TRUE; 
    }  
    if (f.dlg() == DLG_STOPREC_ST)                    // enter su menu  
    {                                                 // stampe        
      f.mask().hide(-MENU_MAIN);        
      f.mask().show(-MENU_STAMPE);           
      f.mask().set_focus_field(DLG_STOPREC_ST0);             
      f.mask().set_caption("Stampe");  
      return TRUE;
    }   
    if (f.dlg() == DLG_STOPREC_SD)                    // enter su menu
    {                                                 // soggetto dichiarante
      f.mask().hide(-MENU_MAIN);           
      f.mask().show(-MENU_SOGGDICH);         
      f.mask().set_focus_field(DLG_STOPREC_SD0);
      f.mask().set_caption("Soggetto dichiarante");
      return TRUE;
    }  
    if (f.dlg() == DLG_STOPREC_STQD)                  // enter su menu 
    {                                                 // stampe dichiarazioni
      f.mask().hide(-MENU_STAMPE);    
      f.mask().show(-MENU_STAMPEDICH_VIS);       
      f.mask().set_focus_field(B_BASE);
      f.mask().set_caption("Stampe dichiarazioni");
      return TRUE;
    }           
    return FALSE;             
  }
  return TRUE;    
}

bool TManutenzione_quadri::hide_menu(TMask_field& f, KEY k)
{
  if (k == K_SPACE)  
  {
    if (f.mask().field(DLG_STOPREC_DICH).shown())     // cancel da menu
    {                                                 // dati anagrafici  
      f.mask().hide(-MENU_DATIANAG);
      f.mask().show(-MENU_MAIN_VIS);      
      f.mask().first_focus(DLG_MANUTENZ);
      f.mask().set_caption("Manutenzione dichiarazione");  
      return TRUE; 
    }  
    if (f.mask().field(DLG_STOPREC_ST0).shown())      // cancel da menu  
    {                                                 // stampe        
      f.mask().hide(-MENU_STAMPE);
      f.mask().show(-MENU_MAIN_VIS);       
      f.mask().first_focus(DLG_STOPREC_ST);                
      f.mask().set_caption("Manutenzione dichiarazione");  
      return TRUE;
    }   
    if (f.mask().field(DLG_STOPREC_SD0).shown())      // cancel da menu
    {                                                 // soggetto dichiarante
      f.mask().hide(-MENU_SOGGDICH);
      f.mask().show(-MENU_MAIN_VIS);         
      f.mask().first_focus(DLG_STOPREC_SD);                
      f.mask().set_caption("Manutenzione dichiarazione");  
      return TRUE;
    }  
    return FALSE;             
  }
  return TRUE;  
}

void TManutenzione_quadri::init_menu(TMask& m)
{
  m.set(F_ANNODIC, _anno_dic); 
  
  const long codditta = _msk[0]->get_long(F_CODDITTA);
  TString80 ragsoc(_msk[0]->get(F_RAGDITTA));
  m.set(F_CODDITTA, codditta);
  m.set(F_RAGDITTA, ragsoc);

// Se persona giuridica c'e' la voce "Amministratori" 
  _soci = tipo_persona(codditta) == 'G';
  m.enable(DLG_MANUTENZ_SOCI, _soci);
  m.set_handler(DLG_MANUTENZ_SOCI, exec_soci);  

// Se non e' giuridica non si puo' usare il quadro G  
  m.enable(DLG_STOPREC_G, _soci);
  
// aggancio handler d'ingresso sui menu
  m.set_handler(DLG_MANUTENZ,    show_menu);
  m.set_handler(DLG_STOPREC_ST,  show_menu);
  m.set_handler(DLG_STOPREC_SD,  show_menu); 
  m.set_handler(DLG_STOPREC_STQD,show_menu);  

// Se non e' un dichiarante disabilita la corrispondente voce
  m.enable(DLG_STOPREC_SD, sogg_dic(codditta));
      
// Evidenzia i quadri compilati o inibiti  
  TString qcomp(NUM_QUADRI), qric(NUM_QUADRI);

// 1.5       
  _basebis->setkey(1);
  _basebis->zero();                                 
  _basebis->put("CODDITTA", codditta);        
  int rt = _basebis->read();  
  qcomp = _basebis->get("QCOMP");
  qric  = _basebis->get("QSUPPRIC");
     
  if (qcomp == "") qcomp.spaces();  
  if (qric == "")  qric.spaces();
    
  enphasize (qcomp, m);
  inibith   (qric, m);
}

bool TManutenzione_quadri::lock(const bool lok)
{
  TLocalisamfile& base = *_base;
  
  base.setkey(1);
  base.zero();
  base.put("CODDITTA", get_firm_770());        
  const int rt = base.read(_isequal, _testandlock);  
  if (rt != NOERR)
    return error_box("Impossibile leggere i dati: errore %d", rt);
  
  if (lok)
  {  
    if (rt != NOERR)              
    {
      if (rt == _islocked)                                            
        return message_box("I dati sono gia' in uso ad un altro programma.");  
    }
    
    const bool in_uso = base.get_bool("IN_USO");
  
    if (in_uso)
      return message_box("I dati sono gia' in uso ad un altro programma");    
    else
    {
      base.put("IN_USO", "X");
      const int rewr = base.rewrite();
#ifdef DBG  
      if (rewr != NOERR)
        return message_box("Rewrite fallita errore %d.", rewr);
#endif    
    }                      
  }
// Release lock  
  else
  {
    base.put("IN_USO", " ");
    const int rewr = base.rewrite();
#ifdef DBG  
    if (rewr != NOERR)
      return message_box("Rewrite fallita errore %d", rewr);
#endif    
  }  
  base.reread(_unlock);
  return TRUE;
}


// Forza la rilettura dei quadri compilati
bool TManutenzione_quadri::leggi_quadri(TMask_field& f, KEY k)
{
  if (k == K_TAB)
  {
    app().init_menu(f.mask());
    xvtil_statbar_set(""); // serve per ripristinare la statusbar 
  }  
  return TRUE;
}

void TManutenzione_quadri::init_query_mask(TMask& m)
{
  m.set(F_ANNODIC, _anno_dic);
}

void TManutenzione_quadri::main_loop()
{
  KEY tasto = K_TAB;
  while (tasto != K_QUIT) 
  { 
               
// eseguo la prima maschera (richiesta codice ditta) solo la prima volta,
// oppure quando esco dal menu manutenzione quadri con "Annulla"    
    if (tasto != K_ESC) 
    {                 
      if (!query_mask()) 
       return;
// Disabilita cambio ditta
      enable_menu_item(M_FILE_NEW, FALSE);
// Disabilita cambio parametri
      enable_menu_item(M_FILE_REVERT, FALSE); 
// Impegna ditta      
      if (!lock(TRUE))
       continue;        
// carico la maschera di manutenzione quadri      
      load_mask(1);
      _msk[1]->autoload(*_rel);       
      init_menu(*_msk[1]);  
      _msk[1]->open_modal();       
    }                                             
    
// eseguo la maschera di manutenzione quadri      
    tasto = _msk[1]->run();
    
    switch (tasto)
    {
      case K_ESC : 
// forzo l'esecuzione dell'handler del bottone "Annulla" 
// se ritorna false significa che era attivo il menu principale
// e quindi permetto la riesecuzione della maschera di richiesta ditta          
        if (!(hide_menu(_msk[1]->field(DLG_CANCEL), K_SPACE)))
        {
          tasto = K_TAB;   
          lock(FALSE);      // release lock
          _msk[1]->close_modal(); // chiude maschera
        } 
        break;
      case K_QUIT : 
        lock(FALSE);      // release lock
        _msk[1]->close_modal(); // chiude maschera 
        break;        
      case K_SAVE :
        break;
      default:
        break;
    }
  
  } 
}

bool TManutenzione_quadri::query_mask()
{
  load_mask(0);
  init_query_mask(*_msk[0]);    
  _msk[0]->first_focus(DLG_OK);
  const KEY ch = _msk[0]->run();        
  return ch == K_ENTER;
}

int MenuQuadri (int argc, char* argv[])
{
  TManutenzione_quadri a;
  a.run(argc, argv, TR("Gestione percipienti"));
  return 0;
}