#ifndef __MASKFLD_H
#define __MASKFLD_H

#ifndef __DATE_H
#include <date.h>
#endif

#ifndef __REAL_H
#include <real.h>
#endif

#ifndef __SCANNER_H
#include <scanner.h>
#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

// @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 <t TField_Flags> | _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 <p scanner>
  virtual void parse_head(TScanner& scanner);
  // @cmember Legge un item del controllo dal file <p scanner>
  virtual bool parse_item(TScanner& scanner);

  // @cmember Crea il controllo (chiama <mf TMask_field::wincreate>)
  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 <p n>-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 <p CHECK_REQUIRED>
  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 <mf TMask_field::enable>)
  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 <mf TMask_field::enable>)
  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 <p s>
  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 <p key> (TRUE se appartiene)
  bool in_key(byte key) const
  { return _keys[key]; }
  // @cmember Setta il campo alla chiave <p key>
  void set_key(byte key) 
  { _keys.set(long(key)); _keys.set(0L);}
  // @cmember Rimuove il campo dalla chiave <p key>
  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 <p group> (TRUE se appartiene)
  bool in_group(byte group) const 
  { return _groups[group]; }
  // @cmember Assegna il campo al grupo <p group>
  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 <mf TMask::send_key>)
  void send_key(KEY k, short to);

  // set focus, message-box, set focus  
  // @cmember Crea una message-box relativo al campo (chiama <f message_box>)
  bool message_box(const char* fmt, ...) const;
  // @cmember Crea una warning-box relativo al campo (chiama <f warning_box>)
  bool warning_box(const char* fmt, ...) const;
  // @cmember Crea una error-box relativo al campo (chiama <f error_box>)
  bool error_box(const char* fmt, ...) const;
  // @cmember Crea una yesno-box relativo al campo (chiama <f yesno_box>)
  bool yesno_box(const char* fmt, ...) const;
  // @cmember Crea una yesnocancel-box relativo al campo (chiama <f yesnocancel_box>)
  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 <e TMaskmode.MODE_QUERY>
  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 <p scanner>
  virtual void parse_head(TScanner& scanner);
  // @cmember Legge un item del controllo dal file <p scanner>
  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 <mf TMask_field::picture_data>)
  virtual const char* picture_data(const char* data, bool video) const;
  // @cmember Permette di rendere visibile/invisibile un campo (vedi <mf TMask_field::show>)
  virtual void show(bool on = TRUE);
  // @cmember Abilita/disabilita il campo (lo rende scrivibile) (vedi <mf TMask_field::enable>)
  virtual void enable(bool on = TRUE);
  // @cmember Ritorna il tipo di check assegnato al campo (vedi <t Checktype>)
  virtual CheckType check_type() const
  { return _check; }
  // @cmember Setta il tipo di check da assegnare al campo (vedi <t Checktype>)
  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 <p data> 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 <p n>-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 <p _insert>
  const TString& get_insert() const
  { return _insert;}
  // @cmember Ritorna il valore di <p _filter>
  const TString& get_filter() const
  { return _filter;}

  // @cmember Ritorna il primo valore di <p _fld>
  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 <p _head>
  const TToken_string& head() const
  { return _head;}
  // @cmember Ritorna il valore di <p _items>
  const TToken_string& items() const
  { return _items;}
  // @cmember Ritorna il valore di <p _cursor>
  TCursor* cursor() const
  { return _cursor;}
  // @cmember Ritorna il valore di <p _checked>
  bool checked() const
  { return _checked;}
  // @cmember Ritorna il valore di <p _secondary>
  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 <p id>
  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 <p _sheet>
  TArray_sheet* sheet()
  { return _sheet; }
  // @cmember Ritorna il prim valore della variabile <p _fld>
  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 <p scanner>
  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 <mf TMask_field::picture_data>)
  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 <p scanner>
  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 <p scanner>
  virtual bool parse_item(TScanner& scanner);
  // @cmember Abilita/Disabilita il campo (vedi <mf TMask_field::enable>)
  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 <p scanner>
  virtual void parse_head(TScanner& scanner);
  // @cmember Legge un item del controllo dal file <p scanner>
  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 <p code>
  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 <mf TMask_field::enable>)
  virtual void enable(bool on);
  // @cmember Permette di mostrare/nascondere il radio button (vedi <mf TMask_field::show>)
  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 <p checked> 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 <p scanner>
  void parse_head(TScanner& scanner);
  // @cmember Legge un item del controllo dal file <p scanner>
  bool parse_item(TScanner& scanner);
  // @cmember Permette di abilitare/disabilitare il bottone (vedi <mf TMask_field::enable>)
  virtual void enable(bool);
  // @cmember Permette di mostrare/nascondere il bottone (vedi <mf TMask_field::show>)
  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 <p scanner>
  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 <p scanner>
  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 <mf TMask_field::enable>)
  virtual void enable(bool on);
  // @cmember Permette di mostrare/nascondere il campo (vedi <mf TMask_field::show>)
  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 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 <c TMask_field>.
// <nl>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 <mf TString::ltrim> e 
//                      <mf TString::rtrim>)
// @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
