campo-sirio/ve/ve2300.cpp

#include <relapp.h>
#include <config.h>

#include "ve2300.h"

#define DESTROY(x) { _msk->field(x).reset_key(1); _msk->hide(x); }
#define CREATE(x) { _msk->field(x).set_key(1); _msk->show(x); }
#define KILL(x) { _msk->field(x).reset_key(1); _msk->disable(x); }
#define REVIVE(x) { _msk->field(x).set_key(1); _msk->enable(x); }



enum state { // tipo di var. per la gestione delle abilitazioni dei campi
  hidden, // nascosto, disabilitato, rimosso, distrutto, ucciso... insomma, fuori dai piedi
  disabled, // disabilitato, visibile, non riabilitabile... cio<69> proprio in mezzo ai piedi e senza possibilit<69> di toglierlo
  disactivated, // disabilitato ma visibile... cio<69> giusto tra i piedi
  activated // attivato... cio<69> utilizzabile come gli altri
  };

// il campo unit<69> di misura nella chiave viene gestito con i quattro stati per risolvere i
// conflitti di abilitazione/disabilitazione incrociati tra vari flag e stati del programma:
// il listbox del tipo di riga ha la priorit<69> pi<70> bassa, cambia solo tra gli ultimi due stati
// (disactivated e activated); il flag "GESTUM" nella testata cambia lo stato del campo tra
// gli intermedi (disabled e disactivated); il tipo di archivio cambia tra il primo e il terzo
// stato (hidden e disactivated)



class TRighe_condizioni_vendita: public TRelation_application {
  TMask *_msk; // maschera principale
  TRelation *_rel; // relazione principale

  TString16 _rcondven; // stringa che indica il tipo di archivio
  bool _codlis_catven; // booleano di abilitazione del campo CATVEN

  state _gest_um; // variabile di abilitazione delle unit<69> di misura

  virtual bool user_create();
  virtual bool user_destroy();                        
  virtual TMask *get_mask(int) { return _msk; } // punto d'aggancio tra la maschera della rel.app. e la maschera principale dell'applicazione
  virtual bool changing_mask(int) { return FALSE; } // ritorna il flag di cambio maschera a seconda dei modi di funzionamento, in questa applicazione la maschera <20> una sola quindi il flag <20> FALSE
  virtual bool changing_keys() const { return TRUE; } // ritorna il flag di rigenerazione della lista delle chiavi ad ogni find(), in questa applicazione le chiavi cambiano continuamente quindi il flag <20> TRUE
  virtual TRelation *get_relation() const { return _rel; } // punto d'aggancio tra la relazione della rel.app. e la relazione principale dell'applicazione

  static void hide_and_show_codriga(void); // procedura di abilitazione/disabilitazione dei tre campi CODRIGA (codice riga)

  static bool handle_tiporiga(TMask_field &, KEY); // handler del campo TIPORIGA (articolo, gruppo merc., ragg. fiscale)
  static bool handle_cod(TMask_field &, KEY); // handler del campo COD (codice listino, numero contratto, codice offerta)

  virtual int write(const TMask &); // metodo usato per scrivere il record sul file
  virtual int rewrite(const TMask &); // metodo usato per aggiornare il record sul file
  
public:
  TRighe_condizioni_vendita() {}
  virtual ~TRighe_condizioni_vendita() {}
};



TRighe_condizioni_vendita &app() { // funzione che ritorna il riferimento alla classe principale dell'applicazione
  return (TRighe_condizioni_vendita &)main_app();
}



bool TRighe_condizioni_vendita::user_create() {
  bool gotcha= FALSE; // booleano di avvenuta inizializzazione
  
  _rcondven= "*"; // inizializzazione dell'indicatore del tipo di archivio
  if (argc()>2) { // se c'<27>, prende il tipo di archivio dalla linea di comando
    TString temp(argv(2));
    _rcondven= temp.left(1); // prende solo il primo carattere
  } else {
    TMask choose("VE2300"); // istanzia la maschera di scelta del tipo di archivio
    if (choose.run() == K_ENTER) _rcondven= choose.get(F_TIPORCV); // prende il tipo di archivio dalla maschera
  }
  _rcondven.upper(); // rende la stringa upper-case
  _msk= new TMask("VE2300X");
  TConfig prassid(CONFIG_DITTA, "ve"); // apre il file di configurazione della ditta corrente
  switch (_rcondven[0]) {
  case 'L': // listini
    _gest_um= disactivated; // attiva di default la gestione delle unit<69> di misura pur lasciando il campo disabilitato
    DESTROY(F_R_C_TIPOCF); // settaggio dei campi da eliminare...
    DESTROY(F_R_C_CODCF);
    DESTROY(F_R_C_COD);
    DESTROY(F_R_O_COD);
    _msk->hide(F_R_C_RICERCA);
    _msk->hide(F_R_O_RICERCA);
    _msk->hide(F_R_CO_CODLOTTO);
    _msk->hide(F_R_O_ARTES);
    _codlis_catven= prassid.get_bool("CodLisCV"); // setta il booleano di abilitazione di CATVEN
    if (!_codlis_catven) KILL(F_R_L_CATVEN); // disabilita condizionalmente le categorie di vendita
    set_search_field(F_R_L_RICERCA); // impostazione del campo di ricerca
    _msk->set_handler(F_R_L_COD, handle_cod); // impostazione dell'handler sul campo di controllo della testata
    gotcha= TRUE;
    break;
  case 'C': // contratti
    _gest_um= hidden; // rimuove la gestione delle unit<69> di misura
    DESTROY(F_R_L_CATVEN); // settaggio dei campi da eliminare...
    DESTROY(F_R_L_COD);
    DESTROY(F_R_O_COD);
    DESTROY(F_R_LO_UM);
    _msk->hide(F_R_L_RICERCA);
    _msk->hide(F_R_O_RICERCA);
    _msk->hide(F_R_O_ARTES);
    set_search_field(F_R_C_RICERCA); // impostazione del campo di ricerca
    _msk->set_handler(F_R_C_COD, handle_cod); // impostazione dell'handler sul campo di controllo della testata
    gotcha= TRUE;
    break;
  case 'O': // offerte
    _gest_um= disactivated; // attiva di default la gestione delle unit<69> di misura pur lasciando il campo disabilitato
    DESTROY(F_R_L_CATVEN); // settaggio dei campi da eliminare...
    DESTROY(F_R_C_TIPOCF);
    DESTROY(F_R_C_CODCF);
    DESTROY(F_R_L_COD);
    DESTROY(F_R_C_COD);
    _msk->hide(F_R_L_RICERCA);
    _msk->hide(F_R_C_RICERCA);
    set_search_field(F_R_O_RICERCA); // impostazione del campo di ricerca
    _msk->set_handler(F_R_O_COD, handle_cod); // impostazione dell'handler sul campo di controllo della testata
    gotcha= TRUE;
    break;              
  default: // messaggio di errore se si indica un archivio non valido
    error_box("Indicare l'archivio sulla linea di comando (L, C o O) oppure selezionarla dalla maschera di partenza");
    break;
  }
  if (gotcha) { // se <20> stato selezionato correttamente un archivio completa l'inizializzazione
    _rel= new TRelation(LF_RCONDV); // apre la relazione (un unico file)
    _msk->set(F_R_TIPO, _rcondven); // settaggio del campo di tipo archivio
    _msk->set_handler(F_R_TIPORIGA, handle_tiporiga); // impostazione dell'handler sul campo di selezione del tipo della riga
    hide_and_show_codriga(); // invoca la procedura di controllo della mutua esclusione dei tre campi CODRIGA
  }
  return (gotcha);
}

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

void TRighe_condizioni_vendita::hide_and_show_codriga() {
  TMask *_msk= app()._msk; // prende il puntatore alla maschera principale dell'applicazione
  if (_msk->query_mode()) { // se la maschera <20> in modo query procede con i controlli...
    short id_campi[3]= { F_R_CODRIGA_A, F_R_CODRIGA_G, F_R_CODRIGA_R }; // vettore degli identificatori dei tre campi CODRIGA in mutua esclusione
    char tag_campi[3]= { 'A', 'G', 'R' }; // vettore dei tag di TIPORIGA per i tre campi CODRIGA in mutua esclusione
    state &_gest_um= app()._gest_um; // prende il riferimento al booleano di abilitazione delle unit<69> di misura
    TString &_rcondven= app()._rcondven; // prende il riferimento alla stringa di tipo di archivio
    char tag_campo= toupper(_msk->get(F_R_TIPORIGA)[0]); // prende il tag del campo da abilitare in TIPORIGA
    for (int i=0; i<3; i++) { // ciclo sui tre campi CODRIGA
      if (tag_campo == tag_campi[i]) { CREATE(id_campi[i]); } // il campo indicato con il tag viene reso visibile
      else { DESTROY(id_campi[i]); } // i campi non corrispondenti al tag vengono resi invisibili
    }
    if ((_gest_um != hidden) && (_gest_um != disabled)) { // se <20> abilitata (o abilitabile) la gestione delle unit<69> di misura ed <20> stata selezionata una riga di articoli...
      if (tag_campo=='A') _gest_um= activated; // ...il campo "unit<69> di misura" viene abilitato...
      else _gest_um= disactivated; // ...altrimenti viene disabilitato
    }
    switch (_gest_um) {
    case hidden: // se l'unit<69> di misura deve essere fuori dai piedi...
      DESTROY(F_R_LO_UM); // ...il campo viene relativo soppresso
      break;
    case disabled: // se l'unit<69> di misura deve essere tra i piedi (ma inutilizzabile)
    case disactivated:
      CREATE(F_R_LO_UM); // ...il campo relativo viene rimesso al mondo...
      KILL(F_R_LO_UM); // ...ma subito ucciso
      break;
    case activated: // se l'unit<69> di misura deve funzionare...
      CREATE(F_R_LO_UM); // ...il campo relativo viene rimesso al mondo...
      REVIVE(F_R_LO_UM); // ...e lasciato vivere in pace
      break;
    }
  }
}       

bool TRighe_condizioni_vendita::handle_tiporiga(TMask_field &fld, KEY k) {
  if (k==K_SPACE) hide_and_show_codriga(); // invoca la procedura di controllo della mutua esclusione dei tre campi CODRIGA
  return TRUE;
}

bool TRighe_condizioni_vendita::handle_cod(TMask_field &fld, KEY k) {
  if ((k==K_TAB) && fld.get().not_empty()) {
    state &_gest_um= app()._gest_um; // prende il riferimento al booleano di abilitazione delle unit<69> di misura
    TString &_rcondven= app()._rcondven; // prende il riferimento alla stringa di indicazione del tipo di archivio
    TMask *_msk= app()._msk; // prende il puntatore alla maschera principale dell'applicazione
    TLocalisamfile condv(LF_CONDV); // apre il file della testata (condizioni di vendita)
    condv.put("TIPO", _rcondven); // riempie il campo "TIPO"
    switch (_rcondven[0]) {
    case 'L': // riempie il resto della chiave dei listini
      condv.put("CATVEN", _msk->get(F_R_L_CATVEN));
      condv.put("COD", _msk->get(F_R_L_COD));
      break;
    case 'C': // riempie il resto della chiave dei contratti
      condv.put("TIPOCF", _msk->get(F_R_C_TIPOCF));
      condv.put("CODCF", _msk->get(F_R_C_CODCF));
      condv.put("COD", _msk->get(F_R_C_COD));
      break;
    case 'O': // riempie il resto della chiave delle offerte
      condv.put("COD", _msk->get(F_R_O_COD));
      break;
    }
    if (condv.read()==NOERR) { // se la lettura <20> andata a buon fine abilita/disabilita i campi della maschera in base ai booleani della testata
      if (_gest_um != hidden) { // se le unit<69> di misura possono essere utilizzate...
        if (!(condv.get_bool("GESTUM"))) _gest_um= disabled; // ma nella testata sono disabilitate, setta la disabilitazione del campo "unit<69> di misura"...
        else _gest_um= disactivated; // altrimenti ne setta la possibile abilitazione
      }
      hide_and_show_codriga(); // lancia la funzione che si occupa di abilitare/disabilitare il campo "unit<69> di misura"
      if (!condv.get_bool("GESTSCAGL")) {
        KILL(F_R_NSCAGL); // disabilita il campo "numero scaglione"
        _msk->disable(F_R_QLIM); // disabilita il campo "quantit<69> limite scaglione"
      } else {
        REVIVE(F_R_NSCAGL); // abilita il campo "numero scaglione"
        _msk->enable(F_R_QLIM); // abilita il campo "quantit<69> limite scaglione"
      }
      if (!condv.get_bool("GESTSCO")) {
        _msk->disable(F_R_SCONTO); // disabilita il campo "sconto"
        _msk->disable(F_R_QOM); // disabilita il campo "quantit<69> art. omaggio"
        _msk->disable(F_R_QBASE); // disabilita il campo "quantit<69> base x sconto"
        _msk->disable(F_R_CODARTOM); // disabilita il campo "codice articolo omaggio"
        _msk->disable(F_R_PROMAGGIO); // disabilita il campo "prezzo omaggio"
        _msk->disable(F_R_UMOM); // disabilita il campo "unit<69> di misura art. omaggio"
      } else {
        _msk->enable(F_R_SCONTO); // abilita il campo "sconto"
        _msk->enable(F_R_QOM); // abilita il campo "quantit<69> art. omaggio"
        _msk->enable(F_R_QBASE); // abilita il campo "quantit<69> base x sconto"
        _msk->enable(F_R_CODARTOM); // abilita il campo "codice articolo omaggio"
        _msk->enable(F_R_PROMAGGIO); // abilita il campo "prezzo omaggio"
        _msk->enable(F_R_UMOM); // abilita il campo "unit<69> di misura art. omaggio"
      }
      return TRUE;
    } else {
      error_box("Non esiste una testata corrispondente alla chiave specificata");
      return FALSE;
    }
  } else return TRUE;
}

int TRighe_condizioni_vendita::write(const TMask &m) {
  m.autosave(_rel); // scrive il contenuto della maschera nel record della relazione
  if (_rcondven != "C") { // se non si sta lavorando sui contratti il campo TIPOCF deve essere svuotato sul file
    TLocalisamfile &f= _rel->lfile(); // prende il file principale della relazione
    TRectype &r= f.curr(); // prende il record corrente del file principale
    f.zero("TIPOCF"); // svuota il campo TIPOCF
  }
  _rel->write(); // invoca la scrittura della relazione
  return (_rel->status()); // ritorna lo stato della relazione
}

int TRighe_condizioni_vendita::rewrite(const TMask &m) {
  m.autosave(_rel); // scrive il contenuto della maschera nel record della relazione
  if (_rcondven != "C") { // se non si sta lavorando sui contratti il campo TIPOCF deve essere svuotato sul file
    TLocalisamfile &f= _rel->lfile(); // prende il file principale della relazione
    TRectype &r= f.curr(); // prende il record corrente del file principale
    f.zero("TIPOCF"); // svuota il campo TIPOCF
  }
  _rel->rewrite(); // invoca la riscrittura della relazione
  return (_rel->status()); // ritorna lo stato della relazione
}



int ve2300(int argc, char* argv[]) {
  TRighe_condizioni_vendita a;
  
  a.run(argc, argv, "Righe condizioni vendita ");
  return 0;
}