campo-sirio/include/mask.h

#ifndef __MASK_H
#define __MASK_H

#ifndef __WINDOW_H
#include <window.h>
#endif

#ifndef __MASKFLD_H
#include <maskfld.h>
#endif

class TSheet_field;

// @doc EXTERNAL

// @type MASK_HANDLER | Prototipo funzione per gestire i tasti speciali all'interno di una maschera.
typedef bool (*MASK_HANDLER)(TMask& mask, KEY key);


// @doc EXTERNAL

// @enum Modalita' di utilizzo della maschera corrente
enum TMaskmode {
  NO_MODE,         // @emem Nessun modo
  MODE_QUERY,      // @emem Modalita' di richiesta chiave
  MODE_QUERYINS,   // @emem Modalita' di richiesta chiave e inserimento dati
  MODE_INS ,       // @emem Modalita' di inserimento dati
  MODE_MOD        // @emem Modalita' di modifca dati
};

// @doc EXTERNAL

// @class TMask | Classe per la gestione delle maschere video
//
// @base public | TWindow
class TMask : public TWindow
{
  // @author:(INTERNAL) Guido

  // @access Protected Member
  protected:

  // @ccost:(INTERNAL) MAX_PAGES | 16 | Massimo numero di pagine nella maschera
  enum { MAX_PAGES = 16 };

  // @access:(INTERNAL) Private Member
  private:

  // @cmember:(INTERNAL) Windows delle pagine
  WINDOW _pagewin[MAX_PAGES+1];

  // @cmember:(INTERNAL) Numero di pagine della maschera
  int _pages;
  // @cmember:(INTERNAL) Pagina corrente
  int _page;

  // @cmember:(INTERNAL) Controlla le pagine abilitate
  TBit_array _enabled;
  // @cmember:(INTERNAL) Modalita' di utilizzo della maschera
  int _mode;
  // @cmember:(INTERNAL) Numero di campi della maschera
  TArray _field;

  // @cmember:(INTERNAL) Primo controllo che deve ricevere il focus
  int _first_focus;

  int _focus;

  // @cmember:(INTERNAL) Puntatore allo sheet che contiene la maschera (puo' essere NULL)
  TSheet_field* _sheet;

  // @cmember:(INTERNAL) Handler per gestire i tasti speciali nelle maschere
  MASK_HANDLER _handler;

  // @cmember:(INTERNAL) Nome del file sorgente contenente la maschera
  TFilename _source_file;
  // @cmember:(INTERNAL) Nome del file di salvataggio in cui sono scaricati i valori della maschera
  TFilename _workfile;
  // @cmember:(INTERNAL) Ultimo offset letto nel file di salvataggio
  long _lastpos;

  // @cmember:(INTERNAL) Cambio attuale per i cambi in valuta
  real _exchange;
  // @cmember:(INTERNAL) Controlla se la maschera deve fare i controlli iniziali di validita' dei campi
  bool _should_check;

  int _error_severity;
  TString _error_message;
  short _msg_field;
  KEY   _msg_key;

  // @cmember:(INTERNAL) Tempo totale di caricamento della maschera
  long _total_time;
  // @cmember:(INTERNAL) Tempo di compilazione della maschera
  long _build_time;
  // @cmember:(INTERNAL) Tempo di inizializzazione della maschera
  long _init_time;

  // @cmember:(INTERNAL) identificatore del campo da testare per l'autopremimento
  short _test_fld;
  // @cmember:(INTERNAL) posizione del campo che per ultimo ha testato l'autopremimento
  int _last_test;

  // @access Protected Member
protected:
  TArray& fields_array() { return _field; }

  // @cmember:(INTERNAL) Numero di sheet contenuti nella maschera
  int _sheets;

  // @cmember Legge i controlli relativi ad un campo
  void load_checks() const;
  // @cmember Inizializza la maschera (Chiamata quando la maschera parte)
  virtual void start_run();
  // @cmember Legge il campo da file
  virtual TMask_field* parse_field(TScanner& scanner);

  // @cmember Inizializza la maschera
  void init_mask();
  // @cmember Legge la pagina da file
  WINDOW read_page(TScanner& scanner, bool toolbar = FALSE);
  // @cmember Legge la maschera da file
  void read_mask(const char* name, int num, int max);

  // @cmember Aggiunge i tags ad una pagina
  void add_tag_button(byte pag, TToken_string& tags, byte sel);

  // @cmember Aggiunge alla maschera tutti i bottoni per la navigazione tra le pagine
  void add_tag_buttons(TToken_string& tags);

  // @cmember Ritorna il numero del primo campo attivo della pagina con finestra <p w>
  int find_first_active(WINDOW w) const;
  // @cmember Ritorna il numero della finestra padre del campo <p f>
  int find_parent_page(const TMask_field& f) const;
  // @cmember Esegue i check del campo corrente
  bool check_current_field() const;
  // @cmember Mostra la prossima/precedente pagina
  void next_page(int p);
  // @cmember Ritorna il numero della pagina corrente
  int curr_page() const
  { return _page; }
  // @cmember Costruttore (crea una maschera vuota)
  TMask() { init_mask();}

  // @access Public Member
public:
  // @cmember Costruttore (crea la maschera leggendo la descrizione dal file .msk)
  TMask(const char* title, int num = 0, int max = MAX_PAGES);
  // @cmember Costruttore (crea una maschera vuota con i parametri dati)
  TMask(const char* title, int pages, int cols, int rows, int xpos = -1, int ypos = -1);

  // @cmember Distruttore
  virtual ~TMask();

  // @cmember Ritorna l'identificatore della classe maschera
  virtual word class_id() const;

  // @cmember Ritorna TRUE se la maschera deriva dalla classe <p c>
  virtual bool is_kind_of(word c) const;

  // @cmember Ritorna la finestra della pagina corrente (Usare con attenzione)
  WINDOW win() const
  { return _page < 0 ? _pagewin[0] : _pagewin[_page]; }

  // @cmember Ritorna il nome del file contentente la maschera
  const TFilename& source_file() const
  { return _source_file; }

  // @cmember Aggiunge alla maschera tutti i bottoni Pag. n
  void add_default_tag_buttons();

  // @cmember Aggiunge runtime un campo testo alla maschera
  TMask_field& add_static (short id, int page, const char* prompt, int x, int y, const char* flags = "");
  // @cmember Aggiunge runtime un campo stringa alla maschera
  TEdit_field& add_string (short id, int page, const char* prompt, int x, int y, int dim, const char* flags = "", int width = 0);

  // @cmember Aggiunge runtime un campo numerico alla maschera
  TReal_field& add_number (short id, int page, const char* prompt, int x, int y, int dim,  const char* flags = "", int ndec = 0);
  // @cmember Aggiunge runtime un campo data alla maschera
  TDate_field& add_date (short id, int page, const char* prompt, int x, int y, const char* flags = "");
  // @cmember Aggiunge runtime un campo bottone alla maschera
  TButton_field& add_button (short id, int page, const char* prompt, int x, int y, int dx = 9, int dy = 1, const char* flags = "", short bmpup = 0, short bmpdn = 0);
  // @cmember Aggiunge runtime un campo boolean alla maschera
  TBoolean_field& add_boolean (short id, int page, const char* prompt, int x, int y, const char* flags = "");
  // @cmember Aggiunge runtime un campo radio button alla maschera
  TRadio_field& add_radio(short id, int page, const char* prompt, int x, int y, int dx, const char* codes, const char* items, const char* flags = "");
  // @cmember Aggiunge runtime un campo memo alla maschera
  TMemo_field& add_memo (short id, int page, const char* prompt, int x, int y, int dx = 78, int dy = 4, const char* flags = "");
  // @cmember Aggiunge runtime un campo zoom alla maschera
  TZoom_field& add_zoom (short id, int page, const char* prompt, int x, int y, int dim, const char* flags = "", int width = 0);
  // @cmember Aggiunge runtime un campo lista alla maschera
  TList_field& add_list (short id, int page, const char* prompt, int x, int y, int dim, const char* flags = "", const char* codes = NULL, const char* items = NULL);

  // @cmember Ritorna il numero di campi della maschera
  int fields() const
  { return _field.items(); }
  // @cmember Ritorna il numero di sheet della maschera
  int sheets() const
  { return _sheets; }

  // @cmember Setta la modalita' di utilizzo della maschera
  void set_mode(int m)
  { _mode = m; }
  // @cmember Ritorna la modalita' corrente di utilizzo della maschera
  int mode() const
  { return _mode; }

  // @cmember Setta la chiave da testare per l'autopremimento
  void set_test_field(int id)
  { if (_test_fld < 0) _test_fld = id; }

  void set_focus_field(short id);
  void notify_focus_field(short id);

  // @cmember Setta il valore attuale della valuta
  void set_exchange(bool show_value, const real& nuo);
  // @cmember Ritorna il valore attuale del cambio
  const real& exchange() const
  { return _exchange; }

  // @cmember Controlla i campi di una maschera (TRUE se tutti validi)
  bool check_fields();
  // @cmember Esegue il check e i messaggi sul campo <p fld_id> della maschera
  virtual void check_field( short fld_id );
  // @cmember Forza la chiusura della maschera
  virtual bool stop_run(KEY key);
  // @cmember Controlla se la maschera puo' essere chiusa (TRUE se puo' esserlo)
  virtual bool can_be_closed() const;

  // @cmember Permette di aprire una maschera
  virtual void open();
  // @cmember Permette di chiudere una maschera
  virtual void close();
  // @cmember Permette di attivare/disattivare tutta la pagina
  virtual void activate(bool on = TRUE);

  // @cmember Converte un identificatore di campo nella sua posizione
  int id2pos(short id) const;
  // @cmember Ritorna il campo i-esimo della maschera
  TMask_field& fld(int i) const
  { return (TMask_field&)_field[i]; }
  // @cmember Ritorna il campo contraddistinto dall'identificatore passato
  TMask_field& field(short id) const;
  // @cmember Ritorna il campo di edit contraddistinto dall'identificatore passato
  TEdit_field& efield(short id) const;

  // @cmember Setta il campo con una stringa
  virtual void set(short fld_id, const char* str, bool hit=FALSE);
  // @cmember Setta il campo con un reale
  void set(short fld_id, const real& num, bool hit=FALSE);
  // @cmember Setta il campo con una data
  void set(short fld_id, const TDate& day, bool hit=FALSE);
  // @cmember Setta il campo con un valore
  void set(short fld_id, long num, bool hit=FALSE);
  // @cmember Ritorna il contenuto del campo <p fld_id> sotto forma di stringa
  virtual const TString& get(short fld_id) const;
  // @cmember Ritorna il contenuto del campo <p fld_id> sotto forma di long
  long get_long(short fld_id) const;
  // @cmember Ritorna il contenuto del campo <p fld_id> sotto forma di int
  //              (chiama <mf TMask::get_long>)
  int get_int(short fld_id) const
  { return (int)get_long(fld_id); }
  // @cmember Ritorna il contenuto del campo <p fld_id> sotto forma di bool
  bool get_bool(short fld_id) const;
  // @cmember Ritorna il contenuto del campo <p fld_id> sotto forma di real
  real get_real(short fld_id) const;
  // @cmember Ritorna il contenuto del campo <p fld_id> sotto forma di data
  TDate get_date(short fld_id) const;

  // @cmember Indica quale campo deve ricevere per primo il focus nella maschera
  int first_focus(short id);

  // @cmember Ritorna il numero del controllo che possiede il focus
  TOperable_field& focus_field() const;

  // @cmember Disabilita la lettura dei check della maschera
  void disable_starting_check()
  { _should_check = FALSE;}

  // @cmember Evita che venga chiamata la TWindow
  virtual void TMask::on_button(short);

  // @cmember Assegna una azione al tasto non standard
  virtual bool on_key(KEY key);
  // @cmember Aggiorna i campi con i valori salvati una volta che non ci sono processi attivi
  virtual void on_idle();
  // @cmember Aggiorna in tutti campi della maschera, che fanno riferimento ad una ditta,
  //              con il riferimento alla ditta attuale
  virtual void on_firm_change();

  // @cmember Abilita/disabilita un campo
  virtual void enable(short fld_id, bool on = TRUE);
  // @cmember Disabilita un campo (chiama <mf TMask::enable>)
  void disable(short fld_id)
  { enable(fld_id, FALSE); }
  // @cmember Riporta il cmpo allo stato di abilitazione iniziale
  void enable_default(short fld_id = 0);

  // @cmember Forza la visualizzazione della pagina p
  void show_page(int p);
  // @cmember Abilita/disabilita una pagina e tutte le successive
  void enable_page(byte p, bool on = TRUE);
  // @cmember Disabilita una pagina e tutte le successive (chiama <mf TMask::enable_page>)
  void disable_page(byte p)
  { enable_page(p, FALSE); }
  // @cmember Controlla se una pagina e' disabilitata (TRUE se disabilitata)
  bool page_enabled(byte p) const;

  // @cmember Ritorna il numero di chiavi utilizzate nei campi della maschera
  byte num_keys() const;
  // @cmember Abilita/disabilita i campi di una chiave sulla maschera
  void enable_key(byte key, bool on = TRUE);
  // @cmember Disabilita i campi di una chiave sulla maschera (chiama <mf TMask::enable_key>)
  void disable_key(byte key)
  { enable_key(key, FALSE); }
  // @cmember Ritorna il l'identificatore di un campo della chiave <p key>
  TEditable_field* get_key_field(byte key, bool first) const;
  // @cmember Controlla se la chiave <p key> ha un valore significativo
  //                              (TRUE se il valore e' valido)
  bool key_valid(int key) const;

  // @cmember Permette di mostrare/nascondere un campo (chiama <mf TMask_field::show>)
  virtual void show(short fld_id = -1, bool on = TRUE);
  // @cmember Permette di nascondere un campo (chiama <mf TMask::show>)
  void hide(short fld_id = 0)
  { show(fld_id, FALSE); }
  // @cmember Rimette lo stato di default del campo
  void show_default(short fld_id = 0);

  // @cmember Azzera il campo
  void reset(short fld_id = 0);

  // @cmember Legge, dalla relazione <p Trelation>, i valori del campo con specifica FIELD
  void autoload(const TRelation& r);
  // @cmember Scrive, dalla relazione <p Trelation>, i valori del campo con specifica FIELD
  void autosave(TRelation& r) const;

  // @cmember Permette di mandare un tasto ad un campo
  void send_key(KEY key, short id, TMask_field* from = NULL);
  // @cmember Permette di mandare un handler ad un controllo
  virtual void set_handler(short fld_id, CONTROL_HANDLER handler);
  // @cmember Permette di mandare un handler ad una maschera
  void set_handler(MASK_HANDLER handler);
  // @cmember Permette di settare il nome del file di salvataggio
  void set_workfile(const char* workfile)
  { _workfile = workfile; _lastpos = 0L;}
  // @cmember Salva i valori dei campi della maschera sul file di salvataggio
  bool save(bool append = FALSE) const;
  // @cmember Legge i valori dei campi della maschera da file di salvataggio
  bool load(bool reset = FALSE);
  // @cmember Copia i valori dei campi dalla maschera <p m>
  void copy_values(const TMask &m);

  // @cmember Ritorna il primo campo dirty
  short dirty() const;

  // @cmember Setta lo sheet di cui la maschera gestisce le righe
  void set_sheet(TSheet_field* s)
  { _sheet = s; }

  // @cmember Ritorna lo sheet che gestisce la maschera
  TSheet_field* get_sheet() const
  { return _sheet; }

  // @cmember Ritorna se la maschera e' contenuta in uno sheet (TRUE se contenuta)
  bool is_sheetmask() const
  { return _sheet != NULL; }

  // @cmember Ritorna TRUE se la maschera non ha modalita' di utilizzo (vedi <t TMaskmode>)
  bool no_mode() const
  { return _mode == NO_MODE; }
  // @cmember Ritorna TRUE se la maschera e' in modalita' di richiesta (vedi <t TMaskmode>)
  bool query_mode() const
  { return _mode == MODE_QUERY || _mode == MODE_QUERYINS; }
  // @cmember Ritorna TRUE se la maschera e' in modalita' di modifica (vedi <t TMaskmode>)
  bool edit_mode() const
  { return _mode == MODE_MOD; }
  // @cmember Ritorna TRUE se la maschera e' in modalita' di inserimento (vedi <t TMaskmode>)
  bool insert_mode() const
  { return _mode == MODE_QUERYINS || _mode == MODE_INS; }

  // @cmember Ritorna il titolo della maschera
  virtual const char* get_caption() const;
  // @cmember Setta il titolo della maschera
  virtual void set_caption(const char* c);

  // @cmember Mostra un messaggio d'errore appena possibile
  void post_error_message(const char* msg, int severity);

  // @cmember Viene eseguita se il campo viene modificato
  virtual bool on_dirty(TMask_field& c);

  // @cmember Ritorna la finestra della toolbar
  WINDOW toolwin() const
  { return _pagewin[MAX_PAGES]; }
};

#endif // __MASK_H