root/campo-sirio
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
campo-sirio/include/form.h
guy 6ac7b50cda Patch level : 
Files correlati     : agalib
Ricompilazione Demo : [ ]
Commento            :
Aggiunto supporto per chiavi software SSA
Aggiunto supporto per ricerche alternative con prefisso %


git-svn-id: svn://10.65.10.50/branches/R_10_00@22582 c028cbd2-c16b-5b4b-a496-9718f37d4682
2012-02-22 17:03:39 +00:00

1186 lines
44 KiB
C++
Executable File
Raw Blame History

#ifndef __FORM_H
#define __FORM_H
#ifndef __SCANNER_H
#include <scanner.h>
#endif
#ifndef __PRINTER_H
class TPrinter;
class TPrintrow;
#endif
#ifndef __MASK_H
class TMask;
#endif
#ifndef __ISAM_H
class TRectype;
#endif
#ifndef __RELATION_H
#include <relation.h>
#endif
#ifndef __ASSOC_H
#include <assoc.h>
#endif
#ifndef __EXPR_H
#include <expr.h>
#endif
// @doc EXTERNAL
// @enum pagetype | Posizione della pagina da stampare
enum pagetype {
odd_page, // @emem Pagine dispari
even_page, // @emem Pagine pari
first_page, // @emem Prima pagina
last_page }; // @emem Ultima pagina
// @doc INTERNAL
// @enum titletype | Tipo di titolo per le sottosezioni
enum titletype {
type_notitle, // @emem Non è un titolo
type_title, // @emem Titolo di testa
type_qtitle}; // @emem Titolo di coda
// @enum sec_print_mode | Tipo di stampa per le sottosezioni
enum sec_print_mode {
printmode_noprint, // non stampa (hidden section)
printmode_normal, // valuta i campi e li stampa
printmode_qtitle, // valuta i campi e li tiene nel buffer titoli di coda
printmode_title // valuta i campi e li tiene nel buffer titoli di testa
};
pagetype char2page(char);
class TForm;
class TMask_field;
class TSheet_field;
class TForm_item;
class TPrint_section;
class TForm_subsection ;
const int MAXCOLUMNS = 64;
const int MAXSUBSECTIONS = 9;
// @doc EXTERNAL
// @class TForm | Classe per la descrizione dei formati di stampa
//
// @base public | TObject
class TForm : public TObject
// @author:(INTERNAL) Guido, Angelo, Villa
{
// @cfriend TForm_editor
friend class TForm_editor;
// @cfriend TForm_EC_editor
friend class TForm_EC_editor;
// @cfriend TPrint_section
friend class TPrint_section;
// @access:(INTERNAL) Private Member
// @cmember:(INTERNAL) Nome del profilo di stampa
TString _name;
// @cmember:(INTERNAL) Nome fisico del file profilo di stampa
TFilename _filename;
// @cmember:(INTERNAL) Codice del profilo di stampa
TString _code;
// @cmember:(INTERNAL) Nome del font da utilizzare
TString _fontname;
// @cmember:(INTERNAL) Dimensione del font da utilizzare
int _fontsize;
//@cmember:(INTERNAL) Numero esatto di pagine
word _npages;
//@cmember:(INTERNAL) Offset X valido per tutte le sezioni
int _x;
//@cmember:(INTERNAL) Offset Y valido per tutte le sezioni
int _y;
// @cmember:(INTERNAL) Carattere utilizzato per il posizionamento dei moduli
char _char_to_pos;
// @cmember:(INTERNAL) Coordinata X del posizionamento iniziale
int _ipx;
// @cmember:(INTERNAL) Coordinata Y del posizionamento iniziale
int _ipy;
// @cmember:(INTERNAL) Coordinata X del posizionamento finale (la riga e' la stessa)
int _fpx;
// @cmember:(INTERNAL) Flag per registrare i parametri (font ed offset)
bool _dirty;
// @cmember:(INTERNAL) Flag di abilitazione del messagio ADD
bool _msg_add_enabled;
// @cmember:(INTERNAL) Relazione corrente (puo' essere NULL), vedi <c TRelation>
TRelation* _relation;
// @cmember:(INTERNAL) Cursore corrente (puo' essere NULL), vedi <c Tcursor>
TCursor* _cursor;
// @cmember:(INTERNAL) <c TRelation_description> per la gestione della relazione corrente
TRelation_description* _rel_desc;
// @cmember:(INTERNAL) Indica se proseguire il ciclo next_match sul file (sezioni annidate)
TArray _skip_info;
// @cmember:(INTERNAL) Array di headers
TArray _head;
// @cmember:(INTERNAL) Array di bodies
TArray _body;
// @cmember:(INTERNAL) Array di footers
TArray _foot;
// @cmember:(INTERNAL) Array di sfondi grafici
TArray _back;
// @cmember:(INTERNAL) Indica se si sta stampando l'ultima pagina
bool _lastpage;
// @cmember:(INTERNAL) Indica se si sta stampando la prima pagina ed essa è uguale all'ultima
bool _first_eq_last;
// @cmember:(INTERNAL) Indica se si tratta di un nuovo form
bool _isnew;
// @cmember:(INTERNAL) Indica se si tratta di form di base (.frm file)
bool _isbase;
// @cmember:(INTERNAL) Indica se effettuare il posizionamento manuale dei moduli
bool _arrange;
// @cmember: (INTERNAL) Trasforma i reali in currency automaticamente
bool _magic_currency;
// @cmember:(INTERNAL) Permessi di Edit
int _editlevel;
// @cmember:(INTERNAL) Descrizione del formato
TString _desc;
// @cmember:(INTERNAL) Array di caratteri di fincatura
TString16 _fink;
// @cmember:(INTERNAL) Numero iniziale di pagina
word _frompage,_topage;
// @cmember:(INTERNAL) Codice divisa impiegata per stampa prezzi ed importi
TString16 _curr_codval;
// @cmember:(INTERNAL) Cambio da applicare in output per stampa prezzi ed importi
TExchange* _exchange;
// @cmember:(INTERNAL) Ritorna l'array di caratteri di fincatura
const char* get_fincatura()
{ return _fink; }
// @cmember:(INTERNAL) Setta l'array di caratteri di fincatura
void set_fincatura(const char* s);
// @access Protected Member
protected:
// @cmember:(INTERNAL) Handler di default della testata di stampa
static void header_handler(TPrinter& p);
// @cmember:(INTERNAL) Handler di default del piede di stampa
static void footer_handler(TPrinter& p);
// @cmember Cambia il formato di tutte le date nel form
bool ps_change_date_format(TPrint_section& s, const char* f);
// @cmember Cambia il formato di tutti i numeri nel form
bool ps_change_number_format(TPrint_section& s, int w, int dec, const char* p);
// @cmember Controlla se esiste una sezione di stampa
TPrint_section* exist(char s, pagetype t, bool create = FALSE);
// @cmember Inizializza il form
void init();
// @cmember Carica il form dal file specificato
void read(const char* form, const char* code = "", int editlevel = 0, const char* desc = "");
// @cmember Ritorna una sezione di stampa, la crea se non esiste (chiama <mf TForm::exist>)
TPrint_section& section(char s, pagetype pos);
// @cmember Ritorna una sezione di stampa, la crea se non esiste (chiama <mf TForm::exist>)
// (3 e' una pagina dispari qualsiasi)
TPrint_section& section(char s, word page = 3);
// @cmember Stampa la sezione <p s>
void print_section(ostream& out, char s) const;
// @cmember Stampa il sorgente del form su file di testo
virtual void print_on(ostream& out) const;
// @cmember Legge una use e setta la relazione (ritorna sempre TRUE)
bool parse_use(TScanner&, TString &);
// @cmember Legge una join e setta la relazione (ritorna sempre TRUE)
bool parse_join(TScanner& scanner);
// @cmember Legge una join e setta la relazione (ritorna sempre TRUE)
bool parse_sortedjoin(TScanner& scanner);
// @cmember Legge una join e setta la relazione (ritorna sempre TRUE)
bool parse_join_param(TScanner& scanner,TRelation * rel, TString16 j, int to );
// @cmember Legge l'espressione di ordinamento e ne ritorna la tokenstring
TToken_string parse_sortexpr(TScanner&);
// @cmember Legge l'espressione di filtro e ne ritorna la tokenstring
TToken_string parse_filter(TScanner&);
// @cmember Legge una <c TRelation_description> e setta la relazione
bool parse_description(TScanner&);
// @cmember Scrive una <c TRelation_description> su <p out>
void print_description(ostream& out) const;
// @cmember Legge dal file le caratteristiche generali del form (identificate da GE)
bool parse_general(TScanner&);
// @cmember Scrive le caratteristiche generali del form su <p out>
void print_general(ostream& out) const;
// @cmember Usata per leggere voci non-standard nella sezione generale
virtual void extended_parse_general(TScanner&)
{}
// @cmember Chiamata per effettuare controlli non standard nell'edit della sezione
// <p sec> (prima dell'esecuzione della maschera di edit <p m>)
virtual void pre_edit_checks(TMask&m, TPrint_section* sec)
{}
// @cmember Chiamata per effettuare controlli non standard nell'edit della sezione
// <p sec> (dopo l'esecuzione della maschera di edit <p m>)
virtual bool post_edit_checks(TMask& m, TPrint_section* sec)
{return FALSE;}
// @cmember Legge un profilo
bool read_profile();
// @cmember Scrive un profilo su file (vedi <mf TForm::read_profile>)
bool write_profile();
// @cmember Resetta gli specials obbligatori per ogni form_item (header, offset e fincatura)
// per comodita' di utilizzo dei membri _col_head, _ofs, finkl e finkr di TForm_item.
void set_compulsory_specials();
// @cmember Legge gli specials obbligatori prima di scriverli
void get_compulsory_specials();
// @cmember Ritorna il numero di pagina correntemente in stampa
word page(const TPrinter& p) const;
// @cmember Ritorna il numero di pagina prossimamente in stampa
word next_page(const TPrinter& p) const;
// @cmember Ritorna se la prima pagina coincide conl'ultima
bool firstpage_is_lastpage() const;
// @cmember Effettua il posizionamento manuale del modulo
void arrange_form();
// @cmember Ritorna il numero di record presenti nella <c TCursor>
virtual long records() const;
// @cmember Effettua l'update della sezione grafica background
virtual word set_background(word p, bool u);
// @cmember Effettua l'update della sezione header
virtual word set_header(word p, bool u);
// @cmember Effettua l'update della sezione body
virtual word set_body(word p, bool u);
// @cmember Effettua l'update della sezione footer
virtual word set_footer(word p, bool u);
// @access Public Member
public:
// @cmember Genera automaticamente la sezione grafica con colonne fincate
bool genera_fincatura(pagetype p, int y1, int y2, const int* rows);
// @cmember Genera le righe di intestazione colonna alla riga indicata, vale per COLUMNWISE
bool genera_intestazioni(pagetype p, short y);
// @cmember Stampa gli items da <p form> a <p to>
bool print(long from = 0L, long to = -1L);
// @cmember Memorizza il risultato dell'ultimo match (val==-1: resetta) su <p file>
void match_result(int file=0, int val=-1);
// @cmember Indica se l'ultimo next_match su <p file> è stato fruttuoso
bool last_match_result(int file=0);
// @cmember Indica se è già stato fatto un next_match su <p file>
bool next_match_done(int file=0);
// @cmember Indica se è già stato fatto un next_match su <p file>
int matches_done(int file=0);
// @cmember Ritorna l'altezza della pagina <p page> la prima di default
word height(word page = 3);
// @cmember Ritorna l'array di item del body
TArray& body()
{ return _body; }
// @cmember Ritorna l'array di item dell'header
TArray& head()
{ return _head; }
// @cmember Ritorna l'array di item del footer
TArray& foot()
{ return _foot; }
// @cmember Ritorna l'array di item dello sfondo
TArray& back() { return _back; }
// @cmember Ritorna il nome del profilo di stampa
const TString& name() const
{ return _name; }
// @cmember Ritorna il codice del profilo di stampa
const TString& code() const
{ return _code; }
// @cmember Ritorna il nome fisico del file del profilo di stampa
const TFilename& filename() const
{ return _filename; }
// @cmember Ritorna se il form è un modulo a pagine fisse
bool fixed_pages() const
{ return _npages>0; }
// @cmember Ritorna se il form contiene sottosezioni
bool has_subsections();
// @cmember Ritorna il nome della mschera per la sezione
virtual const char* section_mask()
{ return "ba2100s"; }
// @cmember Ritorna i permessi di Edit (<md TForm::_editlevel> assume solo i valori 0 e non 0)
int edit_level() const
{ return _editlevel; }
// @cmember Setta i permessi di edit
void set_edit_level(int n)
{ _editlevel = n; }
// @cmember Setta la descrizione del formato
void set_description(const char* s)
{ _desc = s; }
// @cmember Setta la divisa impiegata per la stampa di importi e prezzi
void set_curr_codval(const char* cv = "")
{ _curr_codval = cv; }
// @cmember Ritorna la divisa impiegata per la stampa di importi e prezzi
const TString& get_curr_codval() const
{ return _curr_codval; }
// @cmember Setta il flag di TCurrency automatici
void set_magic_currency(bool mc = TRUE)
{ _magic_currency = mc; }
// @cmember Ritorna il valore del flag per i TCurrency automatici
const bool magic_currency() const
{ return _magic_currency; }
void set_output_exchange(const char* codval, real exchange = ZERO);
const TExchange* output_exchange() const { return _exchange; }
void enable_message_add(bool on) { _msg_add_enabled = on; }
void disable_message_add() { enable_message_add(FALSE); }
bool message_add_enabled() const { return _msg_add_enabled; }
// @cmember Ritorna la relazione corrente
virtual TRelation* relation() const
{ return _relation; }
// @cmember Ritorna la <c TCursor> corrente
virtual TCursor* cursor() const
{ return _cursor; }
// @cmember Ritorna la <c TRelation_description> corrente
TRelation_description& rel_desc() const;
// @cmember Effettua operazioni personalizzate dall'applicazione sul <c TForm_item>
virtual bool validate(TForm_item& fld, TToken_string& val);
// @cmember Ritorna il campo <p id>-esimo della sezione <p sec> se esiste
TForm_item* exist_field(char sec, pagetype pag, short id) const;
// @cmember Ritorna la sottosezione <p name> della sezione <p sec> se esiste
TForm_subsection* exist_field(char sec, pagetype pag, const char *name) const;
// @cmember Ritorna il campo <p id>-esimo della sezione <p sec>
TForm_item& find_field(char sec, pagetype pag, short id) const;
// @cmember Ritorna la sottosezione <p name> della sezione <p sec>
TForm_subsection& find_field(char sec, pagetype pag, const char *name) const;
// @cmember Ritorna l'offset x valido per tutte le sezioni
int& offset_x()
{ return _x; }
// @cmember Ritorna l'offset x valido per tutte le sezioni
int& offset_y()
{ return _y; }
// @cmember Ritorna il nome del font in uso
TString& fontname()
{ return _fontname; }
// @cmember Ritorna la dimensione del font in uso
int& fontsize()
{ return _fontsize; }
// @cmember Ritorna il carattere utilizzato per il posizionamento dei moduli
char& char_to_pos()
{ return _char_to_pos; }
// @cmember Ritorna la coordinata X del posizionamento iniziale
int& ipx()
{ return _ipx; }
// @cmember Ritorna la coordinata Y del posizionamento iniziale
int& ipy()
{ return _ipy; }
// @cmember Ritorna la coordinata X del posizionamento finale
int& fpx()
{ return _fpx; }
// @cmember Ritorna il flag per registrare i parametri
bool dirty() const
{ return _dirty; }
// @cmember Setta il flag per registrare i parametri
void set_dirty(bool d = TRUE)
{ _dirty = d; }
// @cmember Setta se effettuare il posizionamento manuale dei moduli
void set_arrange(bool arng = TRUE)
{ _arrange = arng ; }
// @cmember Cambia il formato di tutte le date nel form (vedi <mf TForm::ps_change_date_format>)
void change_date_format(const char* f);
// @cmember Cambia il formato di tutti i numeri nel form (vedi <mf TForm::ps_change_number_format>)
virtual void change_number_format(int w, int dec, const char* p);
// @cmember Rilegge la sezione specificata
bool reread(char sec, pagetype p, bool force=FALSE);
// @cmember Editor interface (vedi <c TForm_editor>)
TForm_editor& editor() const;
// @cmember Setta lil numero di pagina iniziale
void set_from_page(word p)
{_frompage=p;}
// @cmember Setta lil numero di pagina finale
void set_to_page(word p)
{_topage=p;}
// @cmember Setta l'inizio di stampa dell'ultima pagina
void set_last_page(bool lp)
{ _lastpage = lp; }
// @cmember Setta il modo di sfondo (fincatura)
void set_fink_mode(bool f);
// @cmember Ritorna il modo di sfondo (fincatura)
bool get_fink_mode();
// @cmember Costruttore
TForm();
// @cmember Costruttore (se <p code> == NULL si tratta in form di base, diversamente e'
// integrato by a file definition)
TForm(const char* form, const char * code = "", int editlevel = 0, const char* desc = "");
// @cmember Distruttore
virtual ~TForm();
};
// @doc INTERNAL
// @class TForm_flags | Classe per la gestione dei flag di una <c TForm>
//
// @base public | TObject
class TForm_flags : public TObject
// @author:(INTERNAL) Guido, Angelo, Villa
{
// @access Public Member
public:
// @cmember Indica se il campo e' automagico (determina da solo il suo valore
// alla partenza della maschera)
bool automagic : 1;
// @cmember Indica se il campo e' abilitato
bool enabled : 1;
// @cmember Indica se il campo e' visibile
bool shown : 1;
// @cmember Indica se il campo e' stato modificato
bool dirty : 1;
// @cmember Indica se il campo possiede un carattere di fincatura sinistro
bool finkl : 1;
// @cmember Indica se il campo possiede un carattere di fincatura destro
bool finkr : 1;
// @cmember Indica se si tratta di un campo memo
bool memo : 1;
// @cmember Indica se va stampato a inizio di pagina nuova
bool newpage : 1;
// @cmember Indica (in caso di TForm_currency) se si tratta di un prezzo unitario
bool price : 1;
// @access Protected Member
protected:
// @cmember Permette di stampare i flags su file di testo
void print_on(ostream& out) const;
// @access Public Member
public:
// @cmember Costruttore
TForm_flags();
// @cmember Setta il flag di visibile
void set_shown(bool b)
{ shown = b; }
// @cmember Setta il flag di fincatura sinistra
void set_finkl(bool b)
{ finkl = b; }
// @cmember Setta il flag di fincatura destra
void set_finkr(bool b)
{ finkr = b; }
// @cmember Setta il flag di campo memo
void set_memo (bool b)
{ memo = b; }
// @cmember Setta il flag di campo memo
void set_newpage (bool b)
{ newpage = b; }
// @cmember Setta il flag di campo prezzo per TForm_currency
void set_price (bool b)
{ price = b; }
// @cmember Permette di stampare i flags sulla maschera di editing <p m>
void print_on(TMask& m);
// @cmember Legge i flgs dalla maschera <p m>
void read_from(const TMask& m);
// @cmember Aggiorna i flags con la stringa <p s>
bool update(const char* s);
};
// @doc EXTERNAL
// @class TPrint_section | Classe per la gestione della stampa di una sezione di <c TForm>
//
// @base public | TObject
class TPrint_section : public TObject
// @author:(INTERNAL) Guido, Angelo, Villa
// @access:(INTERNAL) Private Member
{
// @cmember:(INTERNAL) Maschera di edit della sezione corrente
static TMask* _msk;
// @cmember:(INTERNAL) Array delle righe
TArray _rows;
// @cmember:(INTERNAL) Array delle righe dei titoli
TArray _titlerows;
// @cmember:(INTERNAL) Altezza della sezione
word _height;
// @cmember:(INTERNAL) Offset prima colonna
word _ofspc;
// @cmember:(INTERNAL) Offset verticale intestazione colonna
word _ofsvr;
// @cmember:(INTERNAL) Numero di colonne se COLUMNWISE
word _nfld;
// @cmember:(INTERNAL) Flag di modifica parametri
bool _dirty;
// @cmember:(INTERNAL) Specifica la sezione COLUMNWISE
bool _columnwise;
// @cmember:(INTERNAL) Indica se si tratta di una sezione temporanea (da non salvare)
bool _temp;
// @cmember:(INTERNAL) <c TForm> a cui appartiene la sezione
TForm* _form;
// @cmember:(INTERNAL) Tipo della sezione da stampare (<p H>=header, <p B>=body
// <p F>=footer, <p G>=background)
char _sec_type;
// @cmember:(INTERNAL) Posizione della pagina da stampare (vedi <t pagetype>)
pagetype _page_type;
// @cmember:(INTERNAL) Puntatore alla sezione soprastante (!= NULL se si è in una sottosezione)
TForm_subsection * _upsection;
// @cmember:(INTERNAL) Array di sottosezioni
TPointer_array _subsections;
// @cmember:(INTERNAL) Lista dei campi da stampare
TArray _item;
// @cmember:(INTERNAL) Numero di ripetizione eseguite
int _repeat_count;
// @cmember:(INTERNAL) Offset delle colonne se COLUMNWISE
int _tab[MAXCOLUMNS];
// @cmember:(INTERNAL) Fa una copia della print_section
const TPrint_section& copy(const TPrint_section& ps);
// @access Protected Member
protected:
// @cmember Stampa la sezione su file di testo
virtual void print_on(ostream& out) const;
// @cmember Crea un nuovo <c TForm_item> di formato <p key> ritornandone un puntatore
virtual TForm_item* parse_item(const TString& key);
// @cmember Crea un nuovo <c TForm_item> ritornandone un puntatore (chiama <mf TForm_item::parse_item>)
TForm_item* parse_item(TScanner& scanner);
// @cmember Procedura che effettua il ricalcolo delle coordinate di <c TForm_item> nel caso il font sia cambiato
static bool repos_fields(const char* name, int size);
// @cmember Handler del bottone per editare in modo dettagliato un <c TForm_item>
static bool detail_field_handler(TMask_field&, KEY);
// @cmember Handler del bottone per editare gli specials di un <c TForm_item>
static bool special_field_handler(TMask_field&, KEY);
// @cmember Handler dello sheet presente nella maschera di edit della sezione
static bool detail_field_notify (TSheet_field&, int, KEY);
// @cmember Cerca e ritorna l'<p id>-esimo campo nella sezione (funzione ricorsiva usata da find_field)
TForm_item * find_field_everywhere(short id,const TPrint_section *starting) const;
// @cmember Cerca e ritorna la sottosezione <p id> nella sezione
TForm_item * find_field_everywhere(const char *id,const TPrint_section *starting) const;
// @access Public Members
public:
// @cmember Ritorna la <c TPrintrow> della riga <p num>
TPrintrow& row(int num);
// @cmember Ritorna la <c TPrintrow> titoli della riga <p num>
TPrintrow& titlerow(int num);
// @cmember Ritorna il <c TForm> a cui appartiene la sezione
TForm& form() const
{ return *_form; }
// @cmember Ritorna la lista dei campi da stampare
TArray& field_array()
{ return _item; }
// @cmember Ritorna l'<p n>-esimo campo da stampare
TForm_item& field(int n) const
{ return (TForm_item&)_item[n]; }
// @cmember Cerca e ritorna l'<p id>-esimo campo nella sezione
TForm_item* exist_field(short id) const;
// @cmember Cerca e ritorna la sottosezione <p id> nella sezione
TForm_item* exist_field(const char *id) const;
// @cmember Cerca e ritorna l'<p id>-esimo campo da stampare
TForm_item& find_field(short id) const;
// @cmember Cerca e ritorna la sottosezione <p id> da stampare
TForm_item& find_field(const char *id) const;
// @cmember Rimuove uno o tutti i campi da stampare (chiama <mf TArray::destroy>)
void destroy_field(int n, bool c = TRUE)
{ _item.destroy(n, c); }
// @cmember Rimuove tutti i campi da stampare (chiama <mf TArray::destroy>)
void destroy_fields()
{ _item.destroy(); }
// @cmember Viene sostituito il campo di posizione <p n> col campo <p f> (chiama <mf TArray::add>)
void change_field(int n, TForm_item* f);
// @cmember Viene inserito il campo di posizione <p n> col campo <p f> (chiama <mf TArray::insert>)
void insert_field(int n, TForm_item* f);
// @cmember Viene aggiunto i coda alla'array il campo <p f> (chiama <mf TArray::add>)
void add_field(TForm_item* f);
// @cmember Aggiunge una sottosezione
void add_subsection(TForm_subsection * ss) ;
// @cmember Restituisce la sezione numero n
TForm_subsection * subsection(int n) const ;
// @cmember Restituisce il numero di sottosezioni
int subsections() const ;
// @cmember Restituisce il puntatore alla sezione "Padre"
TPrint_section* section_above() const ;
// @cmember Restituisce il puntatore alla sezione "Padre"
TForm_subsection* subsection_above() const { return _upsection; } // Maybe NULL
// @cmember Setta il puntatore alla sezione "Padre"
void set_subsection_above(TForm_subsection* ssa) { _upsection = ssa; } // Maybe NULL
// @cmember ricompone le espressioni di FILE GROUP delle sottosezioni contenute
void set_subs_cond(int file,const char *newcond,const char * oldcond);
// @cmember Valuta l'espressione passata risolvendo le variabili
TExpression & eval_expr(TExpression & e, int def_file=0);
// @cmember Ritorna se si tratta di una sezione temporanea
virtual bool& temp()
{ return _temp; };
// @cmember Ritorna se si tratta di una sezione temporanea
virtual bool temp() const
{ return _temp; };
// @cmember Crea un campo della classe specificata
virtual TForm_item* create_item(const TString& typ);
// @cmember Ritorna il numero di campi da stampare
word fields() const
{ return _item.items(); }
// @cmember Ritorna il numero di campi stampabili (0 se non e' COLUMNWISE)
word columns()
{ tab(0); return _nfld; }
// @cmember Ritorna l'altezza della sezione
word height() const ;
// @cmember Ritorna l'altezza minima delle sottosezioni (non più usato)
word subs_height() const ;
// @cmember Ritorna l'offset della prima colonna
word ofspc() const
{ return _ofspc; }
// @cmember Ritorna l'offset verticale intestazione colonna
word ofsvr() const
{ return _ofsvr; }
// @cmember Modifica i parametri di offset <p x> e <p y> del foglio
void offset(int& x, int& y);
// @cmember Setta il numero di ripetizioni eseguite
void set_repeat_count(int x)
{ _repeat_count = x; }
// @cmember Ritorna il numero di ripetizioni eseguite
int repeat_count()
{ return _repeat_count; }
// @cmember Setta l'altezza della sezione
void set_height(word h)
{ _height = h; }
// @cmember Controlla che si tratti di una sezione vaida (altezza e numero di campi diversi da 0)
virtual bool ok() const
{ return height() > 0 || fields() > 0; }
// @cmember Azzera tutte le righe della sezione di stampa
void reset();
// @cmember Azzera tutti i campi della sezione di stampa
void reset_fields();
// @cmember Stampa le righe bufferizzate dei titoli e le azzera
void print_title();
// @cmember Aggiorna tutti i campi e li inserisce nel buffer delle righe di stampa
virtual bool update();
// @cmember Stampa le righe
word print_rows(const sec_print_mode show_fields, word from, word to);
// @cmember Aggiorna tutti i campi e li stampa (usata in caso di BODY)
bool update_and_print(const sec_print_mode shown, bool newpage=FALSE);
// @cmember Legge la testata dal file di testo (vedi <c TScanner>)
bool parse_head(TScanner& scanner);
// @cmember Legge i campi della sezione dal file di testo (vedi <c TScanner>)
bool parse_body(TScanner& scanner);
// @cmember Legge la testata e il corpo (chiama parse_head e parse_body)
bool parse(TScanner& scanner);
// @cmember Legge dal record <p rec> altezza e offset prima colonna della sezione
bool read_from(const TRectype& rec);
// @cmember Settano il record <p rec> con i valori attuali della sezione
void print_on(TRectype& rec);
// @cmember Esegue l'edit della sezione di stampa
bool edit(const char* title);
// @cmember Ritorna il tipo della sezione da stampare (vedi <md TPrint_section::_sec_type>)
char section_type() const
{ return _sec_type; }
// @cmember Ritorna il tipo di pagina da stampare (vedi <t pagetype>)
pagetype page_type() const
{ return _page_type; }
// @cmember Ritorna TRUE se sono stati modificati i parametri
bool dirty() const
{ return _dirty; }
// @cmember Setta il flag di modifica parametri
void set_dirty(bool d = TRUE)
{ _dirty = d; }
// @cmember Ritorna TRUE se si tratta di una campo COLUMNWISE
bool columnwise() const
{ return _columnwise; }
// @cmember Ritorna l'offset della colonna <p col> se COLUMNWISE
int tab(int col);
// @cmember Annulla (setta a -1) l'offset delle colonne se COLUMNWISE
void reset_tabs();
// @cmember Operatore di assegnamento
const TPrint_section& operator=(const TPrint_section& ps)
{ return copy(ps); }
// @cmember Costruttore
TPrint_section(TForm* parent, char st, pagetype pt, TForm_subsection *fathersection = NULL);
// @cmember Costruttore
TPrint_section(const TPrint_section& ps)
{ copy(ps); }
// @cmember Distruttore
virtual ~TPrint_section();
};
// @doc EXTERNAL
// @class TForm_item | Classe per la definizione per ogni campo del <c TForm>
//
// @base public | TObject
class TForm_item : public TObject
// @author:(INTERNAL) Guido, Angelo, Villa
{
// @cfriend TPrint_section
friend class TPrint_section;
// @access:(INTERNAL) Private Member
// @cmember:(INTERNAL) Gruppi a cui appartiene il campo
TBit_array _group;
// @cmember:(INTERNAL) Special attribuiti al campo (vedi <c TAssoc_array>)
TAssoc_array _special;
// @cmember:(INTERNAL) Indica se si tratta di un campo temporaneo (da non salvare)
bool _temp;
// @access Protected Member
protected:
// @cmember:(INTERNAL) Flag del campo (vedi <c TForm_flags>)
TForm_flags _flag;
// @cmember:(INTERNAL) Sezione da stampare (vedi <c TPrint_section>)
TPrint_section* _section;
// @cmember Identificatore del campo
short _id;
// @cmember Coordinata X (in caratteri) del campo
short _x;
// @cmember Coordinata Y (in caratteri) del campo
short _y;
// @cmember Larghezza del campo (in caratteri)
short _width;
// @cmember Altezza del campo (in caratteri)
short _height;
// @cmember Altezza effettiva del campo
short _effective_height;
// @cmember Offset del campo rispetto l'inizio della colonna (usato per campi
// appartenenti a sezioni COLUMNWISE)
short _ofs;
// @cmember Prompt del campo
TString _prompt;
// @cmember Descrizione del campo
TString _desc;
// @cmember Intestazione della colonna (usato per campi appartenenti a sezioni COLUMNWISE)
TString _col_head;
// @cmember Array di message che manda il campo
TString_array _message;
// @cmember Stampa sullo stream <p out> le caratteristiche del campo
virtual void print_on(ostream& out) const;
// @cmember Stampa sullo stream <p out> il corpo del campo
virtual void print_body(ostream& out) const;
// @cmember Legge dal file di testo identificatore, altezza e larghezza del campo
virtual bool parse_head(TScanner&);
// @cmember Legge dal file di testo il tipo di campo (prima riga)
virtual bool parse_item(TScanner&);
// @cmember Ritorna il messaggio <p m>-esimo del campo
TToken_string& message(int m = 0);
// @cmember Manda il messaggio al campo <p dest>
virtual void send_message(const TString& cmd, TForm_item& dest) const;
// @cmember Esegue il messaggio <p m>
bool do_message(int m = 0);
// @cmember Stampa una stringa alla posizione indicata
void string_at(int x, int y, const char* s);
// @cmember Cerca nella definizione della variabile <p s> e ne ritorna
// l'<p n>-esimo elemento (0=tipo, 1=valore, 2=descrizione)
const char* get_special_item(const char* s, int n) const;
// @cmember Copia tutti i membri dell'oggetto base in fi. Viene chiamata dalla <mf TForm_item::dup>
void copy_to_form_item(TForm_item* fi) const;
// @cmember manda il messaggio a tutti i campi appartenenti al gruppo inidcato
// (funzione ricorsiva chiamata da <mf TForm_item::do_message>)
void send_message_to_group(const char * cmd,byte id,const TPrint_section & section, const TPrint_section *starting_section) ;
// @access Public Member
public:
// @cmember Duplica un TForm_item. Chiama la <mf TForm_item::copy_to_form_item>
virtual TObject* dup() const;
// @cmember Ritorna il numero identificatore del campo
short id() const
{ return _id; }
// @cmember Ritorna il reference del numero identificatore del campo
virtual short& id()
{ return _id; };
// @cmember Ritorna la larghezza del campo (in caratteri)
virtual int width() const
{ return _width; }
// @cmember Ritorna il reference della larghezza del campo (in caratteri)
virtual short& width()
{ return _width; }
// @cmember Ritorna l'altezza del campo (in caratteri)
virtual int height() const
{ return _height; }
// @cmember Ritorna il reference dell'altezza del campo (in caratteri)
virtual short& height()
{ return _height; }
// @cmember Ritorna l'offset del campo rispetto l'inizio della colonna
virtual short& ofs()
{ return _ofs; }
// @cmember Ritorna l'altezza effettiva del campo
virtual int effective_height() const
{ return _effective_height; }
// @cmember Imposta l'altezza effettiva del campo
virtual void set_effective_height(int val)
{ _effective_height=val; }
// @cmember Formatta la stringa <p s>. Funzione che per default non fa nulla.
// Ridefinita solo per TForm_number e TForm_string.
virtual void apply_format(TString & s) const {}
// @cmember Scrive la stringa <p s> alla posizione del TForm_item. Funzione che
// per default non fa nulla. Ridefinita solo per TForm_number e TForm_string.
virtual void put_paragraph(const char* s) {}
// @cmember Ritorna se si tratta di una campo temporaneo (reference)
virtual bool& temp()
{ return _temp; };
// @cmember Ritorna se si tratta di una campo temporaneo
virtual bool temp() const
{ return _temp; };
// @cmember Ritorna se il campo e' memo
bool has_memo() const
{ return _flag.memo; }
virtual bool is_section() const { return false; }
// virtual short& x() { return _x; };
// @cmember Setta la ccordinata X (in caratteri) del campo
virtual void set_x(short x)
{_x=x;}
// @cmember Ritorna la coordinata X del campo
virtual short x();
// @cmember Ritorna il reference della coordinata Y del campo
virtual short& y()
{ return _y; }
// @cmember Ritorna la coordinata Y del campo
virtual short y() const
{ return _y; }
// @cmember Ritorna la coordinata X del campo se e' COLUMNWISE (altrimenti <f CHECK>)
virtual short get_column()
{ CHECK(_section->columnwise(),"La sezione non e' COLUMNWISE"); return _x; }
// @cmember Setta la coordinata X del campo se e' COLUMNWISE (altrimenti <f CHECK>)
virtual void set_column(short c)
{ CHECK(_section->columnwise(),"La sezione non e' COLUMNWISE"); _x = c;}
// @cmember Ritorna il numero di campi da stampare
virtual const int fields()
{ return 0;}
// @cmember Ritorna se si tratta di un campo visibile
bool shown() const
{ return _flag.shown; }
// @cmember Ritorna se si tratta di un campo nascosto
bool hidden() const
{ return !_flag.shown; }
// @cmember Ritorna se si tratta di un campo abilitato
bool enabled() const
{ return _flag.enabled; }
// @cmember Ritorna se si tratta di un campo disabilitato
bool disabled() const
{ return !_flag.enabled; }
// @cmember Ritorna se si tratta di un campo automagic (vedi <md TForm_flags::automagic>)
bool automagic() const
{ return _flag.automagic; }
// @cmember Ritorna se il campo possiede un carattere si fincatura sinistra
bool finkl() const
{ return _flag.finkl; }
// @cmember Ritorna se il campo possiede un carattere si fincatura destra
bool finkr() const
{ return _flag.finkr; }
// @cmember Ritorna se si tratta di campo memo
bool memo() const
{ return _flag.memo; }
// @cmember Legge da file di testo le caratteristiche del campo
virtual bool parse(TScanner&);
// @cmember Aggiorna il contenuto del campo e lo mette nella riga di stampa
virtual bool update();
// @cmember Compila la maschera coi dati del campo
virtual void print_on(TMask& m);
// @cmember Registra sul record i dati del campo
virtual void print_on(TRectype& rform);
// @cmember Compila la <c TToken_string> <p t> coi dati editabili del campo
virtual void print_on_sheet_row(TToken_string& t) const;
// @cmember Legge le caratteristiche di un campo da una <c TMask>
virtual void read_from(const TMask& m);
// @cmember Legge le caratteristiche di un campo da un <c TRectype>
virtual bool read_from(const TRectype& rform);
// @cmember Legge le caratteristiche di un campo da una <c TToken_string>
virtual void read_from(TToken_string& s);
// @cmember Edita il campo usando la maschera <p m>
virtual bool edit(TMask& m);
// @cmember Ritorna il prompt del campo
virtual const char* get() const
{ return _prompt; }
// @cmember Setta il prompt del campo
virtual bool set(const char* s)
{ _prompt = s; return true; }
// @cmember Ritorna un esempio del formato corrente
virtual const char* example() const
{ return ""; }
// @cmember Ritorna se si tratta di un campo appartenente ad una sezione
// COLUMNWISE (<f CKECK> se non e' COLUNMNWISE)
const TString& col_head() const
{CHECK(_section->columnwise(),"La sezione non e' COLUMNWISE"); return _col_head;}
// @cmember Setta se si tratta di un campo appartenente ad una sezione
// COLUMNWISE (<f CKECK> se non e' COLUNMNWISE)
void set_col_head(const char* s)
{CHECK(_section->columnwise(),"La sezione non e' COLUMNWISE"); _col_head = s;}
// @cmember Ritorna il prompt del campo
const TString& prompt() const
{ return _prompt; }
// @cmember Setta il prompt del campo
void set_prompt(const char* s)
{ _prompt = s; }
// @cmember Ritorna il memo associato al campo. (<f CHECK> per un generico item)
virtual TToken_string& memo_info();
// @cmember Ritorna la picture del campo. (<f CHECK> per un generico item)
virtual const TString& picture() const;
// @cmember Setta la picture del campo. (<f CHECK> per un generico item)
virtual void set_picture(const char*);
// @cmember Ritorna la <c TPrint_section> del campo
TPrint_section& section() const
{ return *_section; }
// @cmember Ritorna la <c TForm> della sezione del campo
TForm& form() const
{ return _section->form(); }
// @cmember Cerca il campo identificato da <p id> !!!
TForm_item& find_field(const TString& id) const;
// @cmember Setta il flag di pagina nuova
void set_newpage(bool d = TRUE)
{ _flag.newpage = d; }
// @cmember Setta il flag di fincatura sinistra
void set_finkl(bool d = TRUE)
{ _flag.finkl = d; }
// @cmember Setta il flag di fincatura destra
void set_finkr(bool d = TRUE)
{ _flag.finkr = d; }
// @cmember Setta il flag di campo modificato
void set_dirty(bool d = TRUE)
{ _flag.dirty = d; }
// @cmember Ritorna il flag di campo modificato
bool dirty() const
{ return _flag.dirty; }
// @cmember Ritorna se il campo appartiene al gruppo <p g>
bool in_group(byte g) const
{ return g == 0 || _group[g]; }
// @cmember Ritorna la descrizione del campo
const TString& key() const
{ return _desc; }
// @cmember Riempie la <c TToken_string> <p row> coi dati del campo
virtual void print_on(TToken_string& row) const;
// @cmember Setta il flag di campo visibile
virtual void show(bool on = TRUE)
{ _flag.shown = on; }
// @cmember Nasconde il campo
void hide()
{ show(FALSE); }
// @cmember Abilita/Disabilita il campo
virtual void enable(bool on = TRUE);
// @cmember Disabilita il campo (chiama <mf TForm_item::enable>)
void disable()
{ enable(FALSE); }
// @cmember Ritorna il numero di specials del campo
int special_items() const
{ return _special.items(); }
// @cmember Ritorna gli specials del campo
TAssoc_array& specials() const
{ return (TAssoc_array&)_special; }
// @cmember Riempie il TString_array <p r> passato per reference con i nomi delle variabili
int get_special_names(TString_array& r);
// @cmember Ritorna il valore dello special corrispondente al nome <p s>
// (chiama <mf TForm_item::get_special_item>)
const char* get_special_value(const char* s) const
{ return get_special_item(s, 1); }
void set_special_value(const char* s, const char* val);
// @cmember Ritorna il tipo dello special corrispondente al nome <p s>
// (chiama <mf TForm_item::get_special_item>)
const char* get_special_type (const char* s) const
{ return get_special_item(s, 0); }
// @cmember Ritorna la descrizione dello special corrispondente al nome <p s>
// (chiama <mf TForm_item::get_special_item>)
const char* get_special_desc (const char* s) const
{ return get_special_item(s, 2); }
// @cmember Costruttore
TForm_item(TPrint_section* section);
// @cmember Distruttore
virtual ~TForm_item()
{}
};
class TForm_subsection : public TForm_item
{
TForm_subsection * _title_section, *_qtitle_section;// sottosezioni titolo e coda
TPrint_section _ssec; // sezione di stampa contenente il "corpo" della sottosezione
TString _name; // nome della subsection
titletype _title_type; // indicatore di sezione di tipo titolo
bool _show_title; // indicatore titolo ancora da stampare (in caso di sezione titolo)
bool _bigskip; // indicatore di bigskip sui raggruppamenti (salta di gruppo in gruppo)
int _file_id; // ID del file su cui iterare in stampa se previsto
TExpression * _condexpr; // espressione condizionale per la valutazione della sottosezione
// o per individuare il raggruppamento nel file
protected:
virtual void print_on(ostream& out) const;
TForm_subsection * upper_conditional() const ;
public:
virtual TObject* dup() const;
virtual bool parse(TScanner& s);
virtual bool update();
virtual bool edit(TMask& m);
// @cmember Ritorna l'altezza (in caratteri)
virtual int height() const
{return _ssec.height();}
// @cmember Ritorna l'altezza minima (in caratteri)
int minheight() const
{return _height;}
virtual const char* class_name() const { return "SEZIONE"; }
virtual bool is_section() const { return TRUE; }
// @cmember Restituisce la sezione di stampa del "corpo"
TPrint_section& printsection() { return _ssec; }
// @cmember Setta la sezione titolo
void set_title_section(TForm_subsection * s);
// @cmember Setta la sezione titolo
void set_qtitle_section(TForm_subsection * s);
// @cmember Restituisce la sezione di stampa "titolo"
TPrint_section & title_section(TPrint_section& s) {return _title_section->printsection();}
// @cmember Restituisce se la sezione è un titolo
inline bool is_title() {return _title_type != type_notitle;}
// @cmember Restituisce se la sezione è un titolo di testa
inline bool is_htitle() {return _title_type == type_title;}
// @cmember Restituisce se la sezione è un titolo di coda
inline bool is_qtitle() {return _title_type == type_qtitle;}
// @cmember Ritorna se la sezione è da stampare a inizio di pagina nuova
bool atnewpage() {return _flag.newpage;}
// virtual void show(bool on = TRUE);
// virtual void enable(bool on = TRUE);
void hide() { show(FALSE); }
void disable() { enable(FALSE); }
// @cmember Ritorna il nome della sezione
void name(const char* s) { _name = s; _desc << "Sottosezione " << s; }
const char* name() const { return _name; }
// @cmember restituisce la condizione della sottosezione
const char * condition();
// @cmember restituisce il numero del file associato alla sottosezione
int fileid();
// @cmember imposta la condizione della sottosezione
void setcondition(const char * cond,TTypeexp type=_numexpr);
// @cmember Setta il flag di titolo ancora da stampare
void show_title(bool on) {_show_title=on;}
// @cmember Aggiorna e stampa tutti i campi della sezione e delle sezioni contenute
bool print_body(sec_print_mode showfields=printmode_normal);
// @cmember Aggiorna e stampa tutti i titoli delle sezioni soprastanti
bool print_titles() ;
// @cmember Aggiorna e stampa il titolo di coda
bool print_qtitle() ;
// @cmember Costruttore
TForm_subsection(TPrint_section* above_section, const char* name = "");
virtual ~TForm_subsection();
};
class TForm_string : public TForm_item
{
TString _str, _picture;
TArray _field;
TToken_string _memo;
protected:
virtual const char* class_name() const { return "STRINGA"; }
virtual void print_body(ostream& out) const;
virtual void print_on(TMask& m);
virtual void read_from(const TMask& m);
virtual bool read_from(const TRectype& rform);
virtual void print_on(TRectype& rform);
virtual void print_on(TToken_string& row);
virtual bool parse_item(TScanner&);
virtual bool read();
virtual bool update();
virtual const char* example() const;
virtual TToken_string& memo_info() { return _memo; }
public:
virtual TObject* dup() const;
virtual const int fields() { return _field.items();}
virtual const TString& picture() const { return _picture; }
virtual void set_picture(const char* p) { _picture = p; }
virtual void apply_format(TString & s) const;
virtual void put_paragraph(const char* s);
virtual bool edit(TMask& m);
virtual const char* get() const;
virtual bool set(const char*);
TFieldref& field(int i) const { return (TFieldref&)_field[i]; }
TForm_string(TPrint_section* section);
virtual ~TForm_string() {}
};
#ifdef __FORM_CPP
TForm* _cur_form;
#else
extern TForm* _cur_form;
#endif
#endif
Reference in New Issue View Git Blame Copy Permalink