root/campo-sirio
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
campo-sirio/ba/ba2600.h
guy 88f63a260c Patch level : 10.0 
Files correlati     : ba1 ba2 ba3
Ricompilazione Demo : [ ]
Commento            :
Aggiornato uso TWindow::handler


git-svn-id: svn://10.65.10.50/trunk@19486 c028cbd2-c16b-5b4b-a496-9718f37d4682
2009-10-21 13:43:17 +00:00

889 lines
36 KiB
C++
Executable File
Raw Blame History

//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() {}
};
Reference in New Issue View Git Blame Copy Permalink