//EDITOR DI MASCHERE: applicazione di supporto alla creazione di maschere

#include <applicat.h>
#include <colors.h>
#include <urldefid.h>
#include <window.h>
#include <controls.h>
#include <xvtility.h>
#include <xvt_defs.h>
#include <strings.h>
#include <mask.h>
#include <msksheet.h>                                  
#include <keys.h> 
#include <sheet.h>
#include <execp.h>

//inclusione degli identificatori delle maschere di supporto
#include "ba2600b.h" //per i controlli
#include "ba2600a.h" //per la maschera

class TEditMask_control;  
class TEditMask_sheet;

//--------------------------------------------------------------------
// Classe TEditMask_window: classe per la definizione della "maschera"
//--------------------------------------------------------------------
class TEditMask_window : public TWindow  
{
  // @cmember:(INTERNAL) Array di controlli
   TArray               _controls;   
  // @cmember:(INTERNAL) Puntatore alla classe di definizione dei controlli
   TEditMask_control*  _controllo;   
  // @cmember:(INTERNAL) Puntatore alla classe di definizione del controllo spreadsheet
   TEditMask_sheet*        _sheet;
  // @cmember:(INTERNAL) Nomi delle pagine della "maschera"
   TString_array            _name;  
  // @cmember:(INTERNAL) Presenza(TRUE) della toolbar
   bool                     _tool;   
  // @cmember:(INTERNAL) Modalit� di lettura(FALSE) o creazione(TRUE) della "maschera"
   bool                     _mode;
  // @cmember:(INTERNAL) Definizione del tipo di visualizzazione ("a"->centrata|"b"->personalizzata)
   TString               _type_vz;   
  // @cmember:(INTERNAL) Pagina della "maschera"
   int                      _page;   
  // @cmember:(INTERNAL) Coordinata X
   int                    _coordx;   
  // @cmember:(INTERNAL) Coordinata Y
   int                    _coordy;   
  // @cmember:(INTERNAL) Dimensione: altezza
   int                       _alt;   
  // @cmember:(INTERNAL) Dimensione :lunghezza
   int                      _lung;   
  // @cmember:(INTERNAL) Coordinata Y della toolbar
   int                    _y_tool;  
  // @cmember:(INTERNAL) Totale pagine
   int                _total_page;   
  // @cmember:(INTERNAL) Numero degli sheet presenti(settaggio nella lettura)
   int                    _nsheet;   
  // @cmember:(INTERNAL) Identificativo dello sheet in considerazione
   int                    _idsheet;   
  // @cmember:(INTERNAL) Rettangolo di definizione della toolbar
   RCT                        _rt;  
  // @cmember:(INTERNAL) Rettangolo di definizione della selezione
   RCT                   _rct_sel;   
  // @cmember:(INTERNAL) File .uml
   TFilename                _file;   
   
protected:

  // @cmember Permette(in una maschera di supporto) il settaggio e la lettura
  // dei campi di definizione della "maschera"
  KEY main_loop();   
  
public:
  // @cmember Aggiunge un controllo di tipo m all'array _controls
  void add_control(MENU_TAG m);     
  // @cmember Aggiunge un controllo di tipo string
  TEditMask_control* addstring();
  // @cmember Aggiunge un controllo di tipo number
  TEditMask_control* addnumber();  
  // @cmember Aggiunge un controllo di tipo currency
  TEditMask_control* addcurrency();
  // @cmember Aggiunge un controllo di tipo button
  TEditMask_control* addbutton();
  // @cmember Aggiunge un controllo di tipo date
  TEditMask_control* adddate();
  // @cmember Aggiunge un controllo di tipo boolean
  TEditMask_control* addboolean();
  // @cmember Aggiunge un controllo di tipo text
  TEditMask_control* addtext();
  // @cmember Aggiunge un controllo di tipo groupbox
  TEditMask_control* addgroup();
  // @cmember Aggiunge un controllo di tipo radiobutton
  TEditMask_control* addradio();
  // @cmember Aggiunge un controllo di tipo memo
  TEditMask_control* addmemo();
  // @cmember Aggiunge un controllo di tipo zoom
  TEditMask_control* addzoom();
  // @cmember Aggiunge un controllo di tipo spreadsheet
  TEditMask_control* addsheet();
  // @cmember Aggiunge un controllo di tipo list
  TEditMask_control* addlist();
  // @cmember Fa una copia dei controlli selezionati
  void copy_crt_sel();
  // @cmember Distrugge un controllo con "Elimina" della maschera di supporto
  void destroy_control(TEditMask_control* c);  
  // @cmember Cancella i controlli selezionati
  void erase_crt_sel(); 
  // @cmember Sposta i controlli selezionati nella pagina richiesta
  void move_crt_sel();  
  // @cmember Ritorna la pagina corrente
  int page() { return _page;} 
  // @cmember Setta il punatatore alla classe del controllo spreadsheet
  void set_sheet(TEditMask_sheet* s)  { _sheet=s;} 
  // @cmember Ritorna il puntatore alla classe del controllo spreadsheet 
  TEditMask_sheet* get_sheet()    { return  _sheet;} 
  // @cmember Apri file: ritorna lo spreadsheet corrispondente alla sua maschera
  TEditMask_control* find_sheet(int i); 
  // @cmember Ridisegna il rettangolo di selezione per permettere lo spostamento
  bool redesign(RCT* rct,int dx,int dy); 
  // @cmember Ritorna il controllo avente il punto pnt 
  TEditMask_control* search(const PNT& pnt); 
  // @cmember Torna TRUE se sono stati trovati dei controlli selezionati
  bool search(RCT* rct); 
  // @cmember Sposta il o i controllo/i selezionati 
  void move(RCT* rct,PNT pntinz, PNT pntfin);
  // @cmember Deseleziona i controlli selezionati
  void deselection();  
  // @cmember Inizializza il rettangolo di selezione
  void inizialition(); 
  // @cmember Disegna una linea nella "maschera"
  void line(short x0, short y0, short x1, short y1) const; 
  // @cmember Converte le coordinate da pixel a caratteri
  PNT& logic(const PNT& p, bool& intool);
  // @cmember Controlla le pagine(devono essere inserite in ordine crescente +1)
  int max_page(int pag);  
  // @cmember Normalizza rettangoli
  void normalize_rect(RCT *norm_rctp, RCT*rctp); 
  // @cmember Risponde all'evento E_CHAR
  void o_key(KEY key);   
  // @cmember Visualizza i controlli presenti nella pagina corrente
  void vision_ctrl();  
  // @cmember Visualizza la "maschera" relativa allo spreadsheet corrente
  void vision_spread();
  // @cmember Visualizza i controlli della "maschera" relativa allo spread corrente
  void vision_sp_ctl();
  // @cmember Aggiunge un controllo del tipo string
  RCT& resize_rect(short x, short y, short dx, short dy, 
                   WIN_TYPE wt = WO_TE, bool intool = FALSE) const; //ridimensiona controlli
  // @cmember Definisce il rettangolo di selezione
  void rubber_rect(WINDOW win, RCT*rctp,PNT p);
  // @cmember Crea il rettangolo di selezione in risposta agli eventi del mouse           
  void selected_crt(WINDOW win, EVENT* ep);  
  // @cmember Definisce l' appartenenza di un punto al rettangolo di selezione
  bool selection(RCT* rct,PNT pnt); 
  // @cmember Setta la modalit� della "maschera"
  void set_mod(bool m) { _mode=m; }
  // @cmember Ritorna la modalit� della "maschera" per evitare controlli impropri 
  bool get_mod() { return _mode; }
  // @cmember Ritorna il nome del file 
  TFilename filename() { return _file; }
  // @cmember Salva il file .uml  richiama<save_page(ostream& out)>
  void create_file();  
  // @cmember Salva il file .h
  void create_fileh(); 
  // @cmember Controlla la "maschera" in fase di salvataggio(non sono salvate pagine prive di controlli)
  int page_null(int page);  
  // @cmember Salva la disposizione della "maschera" per il file .uml
  void save_page(ostream& out);  
  // @cmember Apre un file .uml e ricrea la "maschera"
  void restore_mask(const char* filename);
  // @cmember Legge da file le propriet� delle singole pagine
  void read_page(TScanner& scanner, int pg, bool tool);
  // @cmember Legge da file le propriet� della toolbar
  bool read_tool(TScanner& scanner);  
  // @cmember Legge da file i controlli presenti in ogni singola pagina
  TEditMask_control* read_control(TScanner& scanner,const TString& k, bool intool=FALSE); 
  // @cmember Legge le propriet� della "maschera" da quella di supporto
  void get_mask(TMask& m);  
  // @cmember Gestisce gli eventi
  virtual long handler(WINDOW win, EVENT* ep);  
  // @cmember Setta (con i valori salvati precedentemente) la maschera di supporto
  void set_mask(TMask& m);  
  // @cmember Gestisce la scelta da menu : salva come
  void save_as_mask(); 
  // @cmember Gestisce la scelta da menu : salva
  void save_mask();  
  // @cmember Crea la "maschera" con o senza toolbar
  void set_toolbar(bool tb); 
  // @cmember Fa l'update della "maschera" 
  virtual void update();       
  // @cmember Costruttore
  TEditMask_window(short x,short y,short dx,short dy,
     const char*title,long flags, WIN_TYPE wt); 
  // @cmember Distruttore
  ~TEditMask_window() {}      
};

//------------------------------------------------------------------------
// Classe TEditMask_control: definizione della classe base dei controlli
//------------------------------------------------------------------------
class TEditMask_control : public TObject  
{
  // @cmember:(INTERNAL) Puntatore alla classe di definizione della "maschera"
   TEditMask_window*   _parent;  
  // @cmember:(INTERNAL) Rettangolo del controllo
   RCT                    _rct;   
  // @cmember:(INTERNAL) Definizione della selezione di un controllo
   bool              _selected;   
  // @cmember:(INTERNAL) Controllo in toolbar
   bool                _intool;
  // @cmember:(INTERNAL) Coordinata X
   int                   _left;   
  // @cmember:(INTERNAL) Coordinata Y
   int                    _top;   
  // @cmember:(INTERNAL) Dimensione : lunghezza
   int                  _latox;    
  // @cmember:(INTERNAL) Dimensione : altezza
   int                  _latoy;   
  // @cmember:(INTERNAL) Pagina di appartenenza
   int                    _pag;   
  // @cmember:(INTERNAL) Definizione della priorit� del focus sul controllo
   int                  _focus;    
  // @cmember:(INTERNAL) Campo KEY
   TString                _key;  
  // @cmember:(INTERNAL) Tipo di controllo
   TString         _type_field;   
  // @cmember:(INTERNAL) Campo FIELD 
   TString              _field;   
  // @cmember:(INTERNAL) Campo PROMPT 
   TString             _prompt;    
  // @cmember:(INTERNAL) Identificativo del controllo
   TString                 _id;   
  // @cmember:(INTERNAL) Campo WARNING
   TString            _warning;
  // @cmember:(INTERNAL) Campo CHECKTYPE
   TString              _check;    
  // @cmember:(INTERNAL) Campo FLAGS
   TString               _flag;    
  // @cmember:(INTERNAL) Campo GROUP
   TString              _group;   
  // @cmember:(INTERNAL) Campo MESSAGE
   TString_array      _message;     
   
public:

  // @cmember Setta il campo: CHECKTYPE
  const TString& set_check(const TString& ck);
  // @cmember Setta le coordinate del controllo 
  void set_crd(int x, int y);    
  // @cmember Setta le dimensioni dei controlli
  void set_dim(int ln, int lg); 
  // @cmember Setta i campi principali(_prompt,_pag,_focus,_id,_left,_top) della maschera di supporto 
  void set_field(TMask& mask); 
  // @cmember Setta il campo FLAGS
  const TString& set_flag(const TString& fl);  
  // @cmember Setta la priorit� del focus
  void set_focus(int f) { _focus=f; }
  // @cmember Setta il campo GROUP
  const TString& set_group(const TString& gr); 
  // @cmember Setta il numero di riconoscimento degli spreadsheet <find_sheet()>
  virtual void set_idsheet(int n)  { } 
  // @cmember Setta una propriet� degli spreadsheet
  virtual void set_hismask(bool b)  { } 
  // @cmember Setta l'identificativo
  const TString& set_id(const TString& id);      
  // @cmember Setta il campo MESSAGE
  void set_message(TSheet_field& sp);  
  // @cmember Setta i campi opzionali(_flag,_group,_warning,_check,_key,_field) della maschera di supporto
  void set_option(TMask& mask); 
  // @cmember Setta la pagina di appartenenza del controllo
  void set_page(int p) { _pag=p; } 
  // @cmember Setta il campo PROMPT
  const TString& set_prompt(const TString& prompt);  
  // @cmember Setta la selezione dei controlli
  bool set_selected(bool sl);  
  // @cmember Setta il tipo di controllo
  const TString& set_type(const TString& fld);  
  // @cmember Ritorna il numero di identificazione dello spreadsheet <find_sheet()>
  virtual int get_idsheet() { return -1;}  
  // @cmember Ritorna una propriet� dello spreadsheet 
  virtual bool get_hismask() {return TRUE; }
  // @cmember Legge i campi principali dalla maschera di supporto
  void get_field(TMask& mask); 
  // @cmember Ritorna la priorit� del focus
  int get_focus() { return _focus; }  
  // @cmember Legge dalla maschera di supporto il campo MESSAGE
  void get_message(TSheet_field& sp); 
  // @cmember Legge i campi opzionali dalla maschera di supporto
  void get_option(TMask& mask);
  // @cmember Verifica se un controllo � stato selezionato
  bool get_selected() { return _selected; }  
  // @cmember Stampa su file .uml il campo MESSAGE
  void print_message(ostream& out)const; 
  // @cmember Stampa il file .uml
  virtual void print_on(ostream& out) const;
  // @cmember Legge il file .uml
  virtual void read_from(TScanner& scanner,bool intool) {}; 
  // @cmember Legge le propriet� comuni(principali e opzionali) da file .uml
  void read_field(TScanner& scanner,const TString& tok, bool intool);  
  // @cmember Intercetta un punto
  bool contains(const PNT pnt);  
  // @cmember Scrive il prompt sul controllo 
  void frase(short x, short y) const;  
  // @cmember Nasconde o disabilita un controllo                         
  int flag_crt() const;  
  // @cmember Disegna una linea sulla "maschera"
  void line(short x0, short y0, short x1, short y1) const; 
  // @cmember Ritorna l'offset(nullo per campi non editabili)
  virtual int off()const { return 0; }   
  // @cmember Ridisegna il controllo per permettere lo spostamento
  bool redesign(int dx, int dy); 
  // @cmember Ridimensiona i controlli richiama<RCT& resize_rect(....)>
  void resize_rect();  
  // @cmember Ridimensiona i controlli
  RCT& resize_rect(short x, short y, short dx, short dy, WIN_TYPE wt,bool intool=FALSE)const;
  // @cmember Ritorna il prompt del controllo
  const TString& prt()const { return _prompt; } 
  // @cmember Ritorna l'identificativo
  const TString& ident()const { return _id; }  
  // @cmember Ritorna il tipo del controllo
  const TString& type()const { return _type_field; } 
  // @cmember Ritorna il campo FLAGS
  const TString& flag()const  { return _flag; } //ritorna il flags
  // @cmember Ritorna la lunghezza del prompt
  int prompt_len()const  { return _prompt.len();} 
  // @cmember Ritorna la pagina corrente del controllo
  int page() { return _pag;} 
  // @cmember Ritorna il campo MESSAGE
  const TString_array& message()const  { return _message;} //ritorna message
  // @cmember Definisce la finestra figlio (non NULL solo per spreadsheet)
  virtual TEditMask_window* figlio() { return NULL; } 
  // @cmember Setta,apre,legge la maschera di supporto
  virtual KEY main_loop() { return 0;}  
  // @cmember Definisce il parent
  TEditMask_window& padre()const;  
  // @cmember Definisce la finestra ("maschera")
  WINDOW maschera() const  { return _parent->win(); }
  // @cmember Ritorna il rettangolo del controllo
  RCT rectangle()const { return _rct; } 
  // @cmember Fa l'update del controllo
  virtual void update() const {}       
  // @cmember Duplica il controllo o controlli selezionati
  virtual TObject* dup()const { return new TEditMask_control(*this);}
  // @cmember Costruttore
  TEditMask_control(TEditMask_window* parent);  
  // @cmember Costruttore. Copia tutte le caratteristiche del controllo
  TEditMask_control(const TEditMask_control& ctl);
  // @cmember Distruttore
  virtual ~TEditMask_control() {}                       
};

//------------------------------------------------------------------------
// Classe TEditMask_string: definizione della classe per il controllo 
//                          di tipo STRING
//------------------------------------------------------------------------
class TEditMask_string: public TEditMask_control    
{
  // @cmember:(INTERNAL) Lunghezza effettiva del controllo
   int                 _lungsz;    
  // @cmember:(INTERNAL) Lunghezza a video del controllo
   int                 _lungvd;
  // @cmember:(INTERNAL) Offset: spazi terminali del prompt
   int                 _offset;  
  // @cmember:(INTERNAL) Lunghezza di supporto
   int                 _lngspt;    
  // @cmember:(INTERNAL) Browse(use,input,join,output,diplay,copy)
   TString                _use;   
  // @cmember:(INTERNAL) Add Run
   TString               _addr; 

public:
  // @cmember Ritorna la lunghezza a video
  int dim_video()const  { return _lungvd;}
  // @cmember Controlla la lunghezza in caso di valoti nulli
  void error_lung(int lsz, int lvd);
  // @cmember Setta i campi relativi ad _use ed _offset sulla maschera di supporto
  void set_bwoff(TMask& m);  
  // @cmember Legge i campi _use e _offset dalla maschera di supporto
  void get_bwoff(TMask& m);  
  // @cmember Legge dalla maschera di supporto le lunghezze
  void get_lngz(TMask& m);
  // @cmember Setta le lunghezze sulla maschera di supporto
  void set_lngz(TMask& m);
  // @cmember Setta l'offset
  void set_offset(int d);
  // @cmember Ritorna l'offset
  virtual int off()const  { return _offset;} 
  // @member Fa l'update del controllo
  virtual void update() const;
  // @member Legge il file .uml
  virtual void read_from(TScanner& scanner,bool intool);
  // @member Legge da file le lunghezze
  void read_lngz(TScanner& scanner);
  // @member Legge da file l'offset
  int read_off(const TString& prt);
  // @member Legge da file la combinazione del browse(use,input,join,output,display,copy)
  void read_use(TScanner& scanner,const TString& tok);
  // @member Stampa su file la lunghezza
  void print_lngz(ostream& out) const;
  // @member Stampa su file il browse
  void print_use(ostream& out)const; 
  // @member Stampa il file .uml
  virtual void print_on(ostream& out) const;   
  // @member Setta,apre,legge i campi della maschera di supporto
  virtual KEY main_loop();  
  // @member Duplica il controllo
  virtual TObject* dup()const { return new TEditMask_string(*this);}
  // @member Costruttore
  TEditMask_string(TEditMask_window* parent);
  // @member Costruttore.Copia tutte le caratteristiche del controllo           
  TEditMask_string(const TEditMask_string& ctl);
  // @member Distruttore
  virtual ~TEditMask_string() {}
};                    

//------------------------------------------------------------------------
// Classe TEditMask_number: definizione della classe per il controllo 
//                          di tipo NUMBER
//------------------------------------------------------------------------
class TEditMask_number: public TEditMask_string     
{ 
  // @cmember:(INTERNAL) Numero di decimali
   int             _decimals;  
  // @cmember:(INTERNAL) Lunghezza 
   int                _latox;   
  // @cmember:(INTERNAL) Campo PICTURE
   TString          _picture;  

public:

  // @member Setta i decimali
  void set_decimal(int d);
  // @member Setta il campo PICTURE
  const TString& set_picture(const TString& pic);  
  // @member Legge il file.uml
  virtual void read_from(TScanner& scanner, bool intool);
  // @member Stampa il file .uml
  virtual void print_on(ostream& out) const;
  // @member Setta,apre,legge la maschera di supporto
  virtual KEY main_loop();
  // @member Duplica il controllo
  virtual TObject* dup()const { return new TEditMask_number(*this);}//per duplicare
  // @member Costruttore
  TEditMask_number(TEditMask_window* parent) ;
  // @member Costruttore. Copia tutte le propriet� del controllo
  TEditMask_number(const TEditMask_number& ctl);
  // @member Distruttore
  virtual ~TEditMask_number() {}
};

//------------------------------------------------------------------------
// Classe TEditMask_currency: definizione della classe per il controllo 
//                          di tipo CURRENCY
//------------------------------------------------------------------------
class TEditMask_currency: public TEditMask_number     
{  
  // @cmember:(INTERNAL) Dimensione : lunghezza
   int            _latox;
  // @cmember:(INTERNAL) Campo PICTURE
   TString      _picture;
    
public:

  // @member Legge il file .uml
  virtual void read_from(TScanner& scanner,bool intool);
  // @member Setta,apre,legge la maschera di supporto
  virtual KEY main_loop();
  // @member Duplica il controllo
  virtual TObject* dup()const { return new TEditMask_currency(*this);}//per duplicare
  // @member Costruttore
  TEditMask_currency(TEditMask_window* parent) ;
  // @member Costruttore. Copia tutte le caratteristiche del controllo
  TEditMask_currency(const TEditMask_currency& ctl);
  // @member Distruttore
  virtual ~TEditMask_currency() {}
};

//------------------------------------------------------------------------
// Classe TEditMask_date: definizione della classe per il controllo 
//                          di tipo DATE
//------------------------------------------------------------------------
class TEditMask_date: public TEditMask_string          
{  
public:

  // @member Legge il file .uml
  virtual void read_from(TScanner& scanner,bool intool);
  // @member Stampa il file .uml
  virtual void print_on(ostream& out) const;
  // @member Setta.apre,legge la maschera di supporto
  virtual KEY main_loop();
  // @member Duplica il controllo
  virtual TObject* dup()const { return new TEditMask_date(*this);}//per duplicare
  // @member Costruttore
  TEditMask_date(TEditMask_window* parent);
  // @member Costruttore. Copia tutte le caratteristiche del controllo
  TEditMask_date(const TEditMask_date& ctl);
  // @member Distruttore
  virtual ~TEditMask_date() {}
};

//------------------------------------------------------------------------
// Classe TEditMask_boolean: definizione della classe per il controllo 
//                          di tipo BOOLEAN
//------------------------------------------------------------------------
class TEditMask_boolean: public TEditMask_control    
{                 

public:            

  // @member Duplica il controllo
  virtual TObject* dup()const { return new TEditMask_boolean(*this);}//per duplicare
  // @member Legge il file .uml
  virtual void read_from(TScanner& scanner,bool intool);
  // @member Stampa il file .uml
  virtual void print_on(ostream& out) const;
  // @member Setta,apre,legge la maschera di supporto
  virtual KEY main_loop();
  // @member Fa l'update del controllo
  virtual void update()const;
  // @member Costruttore
  TEditMask_boolean(TEditMask_window* parent);
  // @member Costruttore. Copia tutte le caratteristiche del controllo
  TEditMask_boolean(const TEditMask_boolean& ctl);
  // @member Distruttore
  virtual ~TEditMask_boolean() {}
};

//------------------------------------------------------------------------
// Classe TEditMask_text: definizione della classe per il controllo 
//                          di tipo TEXT
//------------------------------------------------------------------------
class TEditMask_text: public TEditMask_string       
{  
  // @cmember:(INTERNAL) Campo FLAGS
   TString           _flag;
  // @cmember:(INTERNAL) Campo GROUP
   TString          _group;      
      
public: 

  // @member Duplica il controllo
  virtual TObject* dup()const { return new TEditMask_text(*this);}
  // @member Legge il file .uml
  virtual void read_from(TScanner& scanner,bool intool);
  // @member Stampa il file .uml
  virtual void print_on(ostream& out) const;
  // @member Setta,apre,legge la maschera di supporto
  virtual KEY main_loop();
  // @member Fa l'update del controllo
  virtual void update() const;
  // @member Costruttore
  TEditMask_text(TEditMask_window* parent);
  // @member Costruttore. Copia tutte le caratteristiche del controllo
  TEditMask_text(const TEditMask_text& ctl);
  // @member Distruttore
  virtual ~TEditMask_text() {}
};

//------------------------------------------------------------------------
// Classe TEditMask_button: definizione della classe per il controllo 
//                          di tipo BUTTON
//------------------------------------------------------------------------
class TEditMask_button: public TEditMask_control  
{  
  // @cmember:(INTERNAL) Dimensione : lunghezza
   int            _latox;
  // @cmember:(INTERNAL) Dimensione : altezza
   int            _latoy;   
   
public:
  
  // @member Duplica il controllo
  virtual TObject* dup()const { return new TEditMask_button(*this);}//per duplicare
  // @member Definisce il tipo standard del controllo
  void type_button(const TString& id,const TString& pr);
  // @member Stampa il file .uml
  virtual void print_on(ostream& out) const;
  // @member Legge il file .uml
  virtual void read_from(TScanner& scanner,bool intool);
  // @member Setta,apre,legge la maschera di supporto
  virtual KEY main_loop();
  // @member Fa l'update del controllo
  virtual void update()const;
  // @member Costruttore
  TEditMask_button(TEditMask_window* parent);
  // @member Costruttore. Copia tutte le caratteristiche del controllo
  TEditMask_button(const TEditMask_button& ctl);
  // @member Distruttore
  virtual ~TEditMask_button() {}
};

//------------------------------------------------------------------------
// Classe TEditMask_group: definizione della classe per il controllo 
//                          di tipo GROUP
//------------------------------------------------------------------------
class TEditMask_group: public TEditMask_control  
{
  // @cmember:(INTERNAL) Dimensione : lunghezza
   int            _latox;
  // @cmember:(INTERNAL) Dimensione : altezza
   int            _latoy;
   
public:            
  
  // @member Duplica il controllo
  virtual TObject* dup()const { return new TEditMask_group(*this);}
  // @member Verifica la presenza del flags "R"
  bool fl_crt()const ;
  // @member Stampa il file .uml
  virtual void print_on(ostream& out) const;
  // @member Legge il file .uml
  virtual void read_from(TScanner& scanner,bool intool);
  // @member Setta,apre,legge la maschera di supporto
  virtual KEY main_loop();
  // @member Fa l'update del controllo
  virtual void update() const;
  // @member Costruttore
  TEditMask_group(TEditMask_window* parent);
  // @member Costruttore. Copia tutte le caratteristiche del controllo
  TEditMask_group(const TEditMask_group& ctl);
  // @member Distruttore
  virtual ~TEditMask_group() {}
};

//------------------------------------------------------------------------
// Classe TEditMask_list: definizione della classe per il controllo 
//                          di tipo LIST
//------------------------------------------------------------------------
class TEditMask_list: public TEditMask_string     
{

  // @cmember:(INTERNAL) Offset
   int             _offset;
  // @cmember:(INTERNAL) Item
   TString_array     _item;
  // @cmember:(INTERNAL) Numero degli item
   int           _num_item;
  
public:       

  // @member Duplica il controllo
  virtual TObject* dup()const { return new TEditMask_list(*this);}
  // @member Legge dalla maschera di supporto il campo ITEM
  void get_item(TSheet_field& sp);
  // @member Setta sulla maschera di supporto il campo ITEM
  void set_item(TSheet_field& sp);
  // @member Stampa il campo ITEM su file .uml
  void print_item(ostream& out)const;  
  // @member Stampa il file .uml
  virtual void print_on(ostream& out) const;             
  // @member Legge il file .uml
  virtual void read_from(TScanner& scanner,bool intool);
  // @member Legge da file il campo item
  TString& read_item(TScanner& scanner,TString& tok);
  // @member Setta,apre,legge la maschera di supporto
  virtual KEY main_loop();
  // @member Fa l'update del controllo
  virtual void update() const;
  // @member Disegna parte del controllo(freccia)
  void image()const;
  // @member Ritorna il numero degli item
  int n_item()const  { return _num_item;}
  // @member Ritorna _item
  const TString_array& item()const  { return _item;}
  // @member Costruttore
  TEditMask_list(TEditMask_window* parent);
  // @member Costruttore. Copia tutte le caratteristiche del controllo
  TEditMask_list(const TEditMask_list& ctl);
  // @member Distruttore
  virtual ~TEditMask_list() {}
};

//------------------------------------------------------------------------
// Classe TEditMask_radio: definizione della classe per il controllo 
//                          di tipo RADIOBUTTON
//------------------------------------------------------------------------
class TEditMask_radio: public TEditMask_list       
{
  // @cmember:(INTERNAL) Dimensione : lunghezza
   int             _latox;                  
  // @cmember:(INTERNAL) Dimensione : altezza
   int             _latoy;
    
public:

  // @member Duplica il controllo
  virtual TObject* dup()const { return new TEditMask_radio(*this);}
  // @member Legge il file .uml
  virtual void read_from(TScanner& scanner,bool intool);
  // @member Stampa il file .uml
  virtual void print_on(ostream& out) const;
  // @member Setta,apre,legge la maschera di supporto
  virtual KEY main_loop(); 
  // @member Fa l'update del controllo
  virtual void update()const;
  // @member Costruttore
  TEditMask_radio(TEditMask_window* parent);
  // @member Costruttore. Copia tutte le caratteristiche del controllo
  TEditMask_radio(const TEditMask_radio& ctl);
  // @member Distruttore
  virtual ~TEditMask_radio() {}
};

//------------------------------------------------------------------------
// Classe TEditMask_memo: definizione della classe per il controllo 
//                          di tipo MEMO
//------------------------------------------------------------------------
class TEditMask_memo: public TEditMask_control     
{
  // @cmember:(INTERNAL) Dimensione : lunghezza
   int       _latox;
  // @cmember:(INTERNAL) Dimensione : altezza
   int       _latoy;
   
public:             
 
  // @member Duplica il controllo
  virtual TObject* dup()const { return new TEditMask_memo(*this);}//per duplicare
  // @member Legge il file .uml
  virtual void read_from(TScanner& scanner,bool intool);
  // @member Stampa il file .uml
  virtual void print_on(ostream& out)const;
  // @member Setta,apre,legge la maschera di supporto
  virtual KEY main_loop();
  // @member Fa l'update del controllo
  virtual void update()const;
  // @member Costruttore
  TEditMask_memo(TEditMask_window* parent);
  // @member Costruttore. Copia tutte le caratteristiche del controllo
  TEditMask_memo(const TEditMask_memo& ctl);
  // @member Distruttore
  virtual ~TEditMask_memo() {}
};

//------------------------------------------------------------------------
// Classe TEditMask_sheet: definizione della classe per il controllo 
//                          di tipo SPREADSHEET
//------------------------------------------------------------------------
class TEditMask_sheet: public TEditMask_control
{
  // @cmember:(INTERNAL) Dimensione : lunghezza
   int                  _latox;
  // @cmember:(INTERNAL) Dimensione : altezza
   int                  _latoy;
  // @cmember:(INTERNAL) Numero degli item
   int               _num_item;
  // @cmember:(INTERNAL) Identificativo di maschera 
   int                _idsheet;
  // @cmember:(INTERNAL) Campo ITEM
   TString_array         _item;
  // @cmember:(INTERNAL) Browse(use,input,join,output,display,copy)
   TString             _browse;
  // @cmember:(INTERNAL) "Maschera" legata allo spreadsheet
   TEditMask_window _sheetmask; 
  // @cmember:(INTERNAL) Permette di aggiungere campi alla "maschera" dello spread
   bool               _is_mask;
   
public:            
  
  // @member Ritorna la "maschera" figlio
  virtual TEditMask_window* figlio() { return &_sheetmask; }
  // @member Duplica il controllo
  virtual TObject* dup()const { return new TEditMask_sheet(*this);}
  // @member Setta l'identificativo di maschera
  void set_idsheet(int n) { _idsheet=n; }
  // @member Ritorna l'identificativo di maschera
  int  get_idsheet() { return _idsheet; }
  // @member Setta la possibilt� di aggiungere controlli alla sua "maschera"
  void set_hismask(bool b) { _is_mask=b; }
  // @member Ritorna _is_mask
  bool  get_hismask() { return _is_mask; }
  // @member Crea i buttons(conferma,annulla,elimina) per la sua maschera
  void window_sheet();
  // @member Setta sulla maschera di supporto i campi ITEM e il browse
  void set_itbr(TMask& m,TSheet_field& sp);
  // @member Legge dalla maschera di supporto i campi ITEM e browse
  void getitbr(TMask& m,TSheet_field& sp); 
  // @member Stampa su file.uml il browse(use,input,join,output,display,copy)
  void print_browse(ostream& out)const; 
  // @member Stampa su file.uml il campo ITEM 
  void print_item(ostream& out)const; 
  // @member Stampa il file .uml
  virtual void print_on(ostream& out)const;
  // @member Legge da file il campo _item
  TString& read_item(TScanner& scanner,TString& tok); 
  // @member Legge da file il campo relativo a browse
  void read_browse(TScanner& scanner,const TString& tok);
  // @member Legge il file .uml
  virtual void read_from(TScanner& scanner,bool intool);
  // @member Setta,apre,legge la maschera di supporto
  virtual KEY main_loop();
  // @member Fa l'update del controllo
  virtual void update() const;
  // @member Costruttore
  TEditMask_sheet(TEditMask_window* parent);
  // @member Costruttore. Copia tutte le caratteristiche del controllo
  TEditMask_sheet(const TEditMask_sheet& ctl);
  // @member Distruttore
  virtual ~TEditMask_sheet() {}
};

//------------------------------------------------------------------------
// Classe TEditMask_zoom: definizione della classe per il controllo 
//                          di tipo ZOOM
//------------------------------------------------------------------------
class TEditMask_zoom: public TEditMask_list     
{
  // @cmember:(INTERNAL) Dimensione : lunghezza
   int     _latox;           
  // @cmember:(INTERNAL) Offset
   int    _offset;
    
public:              
 
  // @member Duplica il controllo
  virtual TObject* dup()const { return new TEditMask_zoom(*this);}
  // @member Legge il file .uml
  virtual void read_from(TScanner& scanner,bool intool);
  // @member Stampa il file .uml
  virtual void print_on(ostream& out) const;
  // @member Setta,apre,legge la maschera di supporto
  virtual KEY main_loop();
  // @member Costruttore
  TEditMask_zoom(TEditMask_window* parent);
  // @member Costruttore. Copia tutte le caratteristiche del controllo
  TEditMask_zoom(const TEditMask_zoom& ctl);
  // @member Distruttore
  virtual ~TEditMask_zoom() {}
};


//-------------------------------------------------------------------------
//  CLASSE TEDITMASK_APPLICATION: classe per l'esecuzione dell'applicazione
//-------------------------------------------------------------------------
class TMaskEditor_application : public TApplication
{
  // @cmember:(INTERNAL) Puntatore alla finestra("maschera")corrente
   TEditMask_window *   _window;  
  // @cmember:(INTERNAL) Esistenza di una finestra
   bool                  _dirty; 
  // @cmember:(INTERNAL) Se la "maschera" � stata salvata
   bool                   _save; 

protected:
  // @cmember Richiama <Tapplication::create>
  virtual bool create();
  // @cmember Richiama <TApplication::destroy>
  virtual bool destroy();
  // @cmember Gestisce le scelte da menu
  virtual bool menu(MENU_TAG);

public:

  // @cmember Visualizza la maschera dello spreadsheet della pagina corrente
  void vision_spread();
  // @cmember Visualizza i controlli della pagina corrente
  void vision_ctrl();
  // @cmember Visualizza i controlli della maschera dello spreadsheet corrente
  void vision_sp_ctl();
  // @cmember Distrugge la "maschera"
  void destroy_window(); 
  // @cmember Crea una nuova "maschera"
  void new_mask();      
  // @cmember Apre una "maschera" gi� predefinita
  void open_mask();
  // @cmember Salva come..la "maschera" su file .uml
  void save_as_mask();
  // @cmember Risalva la "maschera" su file .uml
  void save_mask();
  // @cmember Aggiunge un controllo
  void add_control(MENU_TAG m);   
  // @cmember Copia i controlli selezionati
  void copy_crt_sel();
  // @cmember Cancella i controlli selezionati
  void erase_crt_sel();
  // @cmember Sposta in un'altra pagina i controlli selezionati
  void move_crt_sel();
  // @cmember Permette di compilare la "maschera" creata con l'applicazione
  void build();
  // @cmember Permette di eseguire la "maschera" creata con l'applicazione
  void execute();
  // @cmember Costruttore
  TMaskEditor_application() { _window = NULL; _dirty = FALSE; _save=FALSE; }
  // @cmember Distruttore
  virtual ~TMaskEditor_application() {}
};