campo-sirio/ve/ve6500.cpp

#include <applicat.h>
#include <automask.h>
#include <config.h>
#include <filetext.h>

#include "../cg/cglib01.h"
#include "../mg/mglib.h"

#include "ve6.h"
#include "ve6500.h"                                                          //cosí includo i codici dei campi della maschera ve6500.uml

#include <rdoc.h>
#include <doc.h>
#include "../mg/anamag.h"

//////////   Dichiarazione delle classi   /////////////////////

class TPenna_mask : public TAutomask
{
private:
  bool _gestmag;
  bool _gestdep;
  bool _gestmultimag;
    
protected:
  virtual bool on_field_event(TOperable_field& f, TField_event e, long jolly);
  virtual void on_firm_change();
     
public:
  TPenna_mask();
  virtual ~TPenna_mask(){}  
};

bool TPenna_mask::on_field_event(TOperable_field& f, TField_event e, long jolly)        //definizione di on_field_event
{                                                                                       //é la funzione che gestisce gli
  switch (f.dlg())                                                                      //eventi, tipo pressione dei tasti
  {       
  case F_FILE:
    if(e==fe_button)                   //se e (che é l'evento) = pressione del bottone 'cerca' (fe button)
    {
      DIRECTORY dir; 
      FILE_SPEC fs;
    
      TFilename fname=f.get();         //se il nome del file non esiste -> gli assegna automaticamente il nome
      if(fname == "")                  //articoli.dat
      {
        fname = "articoli.dat";
      }
      
      xvt_fsys_get_dir(&dir);          //funzioni di xvt (grafica); utilizzate per creare la finestra di ricerca del
      xvt_fsys_get_dir(&fs.dir);       //file di tipo .dat (é una finestra tipo gestione risorse Windows)
      strcpy(fs.type, fname.ext());
      strcpy(fs.name, fname);
      strcpy(fs.creator, "ELD");
        
      const bool good = xvt_dm_post_file_open(&fs, "Selezionare il file ...") == FL_OK;
      xvt_fsys_set_dir(&dir);
                     
      if (good)
      {                 
        xvt_fsys_convert_dir_to_str(&fs.dir, fname.get_buffer(), fname.size());   //converte il nome della directory in una
        fname.add(fs.name);                                                       //stringa aggiungendo il path del file
        f.set(fname);                                                         //mostra il campo sul video (la funzione set) 
      }
      
    }
    if(e==fe_close)                //se e = alla pressione del bottone 'chiudi' (fe_close) controlla che il campo sia stato
    {                              //riempito correttamente nella maschera
      TFilename n=f.get();
      return n.exist();
    }     
    break;
  
  case F_TIPO:                        //scelta del tipo di registrazione
    if(e==fe_init || e==fe_modify)    
    {
      int tipo = get_int(F_TIPO);     //trasforma F_TIPO (che puó essere solo 0 o 1) in un intero (tipo)
      
      if (tipo==0)                    //se tipo=0 (sceglie la registrazione Quantitá, vedi maschera) nasconde le opzioni
      {                               //relative a differenza giacenza (GROUP 1 -> hide -1)
        hide(-1);  
      }
      
      else                            //se tipo<>0 (sceglie la registrazione Diff. giacenze, vedi maschera) mostra le
      {                               //opzioni relative a diff. giac.
        show(-1);
        
        if (!_gestdep)
        {
          hide(F_DEP);
        }  
      }
    }
    break;
    
  default:
    break;
  }
  return TRUE;
}



void TPenna_mask::on_firm_change()               //funzione per settare i campi maschera in base alla ditta scelta
{
  TAutomask::on_firm_change();
  TConfig ini(CONFIG_DITTA,"mg");                     //apre il file di configurazione della ditta (modulo mg required)
  
  _gestmag=ini.get_bool("GESMAG");                    //setta la var bool in base all'interrogazione con get_bool (ovvero: se
                                                      //GESMAG esiste->true, altrimenti false
  _gestdep=_gestmag && ini.get_bool("GESDEPOSITI");   //fa la stessa cosa con la GESDEPOSITI (l'and ci vuole perché la gestio
  _gestmultimag=_gestmag && ini.get_bool("GESMULTIMAG");  //depositi non puó esistere senza il magazzino; uguale per la 
                                                          //GESMULTIMAG
  
}


TPenna_mask::TPenna_mask():TAutomask("ve6500")       //contructor di TPenna_mask;public di TAutomask chiama la maschera ve6500 
{
  on_firm_change();                                  //chiama la funzione on_firm_change, che aggiorna in tutti i campi della
                                                     //maschera che fanno rif. ad una ditta, con il rif. alla ditta attuale
}                                                    //In pratica resetta i campi della maschera, che potevano essere settati
                                                     //precedentemente per un'altra ditta

                                                     
class TPenna_app : public TSkeleton_application
{
private:
  TFilename _ini_name;
  int _first_row;
  
protected:
  virtual void main_loop();

public:
  bool load_ini();  
};


///////////   Definizione delle funzioni membro   ////////////

bool TPenna_app::load_ini()                           //definizione della member function load_ini, della classe TPenna_app
{   
  const int args = argc();                            //argc  é un intero che specifica quanti parametri vengono passati al
                                                      //programma dalla linea di comando
  if (args <= 2)
    return FALSE;                                     //argv  é un array di null-terminated strings

  const TString& arg = argv(2);
  if ((arg[0] != '-' && arg[0] != '/') || (arg[1] != 'i' && arg[1] != 'I'))
    return FALSE;
    
  _ini_name = arg.mid(2);
  if (_ini_name.blank() && args > 3)  
    _ini_name = argv(3);
    
  if (!_ini_name.exist())                            //controlla che il file su cui deve scrivere ci sia; se non c'é dá
    return FALSE;                                    //una segnalazione di errore
  
  TConfig ini(_ini_name, "Main");                    //istanza di TConfig, chiamata ini
  TString_array paragrafi;                           //array di stringhe
  int numpar = ini.list_paragraphs(paragrafi);       //legge la lista dei paragrafi, li conta e mette il numero in numpar; lo
                                                     //fa la funzione num_paragraphs
  if(numpar<2)
    return FALSE;
    
  TToken_string para(paragrafi.row(numpar-1),',');   //istanzia (con il nome di para) la classe TToken_string, utilizzando il suo
                                                     //primo constructor (ne ha 3); setta come separatore di caratteri la , al
                                                     //posto del | di default; row é un metodo della classe TString_array che
                                                     //ritorna la stringa alla posizione specificata dal parametro
  _first_row = para.get_int(1)+1;                    //assegna a _first_row il numero (trasformato da una stringa con get_int)
                                                     //dell'ultima riga usata+1, cioé la prima riga libera: é il punto in cui
                                                     //cominciare a scrivere
  return TRUE;                                                                                         
}


void TPenna_app::main_loop()                              //definizione della member function main_loop, della classe TPenna_app
{                 
  if(! load_ini())
  {
    error_box("Impossibile aprire il file '%s'",(const char*)_ini_name); //mostra un messaggio di errore se non riesce ad aprire
                                                                         //il file richiesto; nota la conversione dei tipi che
                                                                         //é da eseguire quando devo passare una TString ad un %s  
    return;
  }
  
  open_files(LF_TAB,LF_TABCOM,LF_DOC,LF_RIGHEDOC,LF_ANAMAG,LF_MAG,LF_UMART,0);
    
  TPenna_mask m;                                          //istanza di TPenna_mask con il nome m (perche'ho chiamato una maschera)
  if(m.run()==K_ENTER)
  {
    TConfig ini(_ini_name, "Main");                       //apre il file su cui scrivere
                                                          //chiamo il nome del file F_FILE che abbiamo scelto con la maschera; get
                                                          //legge una stringa
    ini.set("Result", "SUCCESS");                         //comunica al chiamante il successo della transazione                                                      
                                                          
    const TFilename nomefile = m.get(F_FILE);             //assegno alla variabile nomefile la stringa letta con m.get(F_FILE);   
                                                          //nomefile é una variabile di tipo TFilename
    const TString16 tiporiga = m.get(F_TIPORIGA); 
    
    const int tipo = m.get_int(F_TIPO);                   //var int che indica la modalitá di archiviazione (0=quantitá, 1=dif. giac.)  
    
    TString16 para;                                       //codice del paragrafo corrente
    
                                                          
    TFile_text articoli(nomefile,"opticpen.ini");         //crea un oggetto articoli di tipo TFile_text
    TRecord_text articolocor;                             //crea un record vuoto con nome articolocor 
    TString codice;                                       //crea una stringa per contenere il codice

    real quantita;                                        //crea una variabile reale per contenere la quantita'; ovviamente
                                                          //istanzio dalla classe real
    para.format("%d", LF_DOC);                             
    
    TDate datadoc(ini.get(DOC_DATADOC, para));      //dal paragrafo testata documento prende il valore della data del
                                                     //documento
    TEsercizi_contabili esc;                         //crea un oggetto esc di tipo TEsercizi_contabili
    TString16 annoes;
    annoes.format("%04d", esc.date2esc(datadoc));    //crea un intero lungo 4 riempito di 0 all'inizio
    TString16 codmag = m.get(F_MAG);                 // setta codmag in base al valore della maschera
    codmag.left_just(3) << m.get(F_DEP);             // attacca a codmag il F_DEP, codice deposito dalla maschera  

    
    articoli.open();                                      //applico il metodo open che apre il file in lettura (contenuta in TFile_text)
    for(int i=_first_row;articoli.ok_r();i++)             //ok_r é una funzione che indica la fine del file
    { 
      
      if(articoli.read(articolocor)==NOERR)
      { 
        para.format("%d,%d", LF_RIGHEDOC,i);               // scrive i due numeri (%d) separati dalla , con format (che formatta
                                                           // la stringa para con il formato specificato tra " ")
        ini.set_paragraph(para);                           // sposta il cursore sulla nuova para (nuovo valore)
        
        
        codice = articolocor.get(1);                     // assegno a codice il valore del primo campo; attraverso il .ini lui
                                                         // sa giá che sono i primi 15 caratteri del file; la funzione 
                                                        // get(int pos) é in TRecord_text di Filetext.h assegno a quantita
        quantita = real(articolocor.get(2));             // il valore del secondo campo del record; tutto il resto é come
                                                         // sopra; poiché quantita é un real mentre get ritorna una stringa,
                                                         // devo ridefinire localmente l'output di get, trasformandolo in 
                                                         // real (operazione di cast)
                                                           
        if (tipo==1)
        { 
          
          TArticolo_giacenza art(codice);
          const real giacenza=art.disponibilita(annoes,codmag,"",TRUE);
          quantita = giacenza - quantita;
        }
                                                           
                                                                   
        ini.set(RDOC_TIPORIGA,tiporiga);                                                            
        ini.set(RDOC_CODART,codice);                       // scrive il codice sul file ini
        ini.set(RDOC_CODARTMAG, NULL_CODART);              // scrive il codice per forzare il check
        ini.set(RDOC_QTA,quantita.string());               // scrive la quantitá sul file ini dopo averla trasformata in stringa                               
      }                                                       
      else
        break;                           
    }                                             
  }
     
}  

//////  Esecuzione del programma  ///////////

int ve6500(int argc, char** argv)
{
  TPenna_app app;
  app.run(argc,argv,"Penna Ottica");
  return 0;
}