campo-sirio/ve/ve6500.cpp

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

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

#include "ve6.h"
#include "ve6500.h"                                                          //cos<6F> 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
{                                                                                       //<2F> la funzione che gestisce gli
  switch (f.dlg())                                                                      //eventi, tipo pressione dei tasti
  {       
  case F_FILE:
    if(e==fe_button)                   //se e (che <20> 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";
      
      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 (<28> una finestra tipo gestione risorse Windows)
      strcpy(fs.type, "dat");
      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_init && f.get().empty())                  
			f.set("articoli.dat");
    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_TIPORIGA:                     
    if(e==fe_init && f.get().empty())                  
			f.set("01");
    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<70> essere solo 0 o 1) in un intero (tipo)
      
      if (tipo==0)                    //se tipo=0 (sceglie la registrazione Quantit<69>, 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<63> la gestio
  _gestmultimag=_gestmag && ini.get_bool("GESMULTIMAG");  //depositi non pu<70> 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
}

                                                     
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  <20> un intero che specifica quanti parametri vengono passati al
                                                      //programma dalla linea di comando
  if (args <= 2)
    return FALSE;                                     //argv  <20> 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'<27> 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 <20> 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<69> la prima riga libera: <20> 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 (!has_module(POAUT, CHK_DONGLE))
	{
    error_box("Modulo penna ottica non attivato");
		return;
	}

  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
                                                                         //<2F> 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 <20> 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<69> di archiviazione (0=quantit<69>, 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 
		TTracciato_record & rec = *(articoli.t_rec(""));
		const int nfields = rec.tracciati_campo().items();
    TString codice;                                       //crea una stringa per contenere il codice

    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 <20> 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)
				ini.set(RDOC_TIPORIGA,tiporiga);                                                            
	      ini.set(RDOC_CODARTMAG, NULL_CODART);              // scrive il codice per forzare il check

				for (int f = 0; f < nfields; f++)
				{
					const TTracciato_campo & c = rec.get(f);
					const TString name = c.name();
					if (name.not_empty())
					{
						TString val = articolocor.get(f);
						val.trim();

						if (name == RDOC_CODART)
							codice = val;
						else
							if (name == RDOC_QTA && tipo==1)
							{ 
          
								TArticolo_giacenza art(codice);
								real quantita(val);

								const real giacenza=art.disponibilita(annoes,codmag,"",TRUE);
								quantita = giacenza - quantita;
								val = quantita.string();			
							}
		        ini.set(name, val);                       // scrive il codice sul file ini
					}
        }
      }                                                       
      else
        break;                           
    } 
		articoli.close();
		xvt_fsys_removefile(nomefile);
  }
     
}  

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

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