//EDITOR DI MASCHERE: applicazione di supporto alla creazione di maschere #include #include #include #include #include #include #include #include #include #include #include #include #include //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 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 void 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 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 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 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 virtual bool create(); // @cmember Richiama 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() {} };