#ifndef __MASKFLD_H #define __MASKFLD_H #ifndef __DATE_H #include #endif #ifndef __REAL_H #include #endif #ifndef __SCANNER_H #include #endif class TMask_field; class TRelation; // __RELATION_H class TCursor; class TFieldref; class TArray_sheet; // __SHEET_H // @doc EXTERNAL // @type CONTROL_HANDLER | Funzione per gestire i tasti speciali all'interno di un controllo typedef bool (*CONTROL_HANDLER)(TMask_field& field, KEY key); // @enum Tipo di check da eseguire su un controllo enum CheckType { CHECK_NONE, // @emem Nessun controllo CHECK_NORMAL, // @emem Controllo normale (non e' un campo obbligatorio) CHECK_REQUIRED, // @emem Controlla se il campo non e' vuoto e fa un check normale CHECK_SEARCH // @emem Controlla se il campo c'e' ma non da' nessuna segnalazione se e' errato }; // @enum Momento di richiesta del check enum CheckTime { RUNNING_CHECK, // @emem Check chiamato mentra la maschera sta andando STARTING_CHECK, // @emem Check chiamato al caricamento della maschera FINAL_CHECK }; // @emem Check chiamato quando la maschera si sta fermando // @class TMask_field | Classe per la definizione delle operazioni sui campi di // una maschera // // @base public | TObject class TMask_field : public TObject // @author:(INTERNAL)Guido { // @cfriend TMask friend class TMask; // @access Private Member // @cmember Maschera all'interno del quale e' contenuto il campo TMask* _mask; // @cmember Messaggio di help del campo TString _help; // @cmember Campo corrispondente sul file TFieldref* _field; // @cmember Chiave al quale appartiene il campo TBit_array _keys; // @cmember Gruppo al quale appartiene il campo TBit_array _groups; // @cmember Stringa definibile dall'utilizzatore della classe da utilizzare a piacimento TToken_string _userdata; // @access Protected Member protected: // @cmember Coordinata x del controllo (in caratteri) static int _x; // @cmember Coordinata y del controllo (in caratteri) static int _y; // @cmember Dimensione del controllo (in caratteri) static int _width; // @cmember Prompt del controllo static TString80 _prompt; // @cmember Handler del controllo CONTROL_HANDLER _handler; // @cmember Massima lunghezza del campo int _size; // @cmember Finestra del controllo (not its parent!) WINDOW _win; // @cmember Finestra del prompt del controllo WINDOW _promptwin; // @cmember Identificatore del controllo short _dlg; // @cmember Identificatore della funzione di validazione int _validate_func; // @cmember Parametri da passara alla funzione di validazione TArray _validate_parms; // @cmember Warning da segnalare in caso di dato errato del campo TString _warning; // @cmember Massaggi da mandare in caso di modifica del controllo TArray _message; // @cmember | _flags | | Flag indicante lo stato del campo struct TField_Flags { bool automagic : 1; bool dirty : 2; // Modified during run ? bool enabled : 1; // Is editable bool enable_default : 1; bool firm : 1; // Is the current firm ? bool focusdirty : 1; // Modified during focus ? bool ghost : 1; bool password : 1; bool persistent : 1; bool rightjust : 1; bool roman : 1; // Is a Roman number ? bool shown : 1; // Is visible bool show_default : 1; bool trim : 1; // Trim the string bool uppercase : 1; bool exchange : 1; // Value exchange bool zerofilled : 1; bool pipeallowed : 1; TField_Flags(); char update(const char*); } _flags; // @cmember Costruisce il campo da file void construct(TScanner& scanner, WINDOW parent); // @cmember Costruisce il campo con i suoi parametri void construct(short id, const char* prompt, int x, int y, int len, WINDOW parent, const char* flags = "", int width = 0); // @cmember Ritorna la finestra di appartenenza del campo virtual WINDOW win() const { return _win; } // @cmember Crea la finestra del controllo WINDOW wincreate(WIN_TYPE ct, short dx, short dy, const char* title, WINDOW parent, long flags); // @cmember Crea il prompt del controllo int create_prompt(WINDOW parent, int width = 0, int heigth = 1); // @cmember Ritorna i flags nativi di default del campo long default_flags() const; // @cmember Legge la testata del controllo dal file

virtual void parse_head(TScanner& scanner); // @cmember Legge un item del controllo dal file

virtual bool parse_item(TScanner& scanner); // @cmember Crea il controllo (chiama ) virtual void create(WINDOW parent); // @cmember Distrugge il contrllo virtual void destroy(); // @cmember Setta il focus sul campo virtual void highlight() const; // @cmember Setta il colore dello sfondo virtual void set_back_color(COLOR c) const; // @cmember Legge il valore del campo direttamente dalla finestra del controllo virtual const char* get_window_data() const; // @cmember Scrive il valore del campo direttamente dalla finestra del controllo virtual void set_window_data(const char* data); // @cmember Scrive il valore del campo virtual void set_field_data(const char* data); // @cmember Legge il valore del campo virtual const char* get_field_data() const; // @cmember Permette di settare il valore del cambio del campo virtual void exchange(bool show_value, const real& n) {} // @cmember Esegue il messaggio

-esimo sul campo bool do_message(int n); // @access Public Member public: // @cmember Converte una stringa in un identificatore del controllo short atodlg(const char* s) const; // @cmember Ritorna la finestra padre WINDOW parent() const; // @cmember Ritorna l'identificatore del controllo short dlg() const { return _dlg; } // @cmember Controlla se si tratta di un controllo corretto virtual bool ok() const; // @cmember Ritorna TRUE se il campo e' stato modificato bool dirty() const { return _flags.dirty; } // @cmember Ritorna TRUE se il campo e' stato modificato dall'ultima volta che ha ricevuto il focus bool focusdirty() const { return _flags.focusdirty; } // @cmember Setta lo stato di focusdirty del campo void set_focusdirty(bool d = TRUE) { _flags.focusdirty = d; } // @cmember Setta lo stato di dirty del campo void set_dirty(bool d = TRUE); // @cmember abilita il trim degli spazi void set_trim(bool t) { _flags.trim = t; } // @cmember Setta la giustificazione a destra del campo void set_justify(bool r) { _flags.rightjust = r; } // @cmember Verifica la giustificazione a destra del campo bool right_justified() const { return _flags.rightjust; } // @cmember Verifica la allowance of the pipe bool pipe_allowed() const { return _flags.pipeallowed; } // @cmember Allowa la pippa void allow_pipe(bool r = TRUE) { _flags.pipeallowed = r; } // @cmember Ritorna il nome della classe virtual const char* class_name() const; // @cmember Ritorna l'identificatore della classe virtual word class_id() const; // @cmember Ritorna la massima lunghezza della stringa int size() const { return _size; } // @cmember Ritorna TRUE se il campo e' un numero romano bool roman() const { return _flags.roman; } // @cmember Ritorna TRUE se il campo e' automagic bool automagic() const { return _flags.automagic; } // @cmember Ritorna TRUE se si tratta di campo fantasma bool ghost() const { return _flags.ghost; } // @cmember Ritorna TRUE se si tratta di campo in valuta bool exchangeable() const { return _flags.exchange; } // @cmember Controlla se il campo ha un check virtual bool has_check() const { return FALSE;} // @cmember Controlla se il campo ha una richiesta virtual bool has_query() const { return FALSE;} // @cmember Controlla se il campo ha un messaggio virtual bool has_message() const { return _message.items() > 0; } // @cmember Ritorna lo stato di checktype del campo virtual CheckType check_type() const { return CHECK_NONE; } // @cmember Ritorna TRUE se il checktype del campo e

bool required() const { return check_type() == CHECK_REQUIRED; } // @cmember Controlla la validita' del campo virtual bool check(CheckTime = RUNNING_CHECK) { return TRUE;} // @cmember Azzera il contenuto del campo virtual void reset(); // @cmember Abilita/disabilita il campo (lo rende scrivibile) virtual void enable(bool on = TRUE); // @cmember Abilita/disabilita il campo (chiama ) void disable() { enable(FALSE); } // @cmember Controlla se un campo e' abilitato virtual bool enabled() const { return _flags.enabled; } // @cmember Rimette lo stato di dis/abilitazione del campo a seconda di come era settato sul file void enable_default(); // @cmember Controlla se il campo e abilitato di default bool enabled_default() const { return _flags.enable_default; } // @cmember Permette di rendere visibile/invisibile un campo virtual void show(bool on = TRUE); // @cmember Permette di rendere invisibile un campo (chiama ) void hide() { show(FALSE); } // @cmember Ritorna TRUE se il campo e' visibile bool shown() const { return _flags.shown; } // @cmember Rimette lo stato di in/visibilta' del campo a seconda di come era // settato sul file void show_default(); // @cmember Ritorna TRUE se il campo e' sia visibile che abilitato bool active() const; // @cmember Setta l'handler del controllo void set_handler(CONTROL_HANDLER handler) { _handler = handler; } // @cmember Ritorna TRUE se il campo e' di tipo edit virtual bool is_edit() const { return FALSE; } // @cmember Permette di spedire il check bool to_check(KEY k, bool checkrun = FALSE) const; // @cmember Gestisce la chiamata all'handler del campo virtual bool on_hit(); // @cmember Gestisce la pressione del tasto (TRUE se la gestione ha avuto successo) virtual bool on_key(KEY key); // @cmember Serve per eseguire gli handler autoprementi (TRUE se il focus e' cambiato) virtual bool test_focus_change(); // @cmember Setta il contenuto del campo inserendo la stringa

void set(const char* s); // @cmember Ritorna il contenuto del campo TString& get() const; // @cmember Ritorna il valore di _userdata TToken_string& custom_data() { return _userdata; }; // @cmember Permette di dare la stessa formattazione del campo della maschera virtual const char* picture_data(const char* data, bool video) const; // @cmember Ritorna il warning del campo virtual const char* warning() const { return _warning;} // @cmember Legge dalla relazione il valore del campo virtual bool autoload(const TRelation* r = NULL); // @cmember Scrive sulla relazione il valore del campo virtual bool autosave(TRelation* r = NULL) const; // @cmember Riporta il valore iniziale del campo (annulla le modifiche) void undo(); // @cmember Ritorna uil prompt del cmpo const char* prompt() const; // @cmember Setta il prompt del campo void set_prompt(const char* p); // @cmember Controlla se il campo appartiene alla chiave

(TRUE se appartiene) bool in_key(byte key) const { return _keys[key]; } // @cmember Setta il campo alla chiave

void set_key(byte key) { _keys.set(long(key)); _keys.set(0L);} // @cmember Rimuove il campo dalla chiave

void reset_key(byte key); // @cmember Ritorna l'ultima chiave di appartenenza del campo word last_key() const; // @cmember Controlla se il campo appartiene al gurppo

(TRUE se appartiene) bool in_group(byte group) const { return _groups[group]; } // @cmember Assegna il campo al grupo

void set_group(byte group) { _groups.set(long(group)); _groups.set(0L);} // @cmember Ritorna il nome del campo corrsipondente sul file const TFieldref* field() const { return _field; } // @cmember Setta il nome del campo corrsipondente sul file void set_field(const TString& fr); // @cmember Setta il focus sul campo void set_focus() const; // @cmember Manda al campo l'identificatore di un tasto (chiama ) void send_key(KEY k, short to); // set focus, message-box, set focus // @cmember Crea una message-box relativo al campo (chiama ) bool message_box(const char* fmt, ...) const; // @cmember Crea una warning-box relativo al campo (chiama ) bool warning_box(const char* fmt, ...) const; // @cmember Crea una error-box relativo al campo (chiama ) bool error_box(const char* fmt, ...) const; // @cmember Crea una yesno-box relativo al campo (chiama ) bool yesno_box(const char* fmt, ...) const; // @cmember Crea una yesnocancel-box relativo al campo (chiama ) KEY yesnocancel_box(const char* fmt, ...) const; // @cmember Ritorna un reference alla maschera di appartenenza del campo TMask& mask() const { return *_mask; } // @cmember Costruttore TMask_field(TMask* mask); // @cmember Distruttore virtual ~TMask_field(); }; // @class TEdit_field | Classe per la definizione dei campi editabili // // @base public | TMask_field class TEdit_field : public TMask_field { // @cfriend TBrowse friend class TBrowse; // @cfriend TList_sheet friend class TList_sheet; // @cfriend TBrowse_sheet friend class TBrowse_sheet; // @access Protected Member protected: // @cmember Valore del campo TString _str; // @cmember Formato che deve avere il campo TString _picture; // @cmember Accettabilita' di valori nulli CheckType _check; // @cmember Controllo da effettuare anche in bool _forced; // @cmember Controllo abilitato bool _check_enabled; // @cmember Oggetto che contiene la ricerca e il controllo del campo TBrowse* _browse; // @cmember Oggetto che contiene la ricerca e il controllo del campo TList_sheet* _sheet; // @cmember Finestra del bottone di ricerca del campo WINDOW _buttonwin; // @cmember Ritorna la browse const TBrowse* get_browse(TScanner& scanner) const; // @cmember Ritorna l'identificatore della classe virtual word class_id() const; // @cmember Legge la testata del controllo dal file

virtual void parse_head(TScanner& scanner); // @cmember Legge un item del controllo dal file

virtual bool parse_item(TScanner& scanner); // @cmember Setta il colore dello sfondo virtual void set_back_color(COLOR c) const; virtual bool is_edit() const { return TRUE; } // @cmember Crea il controllo virtual void create(WINDOW parent); // @cmember Distrugge il contrllo virtual void destroy(); // @cmember Chiama l' eventuale funzione di validazione bool validate(KEY k); // @cmember Scrive il valore del campo direttamente dalla finestra del controllo virtual void set_window_data(const char* data); // @cmember Scrive il valore del campo virtual void set_field_data(const char* data); // @cmember Legge il valore del campo virtual const char* get_field_data() const; // @cmember Mostra un messaggio di errore di default per il campo bool default_error_box() const; // @access Public Member public: // @cmember Gestisce la chiamata all'handler del campo virtual bool on_hit(); // @cmember Gestisce la pressione del tasto (TRUE se la gestione ha avuto successo) virtual bool on_key(KEY key); // @cmember Controlla se il campo ha un check virtual bool has_check() const; // @cmember Controlla se il campo ha una ricerca virtual bool has_query() const { return _browse || _sheet;} // @cmember Permette di dare la stessa formattazione del campo della maschera // (vedi ) virtual const char* picture_data(const char* data, bool video) const; // @cmember Permette di rendere visibile/invisibile un campo (vedi ) virtual void show(bool on = TRUE); // @cmember Abilita/disabilita il campo (lo rende scrivibile) (vedi ) virtual void enable(bool on = TRUE); // @cmember Ritorna il tipo di check assegnato al campo (vedi ) virtual CheckType check_type() const { return _check; } // @cmember Setta il tipo di check da assegnare al campo (vedi ) void check_type(CheckType c) { _check = c; } // @cmember Controlla se un campo e' forced bool forced() const { return _forced;} // @cmember Esegue il controllo virtual bool check(CheckTime = RUNNING_CHECK); // @cmember Ritorna l'oggetto _browse TBrowse* browse() const { return _browse;} // @cmember Ritorna l'oggetto _sheet TList_sheet* sheet() const { return _sheet;} // @cmember Permette di abilitare/disabilitare un check di un campo void enable_check(bool on = TRUE) ; // @cmember Controlla se un campo ha abilitato o disabilitato i check (TRUE se abilitato) bool check_enabled() const { return _check_enabled;} // @cmember Ritorna

formattato secondo i flags settati del campo const char* format(const char* data) const; // @cmember Ritorna la picture del campo const char* picture() const { return _picture; } // @cmember Costruttore TEdit_field(TMask* mask); // @cmember Distruttore virtual ~TEdit_field(); }; /////////////////////////////////////////////////////////// // TBrowse /////////////////////////////////////////////////////////// // @class TBrowse | Classe per la definizione dei campi con ricerca class TBrowse { // @access Private Member // @cmember Campo che possiode lo sheet TEdit_field* _fld; // @cmember Relazione della ricerca TRelation* _relation; // @cmember Cursore sulla relazione TCursor* _cursor; // @cmember Comando da eseguire alla pressione del tasto Gestione TString _insert; // @cmember Filtro sul cursore TString _filter; // @cmember Record selezionato long _rec; // @cmember Indica se e' presente un campo secondario nella ricerca bool _secondary; // @cmember Indica se sul campo e' gia' stao effettuato il check bool _checked; // @cmember Testata della maschera di ricerca TToken_string _head; // @cmember Item della maschera di ricerca TToken_string _items; // @cmember Campi di input sulla maschera TToken_string _inp_id; // @cmember Campi di input sul file TToken_string _inp_fn; // @cmember Campi di output sulla maschera TToken_string _out_id; // @cmember Campi di output sul file TToken_string _out_fn; // @access Protected Member protected: // @cmember Scrive l'output della ricerca sulla maschera void do_output(CheckTime = RUNNING_CHECK); // @cmember Azzera i campi di output sulla maschera void do_clear(); // @cmember Chiama la maschera di gestione della ricerca bool do_insert(); // @cmember Ritorna il campo

-esimo TMask_field& field(short n) const; // @cmember !!!!!!piu' d'uno TToken_string& create_siblings(TToken_string& siblings); // @access Public Member public: // @cmember Ritorna il numero di inputs senza contare quelli che funzionano // solo da filtro int inputs(); // @cmember Ritorna il numero di campi non vuoti e non filtrati int do_input(bool filter = FALSE); // @cmember Costruttore TBrowse(TEdit_field* f, TRelation* r, int key = 1, const char* filter = ""); // @cmember Costruttore TBrowse(TEdit_field* f, TCursor* c); // @cmember Distruttore ~TBrowse(); // @cmember Controlla la sintassi della join del campo e ne setta i membri void parse_join(TScanner& scanner); // @cmember Controlla la sintassi della input del campo e ne setta i membri void parse_input(TScanner& scanner); // @cmember Controlla la sintassi della display del campo e ne setta i membri void parse_display(TScanner& scanner); // @cmember Controlla la sintassi della output del campo e ne setta i membri void parse_output(TScanner& scanner); // @cmember Controlla la sintassi della insert del campo e ne setta i membri void parse_insert(TScanner& scanner); // @cmember Controlla la sintassi della copy del campo e ne setta i membri bool parse_copy(const TString& what, const TBrowse& b); // @cmember Permette di settare il comando alla pressione del tasto Gestione void set_insert(const char* s) { _insert = s;} // @cmember Ritorna il valore di

const TString& get_insert() const { return _insert;} // @cmember Ritorna il valore di

const TString& get_filter() const { return _filter;} // @cmember Ritorna il primo valore di

TEdit_field& field() const { return *_fld; } // @cmember Controlla la validita' del campo bool check(CheckTime = RUNNING_CHECK); // @cmember Controlla se il campo puo' essere vuoto bool empty_check(); // @cmember Ritorna il valore di

const TToken_string& head() const { return _head;} // @cmember Ritorna il valore di

const TToken_string& items() const { return _items;} // @cmember Ritorna il valore di

TCursor* cursor() const { return _cursor;} // @cmember Ritorna il valore di

bool checked() const { return _checked;} // @cmember Ritorna il valore di

bool secondary() const { return _secondary;} // @cmember Esegue la ricerca. Torna il tasto che ha terminato la ricerca KEY run(); }; /////////////////////////////////////////////////////////// // TList_sheet /////////////////////////////////////////////////////////// // @class TList_sheet | Classe per la gestione dei list sheet class TList_sheet { // @access Private Memeber // @cmember Campo che possiede lo sheet TEdit_field* _fld; // @cmember Sheet con i dati TArray_sheet* _sheet; // @cmember Numero di righe dello sheet int _row; // @cmember Campi di input sulla maschera TToken_string _inp_id; // @cmember Campi di output sulla maschera TToken_string _out_id; // @access Protected Member protected: // @cmember Ritorna il numero di riga selezionata int do_input(); // @cmember Scrive l'output della ricerca sulla maschera void do_output(CheckTime = RUNNING_CHECK); // @cmember Chiamata dal tasto Gestione. Non essendo presente nei list_sheet non fa niente bool do_insert(); // @cmember Ritorna il campo

TMask_field& field(short id) const; // @access Public Memeber public: // @cmember Costruttore TList_sheet(TEdit_field* f, const char* caption, const char* head); // @cmember Distruttore ~TList_sheet(); // @cmember Controlla la sintassi della input del campo e ne setta i membri void parse_input(TScanner& scanner); // @cmember Legge dal file gli item dello sheet void read_item(TScanner& scanner); // @cmember Controlla la sintassi della output del campo e ne setta i membri void parse_output(TScanner& scanner); // @cmember Ritorna il valore della variabile

TArray_sheet* sheet() { return _sheet; } // @cmember Ritorna il prim valore della variabile

TEdit_field& field() const { return *_fld; } // @cmember Controlla la validita' del campo bool check(CheckTime = RUNNING_CHECK); // @cmember Esegue la ricerca. Torna il tasto che ha terminato la ricerca KEY run(); }; //@class TReal_field | Classe per la gestione dei campi di numeri reali // // @base public | TEdit_field class TReal_field : public TEdit_field { // @access Private Member // @cmember Numero di decimeali del campo int _decimals; // @access Protected Member protected: // @cmember Ritorna l'identificatore della calsse virtual word class_id() const; // @cmember Legge il valore del campo direttamente dalla finestra del controllo virtual const char* get_window_data() const; // @cmember Scrive il valore del campo direttamente dalla finestra del controllo virtual void set_window_data(const char* data); // @cmember Setta il valore del cambio nel campo virtual void exchange(bool show_value, const real& n); virtual const char* picture_data(const char* data, bool video) const; // @cmember Crea il controllo virtual void create(WINDOW parent); // @cmember Legge un item del controllo dal file

virtual void parse_head(TScanner& scanner); // @cmember Gestisce la pressione del tasto (TRUE se la gestione ha avuto successo) virtual bool on_key(KEY key); // @cmember Legge dalla relazione il valore del campo virtual bool autoload(const TRelation* r); // @access Public Member public: // @cmember Setta la precisione (numero di decimali) del reale e la sua picture void set_decimals(int d); // @cmember Ritorna la precisione del reale (numero di decimali) int decimals() const { return _decimals; } // @cmember Costruttore TReal_field(TMask* mask); }; //@class TDate_field | Classe per la gestione dei campi data // // @base public | TEdit_field class TDate_field : public TEdit_field { // @access Protected Member protected: // @cmember Permette di formattare la data secondo i flag correnti const char* format_data(const char* data, bool* changed=NULL) const; // @cmember Ritorna l'identificatore della classe virtual word class_id() const; // @cmember Crea il controllo virtual void create(WINDOW parent); // @cmember Gestisce la pressione del tasto (TRUE se la gestione ha avuto successo) virtual bool on_key(KEY key); // @cmember Permette di dare la stessa formattazione del campo della maschera // (vedi ) virtual const char* picture_data(const char* data, bool video) const; // @cmember Legge il valore del campo direttamente dalla finestra del controllo virtual const char* get_window_data() const; // @cmember Scrive il valore del campo direttamente dalla finestra del controllo virtual void set_window_data(const char* data); // @cmember Scrive sulla relazione il valore del campo gestendo formato ANSI virtual bool autosave(TRelation* r = NULL) const; // @access Public Member public: // @cmember Legge un item del controllo dal file

void parse_head(TScanner& scanner); // @cmember Costruttore TDate_field(TMask* mask); }; // @class TBoolean_field | Classe per la gestione dei campi boolean (check box) // // @base public | TMask_field class TBoolean_field : public TMask_field { // @access Protected Member protected: // @cmember Indica se il campo e' selezionato o no bool _on; // @cmember Ritorna l'identificatore della classe virtual word class_id() const; // @cmember Crea il controllo virtual void create(WINDOW parent); // @cmember Legge il valore del campo direttamente dalla finestra del controllo virtual const char* get_window_data() const; // @cmember Scrive il valore del campo direttamente dalla finestra del controllo virtual void set_window_data(const char* data); // @cmember Scrive il valore del campo virtual void set_field_data(const char* data = NULL); // @cmember Legge il valore del campo virtual const char* get_field_data() const; // @cmember Legge un item del controllo dal file

virtual bool parse_item(TScanner& scanner); // @cmember Abilita/Disabilita il campo (vedi ) virtual void enable(bool on); // @cmember Setta il colore dello sfondo virtual void set_back_color(COLOR c) const; // @cmember Gestisce la chiamata all'handler del campo virtual bool on_hit(); // @cmember Gestisce la pressione del tasto (TRUE se la gestione ha avuto successo) virtual bool on_key(KEY key); // @access Public Members public: // @cmember Costruttore TBoolean_field(TMask* mask); }; // @class TList_field | Classe per la gestione dei campi lista (list box) // // @base public | TMask_field class TList_field : public TMask_field { // @access Private Member // @cmember Crea una lista con i mesi void add_list(); // @access Protected Member protected: // @cmember Lista delle voci TToken_string _values; // @cmember Lista dei codice delle voci TToken_string _codes; // @cmember Valore del campo TString _str; // @cmember Ritorna l'identificatore della classe virtual word class_id() const; // @cmember Scrive il valore del campo direttamente dalla finestra del controllo virtual void set_window_data(const char* data); // @cmember Legge il valore del campo direttamente dalla finestra del controllo virtual const char* get_window_data() const; // @cmember Scrive il valore del campo virtual void set_field_data(const char* data = NULL); // @cmember Legge il valore del campo virtual const char* get_field_data() const; // @cmember Crea il controllo virtual void create(WINDOW parent); // @cmember Setta la voce corrente virtual void current(int n); // @cmember Ritorna la voce corrente virtual int current() const; // @cmember Trasforma la voce nel corrsipondente valore int str2curr(const char* data); // @cmember Gestisce la chiamata all'handler del campo virtual bool on_hit(); // @cmember Gestisce la pressione del tasto (TRUE se la gestione ha avuto successo) virtual bool on_key(KEY key); // @cmember Legge dal file gli item dello sheet virtual void read_item(TScanner& scanner); // @cmember Setta il colore dello sfondo virtual void set_back_color(COLOR c) const; // @cmember Legge un item del controllo dal file

virtual void parse_head(TScanner& scanner); // @cmember Legge un item del controllo dal file

virtual bool parse_item(TScanner& scanner); // @access Public Member public: // @cmember Costruttore TList_field(TMask* mask); // @cmember Sostituisce alle voci correnti quelle passate come parametri virtual void replace_items(const char* codes, const char* values); // @cmember Aggiunge una voce virtual void add_item(const char* code_value); // @cmember Elimina la voce con codice

virtual void delete_item(const char* code); // @cmember Ritorna il numero di voci presenti int items() const; }; // @class TRadio_field | Classe per la gestione dei campi lista (list box) // // @base public | TList_field class TRadio_field : public TList_field { // @access Provate Member // @ccost MAX_RADIO | 8 | Numero massimo di opzioni di un radio button enum { MAX_RADIO = 8 }; // @cmember Numero di opzioni presenti nel radio button int _nitems; // @cmember Numero della voce attiva nel radio button int _active_item; // @cmember Finestre delle righe del radiobutton WINDOW _radio_ctl_win[MAX_RADIO]; // @access Protected Member protected: // @cmember Ritorna l'identificatore della classe virtual word class_id() const; // @cmember Crea il controllo virtual void create(WINDOW parent); // @cmember Distrugge il contrllo virtual void destroy(); // @cmember Permette di abilitare/disabilitare il radio button (vedi ) virtual void enable(bool on); // @cmember Permette di mostrare/nascondere il radio button (vedi ) virtual void show(bool on); // @cmember Setta il colore dello sfondo virtual void set_back_color(COLOR c) const; // @cmember Setta la voce corrente virtual void current(int n); // @cmember Ritorna la voce corrente virtual int current() const; // @cmember Ritorna la finestra della voce selezionata WINDOW win() const { return _radio_ctl_win[_active_item]; } // @access Public Member public: // @cmember Costruttore TRadio_field(TMask* mask); // @cmember Seleziona usando

la voce corrente void check_radiobutton(WINDOW checked); // @cmember Sposta il focus dal radio button bool move_focus(int d); }; // @class TButton_field | Classe per la gestione dei campi bottone // // @base public | TMask_field class TButton_field : public TMask_field { // @access Private Member // @cmember Valore della combinazione di tasti che sostituisce il bottone KEY _virtual_key; // @cmember Tasto generato quando viene premuto il bottone che si sta gestendo KEY _exit_key; // @access Protected Member protected: // @cmember Ritorna l'identificatore della classe virtual word class_id() const; // @cmember Crea il controllo virtual void create(WINDOW parent); // @cmember Setta il colore dello sfondo virtual void set_back_color(COLOR c) const; // @cmember Legge un item del controllo dal file

void parse_head(TScanner& scanner); // @cmember Legge un item del controllo dal file

bool parse_item(TScanner& scanner); // @cmember Permette di abilitare/disabilitare il bottone (vedi ) virtual void enable(bool); // @cmember Permette di mostrare/nascondere il bottone (vedi ) virtual void show(bool); // @cmember Gestisce la pressione del tasto (TRUE se la gestione ha avuto successo) virtual bool on_key(KEY key); public: // @cmember Costruttore TButton_field(TMask* mask); // @cmember Ritorna il valore della combinazione di tasti che sostiutiscono il bottone KEY virtual_key() const { return _virtual_key; } // @cmember Ritorna il valore del tasto di uscita KEY exit_key() const { return _exit_key; } }; // @class TGroup_field | Classe per la gestione del disegno dei group box // // @base public | TMask_field class TGroup_field : public TMask_field { // @access Protected Member protected: // @cmember Legge un item del controllo dal file

virtual void parse_head(TScanner& scanner); // @cmember Crea il controllo virtual void create(WINDOW parent); // @cmember Scrive il valore del campo direttamente dalla finestra del controllo virtual void set_window_data(const char* data); // @cmember Scrive il valore del campo virtual void set_field_data(const char* data); // @cmember Setta il colore dello sfondo virtual void set_back_color(COLOR c) const; // @access Public Member public: // @cmember Costruttore TGroup_field(TMask* mask); }; // @class TMemo_field | Classe per la gestione dei campi memo // // @base public | TMask_field class TMemo_field : public TMask_field { // @access Private Member // @cmember Oggetto text che contiene il valore del campo memo TXEDIT _te; TToken_string _data; // @access Protected Member protected: // @cmember Ritorna l'identificatore della classe virtual word class_id() const { return CLASS_MEMO_FIELD; } // @cmember Ritorna il nome della classe virtual const char* class_name() const { return "MEMO"; } // @cmember Crea il controllo virtual void create(WINDOW parent); // @cmember Legge un item del controllo dal file

virtual void parse_head(TScanner& scanner); // @cmember Setta il focus sul campo virtual void highlight() const; // @cmember Scrive il valore del campo direttamente dalla finestra del controllo virtual void set_window_data(const char* data); // @cmember Legge il valore del campo direttamente dalla finestra del controllo virtual const char* get_window_data() const; // @cmember Scrive il valore del campo virtual void set_field_data(const char* data = NULL); // @cmember Legge il valore del campo virtual const char* get_field_data() const; // @cmember Permette di abilitare/disabilitare il campo (vedi ) virtual void enable(bool on); // @cmember Permette di mostrare/nascondere il campo (vedi ) virtual void show(bool on); // @cmember Gestisce la pressione del tasto (TRUE se la gestione ha avuto successo) virtual bool on_key(KEY k); // @access Public Member public: // @cmember Costruttore TMemo_field(TMask* mask); // @cmember Distruttore virtual ~TMemo_field(); }; // @class TZoom_field | Come edit filed ma zooma per l'editing dei campi memo // // @base public | TEdit_field class TZoom_field : public TEdit_field { // @access Private Member TToken_string _memo; // @cmember Finestra del bottone per lo zoom del campo WINDOW _buttonzoom; // @access Protected Member protected: // @cmember Ritorna l'identificatore della classe virtual word class_id() const { return CLASS_ZOOM_FIELD; }; // @cmember Ritorna il nome della classe virtual const char* class_name() const { return "ZOOM"; } // @cmember Scrive il valore del campo direttamente dalla finestra del controllo virtual void set_window_data(const char* data); // @cmember Legge il valore del campo direttamente dalla finestra del controllo virtual const char* get_window_data() const; // @cmember Scrive il valore del campo virtual void set_field_data(const char* data); // @cmember Legge il valore del campo virtual const char* get_field_data() const; void set_first_line( const char * c ); // @cmember Crea il controllo virtual void create(WINDOW parent); // @cmember Distrugge il contrllo virtual void destroy(); // @access Public Member public: // @cmember Permette di rendere visibile/invisibile un campo (vedi ) virtual void show(bool on = TRUE); // @cmember Abilita/disabilita il campo (lo rende scrivibile) (vedi ) virtual void enable(bool on = TRUE); // @cmember Gestisce la pressione del tasto (TRUE se la gestione ha avuto successo) const char * get_first_line( ); virtual bool on_key(KEY key); // @cmember Costruttore TZoom_field(TMask* mask); // @cmember Distruttore virtual ~TZoom_field(); }; #endif // __MASKFLD_H // @struct TField_Flags | ATTENZIONE: questa struttura e' deifnita nella calsse . // Serve per definire i flegs di settaggio di un campo // // @field bool | automagic | TRUE se il campo e' automagic (campi data e numero che assumono data // odierna e anno corrente nel caso non venga inserito nessun valore) // @field bool | dirty | TRUE se il campo e' stato modificato durante l' esecuzione della maschera // @field bool | enabled | TRUE se il campo e' editabile // @field bool | enable_default | TRUE se il campo e' abilitato di default // @field bool | firm | TRUE se il campo contiene la ditta corrente // @field bool | focusdirty | TRUE se il campo e' stato modificato mentre il campo aveva il focus // @field bool | ghost | TRUE se si tratta di un campo fantasma // @field bool | password | Campo password (you write but you don't see anything) // @field bool | persistent | Campo persistente (non si cancella mai) // @field bool | rightjust | TRUE se il campo deve essere giustificato a destra // @field bool | roman | TRUE se il campo e' un numero romano // @field bool | shown | TRUE se il campo e' visibile // @field bool | show_default | TRUE se il campo e' visibile di default // @field bool | trim | TRUE se occorre fare la trim su una stringa (vedi e // ) // @field bool | uppercase | TRUE se il campo e' maiuscolo // @field bool | exchange | TRUE se il campo e' in valuta // @field bool | zerofilled | TRUE se il campo // @field void | TField_Flags() | Costruttore // @field char | update(const char*) | Aggiorna i bit della struttura secondo i valori letti da file