campo-sirio/include/printer.h

#ifndef __PRINTER_H
#define __PRINTER_H

#ifndef __STDIO_H
#include <stdio.h>
#endif

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

#ifndef __TEXT_H
#include <text.h>
#endif                   


// @doc EXTERNAL

// @enum TPrintstyle | Indica lo stile da assegnare al carattere 
enum TPrintstyle 
{
  normalstyle     = 0, // @emem Stile normale
  boldstyle       = 1, // @emem Stile grassetto
  underlinedstyle = 2, // @emem Stile sttolineato
  italicstyle     = 4  // @emem Stile corsivo
  };

// @enum TPrtype | Indica il tipo di stampante da utilizzare per la stampa
enum TPrtype 
{
  normprinter  = 0, // @emem Stampa su stampante normale
  fileprinter  = 1, // @emem Stampa su file
  spoolprinter = 2, // @emem Stampa utilizzando lo spool
  localprinter = 3, // @emem Stampa su la stampante locale
  screenvis    = 4, // @emem Anteprima a video
  winprinter   = 5, // @emem Stampa su stampante definita da Windows<tm>
  export       = 6  // @emem Esporatzione di stampa
  };

enum TGraphic_shape
{ 
  line,
  box
};


// @class TPrintrow | Classe per la definizione della stampa di una riga
//
// @base public | TObject
class TPrintrow : public TObject

// @author:(INTERNAL) Villa

// @access Private Member
{
  // @ccost MAXSTR | 256 | Lunghezza massima della riga da stampare
  enum { MAXSTR = 256 };

  // @cmember Stringa da stampare nella riga
  TString256 _row;
  // @cmember Attributi carattere dei caratteri
  char _attr[MAXSTR];
  // @cmember Attributi colore dei caratteri
  int _cols[MAXSTR];
  // @cmember Inizio delle nuove posizioni di tabulazione
  TBit_array _tab;

  // @cmember Attributo carattere corrente
  TPrintstyle _currentstyle;
  // @cmember Attributo colore corrente
  int _currentcolor;
  // @cmember Ultima posizione di stampa
  int _lastpos;

  // @access Public Member
public:
  // @cmember Costruttore
  TPrintrow();
  // @cmember Costruttore
  TPrintrow(const TPrintrow& pr);
  // @cmember Distruttore
  virtual ~TPrintrow() 
  {}

  //  TPrintrow& center(const char* str, int position);
  // @cmember Ritorna l'identificatore della classe
  virtual word class_id() const;
  // @cmember Ritorna il nome della classe
  virtual const char* class_name() const;
  // @cmember Duplica una riga (vedi <mf TObject::dup>)
  virtual TObject* dup() const;

  // @cmember Ritorna la stringa da stampare nella riga
  const char* row() const 
  { return _row; }
  // @cmember Ritorna la riga con i codici '@' per lo stile  ed il colore del font
  const char* row_codified() const;
  // @cmember Svuota la riga
  TPrintrow& reset();

  // @cmember Ritorna lo stile del carattere <p position>-esimo (vedi <t TPrintstyle>)
  TPrintstyle get_style(int position) const 
  { return (TPrintstyle)_attr[position]; }
  // @cmember Ritorna l'attributo carattere corrente
  TPrintstyle get_style() const
  { return _currentstyle; }
  // @cmember Ritorna il colore del carattere <p position>-esimo
  int get_color(int position) const 
  { return (TPrintstyle)_cols[position]; }
  // @cmember Ritorna l'attributo colore corrente
  int get_color() const 
  { return _currentcolor; }
  // @cmember Scrive una stringa (!!!-1=tab)
  TPrintrow& put(const char* str, int position = -1, int len=0);
  // @cmember Setta l'attributo carattere corrente (vedi <t TPrintstyle>)
  void set_style(TPrintstyle style)  
  { _currentstyle=style; }
  // @cmember Ritorna l'ultima posizione di stampa
  int  lastpos() const 
  { return _lastpos; }
};

// @class PrinterDef | Classe per la definizione delle stampanti da utilizzare
//
// @base public | TObject
class PrinterDef : public TObject

// @author:(INTERNAL) Villa

// @access Private Member
{
  // @cfriend TPrinter
  friend class TPrinter;

  // @cmember Nome del file della stampante
  TString _printername;
  // @cmember Tipo di stampante da utilizzare (0=diretta,1=locale,2=spool)
  TString _printertype;
  // @cmember Filtro p<>er la pipe '<pipe>' (solo per unix
  TString _filtername;
  // @cmember Nome del device di stampa
  TString _devicename;
  // @cmember Codici attributo per la stampante corrente
  char _atstr[4][10];
  // @cmember Codici di stampa
  TString_array _codes;
  // @cmember Nome dei codici di stampa
  TString_array _names;
  // @cmember Codice del formfeed per la stampante corrente
  TString _ffcode;
  // @cmember Codice del new line per la stampante corrente
  TString _nlcode;

  // @access Public Member
public:
  // @cmember Legge la descrizione della stampante dal file
  bool read(const char* name, FILE* fd);
  // @cmember Controlla se il nome del file della stampante e' "Default"
  bool isdefault();
  // @cmember Ritorna l'<p i>-esimo nome del codice di stampa
  const char* get_codenames(word i) const
  { return  i < (word)_names.items() ? (const char*)_names.row(i) : NULL; }
  // @cmember Ritorna l'<p i>-esimo codice di stampa
  const char* get_codes(word i) const 
  { return  i < (word)_codes.items() ? (const char*)_codes.row(i) : NULL; }
  // @cmember Costruttore
  PrinterDef() : _printername(10), _filtername(10), _ffcode("\f"), _nlcode("\n") 
  {}
};

// @class BkDef | Classe per la definizione dei bookmark in anteprima di stampa
//
// @base public | TObject
class BkDef : public TObject

// @author:(INTERNAL) Villa   

// @comm Questo oggetto e' in grado di costrutire l'intero menu' gerarchico dei bookmark
{

  // @access Public Member
public:
  // @cmember Identificatore del bookmark creato
  int _id;
  // @cmember Identificatore del bookmark padre
  int _father_id;
  // @cmember Testo del bookmark
  TString _txt;
  // @cmember Numero della riga sulla quale e' inserito il bookmark
  long _row;
  
  // @cmember Costruttore
  BkDef() 
  {}
  // @cmember Distruttore
  virtual ~BkDef() 
  {}
};


class TPrinter;
class TPrint_intersector;

// @type PRINTSECTIONHANDLER | Funzione definita dall'utente chiamata all'inizio della stampa
//                           dell'header o del footer
typedef void (*PRINTSECTIONHANDLER)(TPrinter& printer);
// @type LINKHANDLER | Funzione definita dall'utente per la gestione del link
typedef void (*LINKHANDLER)(int, const char*);



class TViswin;               

// @class TPrinter | Classe per la definzione delle operazioni sulla stampante
//
// @base public | TObject
class TPrinter : public TObject
// @author:(INTERNAL) Villa

// @access Private Member
{
  // @cmember Puntatore al file di configurazione
  FILE* _cnfptr;
  // @cmember Puntatore al file della stampante
  FILE* _fp;
  // @cmember Puntatore al file di visualizzaizone
  TViswin* _vf;

  // @cmember Testo da stampare
  TTextfile _txt;
  // @cmember Nome del file di esportazione
  TFilename _exportfile;
  // @cmember Dimensione dell'header
  int _headersize;
  // @cmember Dimensione del footer
  int _footersize;
  // @cmember Contenuto dell'header
  TArray _header;
  // @cmember Contenuto del footer
  TArray _footer;
  // @cmember Descrizione delle stampanti
  TArray _printers;
  // @cmember Indice corrente della stampante
  int _curprn;
  // @cmember Codice corrente della stampante
  int _curcode;
  // @cmember Lunghezza della pagina logica
  int _formlen;
  // @cmember Larghezza della pagina logica
  int _formwidth;
  // @cmember Prossima riga da stampare
  int _currentrow;

  // @cmember Nome del font per la stampa
  TString80 _fontname;
  // @cmember Dimensione del font per la stampa
  int _ch_size;

  // @cmember Pagina logica contenente la prossima riga da stampare
  word _currentpage;
  // @cmember Prima pagina da stampare (normalmente 0)
  word _frompage;
  // @cmember Ultima pagina da stampare (normalmente USHRT_MAX)
  word _topage;
  // @cmember Indica la stampa di un form feed dopo ogni footer
  bool _hwformfeed;
  // @cmember Indica il tipo di output selezionato dall'utente per la stampa
  TPrtype _printertype;
  // @cmember Indica se la stampante e' inizializzata
  bool _isopen;
  // @cmember Data di stampa
  TDate  _date;
  // @cmember Nome del file per la stampa su disco
  TFilename _printerfile;
  // @cmember Array di nomi dei link
  TArray _linksdescr;
  // @cmember Array di nomi di segnalibri
  TArray _bookmarks;
  // @cmember Indica se e' attivo il link multiplo (vedi <mf TPrint_application::set_multiple_link>)
  bool _multiple_link;
  
  // @cmember Nome del paragrafo di configurazione
  TString _config;

  // @cmember Array di stringhe per la desccrizione del background
  TString_array _background;     
  // @cmember Nomi dei file delle immagini da stampare
  TString_array _image_names;

  // @cmember Stringa contenente i @codes per il disegno dello sfondo
  const char* _bg_desc;
  // @cmember Nomi delle stampanti utilizzabile
  TToken_string _printer_names;
  // @cmember Indica se la stampante e' abilitata a trattare grafica
  bool _isgraphics;
  // @cmember Indica se la stampante e' stata momentaneamente interrotta
  bool _frozen; 
  // @cmember Numero di copie da fare
  int _ncopies;
  // @cmember Descrizione completa dello stato della stampante
  PRINT_RCD* _print_rcd;
  // @cmember Dimensione del record per la descrizione completa dello stato della stampante
  int _print_rcd_size;
  // @cmember Numero di linee per pollice
  int _lines_per_inch;
  // @cmember Offset verticale in pixels
  int _vert_offset;
  // @cmember Offset orizzontale in pixels
  int _horz_offset;
  // @cmember Offset verticale in linee (in caratteri)
  int _l_offset;
  // @cmember Offset orizzontale in colonne (in caratteri)
  int _c_offset;
  // @cmember Definizione dell stampa in punti per linea
  int _dots_per_line;                                     
  
  // @cmember Setta <p t> con il profilo della stampante
  void _get_windows_printer_names(TToken_string& t);
  // @cmember Indica se si tratta di copia multipla
  bool _multiple_copies;
  // @cmember Indica se occorre esportare l'header di stampa
  bool _export_header;                                   
  // @cmember Lunghezza dell'header di stampa da esportare
  int _export_header_len;
  
  // @cmember Handler dell'header
  PRINTSECTIONHANDLER _headerhandler;
  // @cmember Handler del footer
  PRINTSECTIONHANDLER _footerhandler;
  // @cmember Header del link ipertestuale
  LINKHANDLER _linkhandler;   
  
  
  // @cmember caratteri per fincatura
  char _fink[11];
  
  // @cmember fincatore per modo testo
  TPrint_intersector* _finker; 

  
  // @access Protected Member
protected:
  // @cmember Ritorna il carattere di newline
  virtual char newline()
  { return '\n'; }
  // @cmember Metodo base per la stampa
  bool printrow (TPrintrow* rowtoprint=NULL);
  // @cmember Stampa un formfeed (ritorna sempre TRUE)
  bool printformfeed ();
  
  // @cmember Stampa l'header della pagina
  bool printheader();
  // @cmember Stampa il footer della pagina
  bool printfooter();

  // @cmember Salva i parametri di configurazione correnti
  void save_configuration();
  // @cmember Stampa il testo
  void print_txt(TTextfile& txt);

  // @access Public Member
public:

  // @cmember Costruttore
  TPrinter ();
  // @cmember Distruttore
  virtual ~TPrinter();    


#if XVT_OS == XVT_OS_WIN        
  // @cmember Inizia una nuova sessione di stampa. Viene passata alla <mf TPrintwin::do_print>
  static BOOLEAN XVT_CALLCONV1 start_winprint(long);
#endif

  // @cmember Setta il numero della prima pagina da stampare
  void set_from_page (word from)
  { _frompage = from; }
  // @cmember Setta il numero dell'ultima pagina da stampare
  void set_to_page (word to)
  { _topage = to; }
  // @cmember Indica se stampare un formfeed dopo ogni footer
  void set_hwff (bool hwff) 
  { _hwformfeed = hwff; }

  // @cmember Permette di tradurre la stringa con i codici @codes in un array utilizzabile dalla stampa
  void parse_background(const char* bgdesc, TArray& bg);

  // @cmember Ritorna il numero delle stampanti disponibili
  int descriptions() 
  { return _printers.items(); }
  // @cmember Ritorna il nome della <p i>-esima stampante disponibile
  const PrinterDef& get_description(word i) const 
  { return (const PrinterDef&) _printers[i]; }
  
  // @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 lunghezza della pagina logica
  int formlen () const
  { return _formlen; }
  // @cmember Ritorna la larghezza della pagina logica
  int formwidth () const
  { return _formwidth; }

  // @cmember Ritorna il numero della prima pagina da stampare
  word frompage () const
  { return _frompage; }
  // @cmember Ritorna il numero dell'ultima pagina da stampare
  word topage () const
  { return _topage; }
  // @cmember Ritorna la dimensione dell'header
  int headersize () const
  { return _headersize; }
  // @cmember Ritorna la dimensione del footer
  int footersize () const
  { return _footersize; }
  // @cmember Ritorna il contenuto della <p linetoget>-esima linea dell'header
  TPrintrow*  getheaderline (int linetoget);
  // @cmember Ritorna il contenuto della <p linetoget>-esima linea del footer
  TPrintrow*  getfooterline (int linetoget);
  // @cmember Setta la lunghezza della pagina logica da stampare
  int formlen (int fl)
  { return (_formlen=fl); }
  // @cmember Setta la dimensione del footer
  int footerlen (int fl)
  { return (_footersize=fl); }
  // @cmember Setta la dimensione dell'header
  int headerlen (int hl)
  { return (_headersize=hl); }
  // @cmember Setta il numero della prima pagina da stampare
  word frompage (word fp)
  { return (_frompage=fp);}
  // @cmember Setta il numero dell'ultima pagina da stampare
  word topage (word tp)
  { return (_topage=tp); }
  // @cmember Setta il contenuto di una line dell'header
  void setheaderline (int linetoset, TPrintrow* line);
  // @cmember Setta il contenuto di una line dell'header passata per indirizzo
  void setheaderline (int linetoset, const TPrintrow& line);
  // @cmember Setta il contenuto di una line del footer
  void setfooterline (int linetoset, TPrintrow* line);
  // @cmember Setta il contenuto di una line del footer passata per indirizzo
  void setfooterline (int linetoset, const TPrintrow& line);
  // @cmember Elimina il contenuto dell'header
  void resetheader();
  // @cmember Elimina il contenuto del footer
  void resetfooter();                                    
  // @cmember Setta il colore del background
  void setbackground(const char* bg);     
  // @cmember Ritorna l'array con i nomi delle immagini da stampare!!!
  TString_array& image_names()   
  { return _image_names; }
  // @cmember Ritorna l'array con i nomi dei colori da stampare!!!
  TString_array& getbgdesc()
  { return _background; }
  // @cmember Ritorna l'array con i segalibri settati
  TArray& get_bookmarks()
  { return _bookmarks;  }
  // @cmember Ritorna se la stampante e' stata momentaneamente interrotta
  bool frozen() 
  { return _frozen; } 
  // @cmember Setta l'interruzione momentanea della stampante
  void freeze(bool b = TRUE)
  { _frozen = b; }
  // @cmember Ritorna il numero delle copie da stampare
  int n_copies() { return _ncopies; }
  // @cmember Abilita/disabilita la copia multipla!!!
  void enable_multiple_copies(bool b = TRUE) 
  { _multiple_copies = b; }
  
  // @cmember Ritorna il nome delle stampanti utilizzabili
  TToken_string& getprinternames();
  // @cmember Ritorna il testo da stampare
  TTextfile& get_txt()
  { return _txt; }
  
  // @cmember Setta l'handle dell'header
  void setheaderhandler(PRINTSECTIONHANDLER h)
  { _headerhandler = h; }
  // @cmember Setta l'handle del footer
  void setfooterhandler(PRINTSECTIONHANDLER h)
  { _footerhandler = h; }

  // sono qui e non nella printapp per poter usare una viswin
  // completamente anche da un'altra application
  // @cmember Setta l'header del link (usata dalla <c TViswin>)
  void setlinkhandler(LINKHANDLER h)
  { _linkhandler   = h; }
  // @cmember Ritorna l'header del link
  LINKHANDLER getlinkhandler() 
  { return _linkhandler; }
  // @cmember Ritorna l'array con i nomi dei link
  TArray& links() 
  { return _linksdescr; }
  // @cmember Abilita/disabilita il link multiplo
  void setmultiplelink(bool on) 
  { _multiple_link = on;   }
  // @cmember Indica se attivato il link multiplo
  bool ismultiplelink()
  { return _multiple_link; }

  const char* get_fincatura() { return _fink; }
  void set_fincatura(const char* s) { strncpy(_fink, s, sizeof(_fink)); }
  
  // caratteri fincazione                                              
  char f_topleft()      const { return _fink[0];  }                                              
  char f_topmiddle()    const { return _fink[1];  }                                              
  char f_topright()     const { return _fink[2];  }                                              
  char f_botleft()      const { return _fink[3];  }                                              
  char f_botmiddle()    const { return _fink[4];  }                                              
  char f_botright()     const { return _fink[5];  }                                              
  char f_centerleft()   const { return _fink[6];  }                                              
  char f_centermiddle() const { return _fink[7];  }                                              
  char f_centerright()  const { return _fink[8];  }                                              
  char f_horizontal()   const { return _fink[9];  }                                              
  char f_vertical()     const { return _fink[10]; }                                              
  

  // @cmember Permette di saltare alcune righe dalla posizione corrente 
  bool skip (int linetoskip);
  // @cmember Permette di saltare alla riga indicata
  bool jump (int linestojump);
  // @cmember Resetta la stampa eliminando header e footer correnti e riportando i valori di
  //          pagina corrente e riga corrente a 1
  void reset ();
  // @cmember Permette di settare i parametri di stampa tramite la maschera bagn001a
  virtual bool set ();
  // @cmember Apre un processo di stampa
  bool open ();
  // @cmember Chiude un processo di stampa
  void close ();
  // @cmember Stampa un formfeed.
  bool formfeed ();
  // @cmember Permette di stampare una riga
  bool print (TPrintrow& rowtoprint);
  // @cmember Ritorna se la stampante e' stat inizializzata
  bool isopen()
  { return _isopen; }
  // @cmember Permette di settare la data di stampa
  void setdate(const TDate& d)
  { _date = d; }
  // @cmember Ritorna la data di stampa
  const TDate& getdate() const 
  { return _date; }
  // @cmember Ritorna il tipo di output selezionato dall'utente per la stampa
  TPrtype printtype()
  { return _printertype; }
  // @cmember Setta il tipo di output selezionato dall'utente per la stampa
  void set_printtype(TPrtype dest)
  { _printertype=dest; }
  // @cmember Setta il nome del file per la stampa su disco
  void set_printerfile(const char * ffile)
  { _printerfile=ffile; }
  // @cmember Ritorna il numero della pagina logica da stampare
  word getcurrentpage() const 
  { return _currentpage; }
  // @cmember Setta il numero della pagina logica da stampare
  void setcurrentpage(word n) 
  { _currentpage = n; }  
  // @cmember Dirige la stampa sul file specificato, preservando gli attributi di formato.
  //          Se <p header> = TRUE si stampano su file anche gli header    
  void set_export_file(const char* n, bool header = TRUE, int len = 0) 
  { _printertype = export; _exportfile = n; _export_header = header; _export_header_len = len;}
  // @cmember Inserisce un file di export fatto da un'altra printer
  void merge_export_file(const char* file, bool header = TRUE);
  // @cmember Ritorna il numero di righe disponibili poer la stampa
  word rows() const 
  { return _formlen-_headersize-_footersize; }
  // @cmember Ritorna il numero di righe che rimangono a disposizione per la stampa
  word rows_left() const;                                   
  // @cmember Setta il record per la descrizione dello stato dell stampante
  void set_printrcd();
  // @cmember Ritorna il record per la descrizione dello stato dell stampante
  PRINT_RCD* get_printrcd(int* size = NULL);
#if XVT_OS == XVT_OS_WIN
  // @cmember Setta le caratteristiche della stampante leggendole da <p _print_rcd>
  void set_win_formlen(WINDOW prwin = NULL_WIN);  
#endif
  // @cmember Setta la definizione della stampante in linee per pollice
  void set_lines_per_inch(int n)  
  { _lines_per_inch = n; }
  // @cmember Ritorna la definizione della stampante in linee per pollice
  int get_lines_per_inch() const 
  { return _lines_per_inch; }
  // @cmember Ritorna l'offset verticale
  int get_vert_offset() const 
  { return _vert_offset; }
  // @cmember Ritorna l'offset orizzontale
  int get_horz_offset() const 
  { return _horz_offset; }
  // @cmember Ritorna l'offset verticale in caratteri (linee)
  int get_line_offset() const 
  { return _l_offset; }
  // @cmember Ritorna l'offset orizzontale in caratteri (colonne)
  int get_column_offset() const 
  { return _c_offset; }
  // @cmember Ritorna la definizione di stampa in punti per linea
  int get_dots_per_line() const { return _dots_per_line; }
  // @cmember Ritorna se la stampante e' abilitata a stampare grafica
  bool isgraphics() const { return _isgraphics; }
  // @cmember Setta la stampante per l'abilitazione a stampare in grafica
  void set_graphics(bool g) { _isgraphics=g; }
  // @cmember Setta l'offset verticale e orizzontale in caratteri
  void set_offset(int a, int b) { _l_offset=a; _c_offset=b;}
  // @cmember ritorna la riga di background se si stampa in modo testo
  const char* background_chars(int l) const;
   
  // @cmember Ritorna la dimensione dei caratteri da stampare 
  int get_char_size() const
  { return _ch_size; }
  // @cmember Ritorna il nome del font di stampa
  char* fontname() const 
  { return (char*)(const char*)_fontname; }
  
  // @cmember Setta la dimensione dei caratteri da stampare 
  void set_char_size(int size)  
  { _ch_size = size; }
  // @cmember Setta il nome del font di stampa
  void set_fontname(const char *name) 
  { _fontname = name; }
  
  // @cmember Legge la configurazione della stampante
  void read_configuration(const char* parag = NULL);

  // @cmember Crea un segnalibro
  int set_bookmark(const char* txt, int father = -1);

  // @cmember Ritorna vero se la stampante e' generica/solo testo
  bool is_generic() { return (_dots_per_line == 1); }
};


// @class TFile_printer | Classe per la definizione delle operazini per la stampa su file
//
// @base public | TPrinter
class TFile_printer : public TPrinter
// @author:(INTERNAL) Nicola

// @access Private Member
{
  // @cmember Dimensione del file
  long _size;
  // @cmember Disco al quale appertiene il file
  const char * _drive;
  // @cmember Numero progressivo volume
  int _volume;
  // @cmember Numero di record per disco
  int _num_rec_volume;
  // @cmember Numero di record per inizio e fine volume
  int _num_rec_testa_coda;  
  // @cmember Numero di record per inizio volume
  int _num_rec_inizio;
  // @cmember Numero di record per coda volume
  int _num_rec_fine;
  // @cmember Lunghezza del record
  int _len_rec;
  // @cmember Array di tipi record
  TArray _record;
  // @cmember Indica se il file sui dischetti deve avere un nome NON modificabile dall'utente
  bool _nome_file_fissato;  
  // @cmember Indica se l'etichetta dei dischetti deve essere fissa
  bool _label_fissata;
  // @cmember Indica se il disco deve essere formattato prima di fare la stampa
  bool _formatta;
  // @cmember File da generare sui dischetti
  const char* _file;
  // @cmember Etichetta da scrivere sui dischetti
  const char* _label;
  // @cmember Array dei file temporanei generati
  TArray  _tmp_files;
  // @cmember Puntatore al file creato
  FILE* _fd;

  //  bool scrivi_volume();

  // @access Public Member
public:
  // @cmember Ritorna il nalore di una newline
  virtual char newline() 
  { return '\0'; }
  // @cmember Setta se il file sui dischetti deve avere un nome NON modificabile dall'utente
  void set_file_fissato (bool fissato) 
  { _nome_file_fissato = fissato; }
  // @cmember Setta se l'etichetta dei dischetti deve essere fissa
  void set_label_fissata (bool fissata) 
  { _label_fissata = fissata; }
  // @cmember Setta la lunghezza del record
  void set_len_rec (int len) 
  { _len_rec = len; }

  // @cmember Setta il file da generare sui dischetti
  void set_file (const char * ffile) 
  { _file = ffile; }
  // @cmember Setta l'etichetta da scrivere sui dischetti
  void set_label (const char * label) 
  { _label = label; }

  // @cmember Aggiunge un array di tipo record alla posizione <p line>
  void set_record (int record_to_set, TPrintrow* line) 
  {_record.add(line, record_to_set); }

  // @cmember Ritorna l'array di tipo record della posizione <p line>
  TPrintrow * get_record (int record_to_get) 
  {return (TPrintrow *)&_record[record_to_get]; }

  // @cmember Ritorna il record di inizio volume
  TPrintrow* get_record_inizio_volume() const 
  { return (TPrintrow*)&_record[0];}
  // @cmember Ritorna il record di inizio elenco
  TPrintrow* get_record_inizio_elenco() const 
  {return (TPrintrow*)&_record[1];}
  // @cmember Ritorna il record del dettaglio
  TPrintrow* get_record_dettaglio() const 
  { return (TPrintrow*)&_record[2]; }
  // @cmember Ritorna il record di fine elenco
  TPrintrow* get_record_fine_elenco() const 
  {return (TPrintrow*)&_record[3]; }
  // @cmember Ritorna il record di fine volume
  TPrintrow* get_record_fine_volume() const 
  { return (TPrintrow*)&_record[4]; }
  // @cmember Ritorna ???
  TPrintrow* get_record_filler() const 
  { return (TPrintrow*)&_record[5]; }

  // @cmember Ritorna il numero di record per disco
  int  num_rec_volume () 
  { return _num_rec_volume; }
  // @cmember Ritorna il numero progressivo volume
  int  num_volumi () 
  { return _volume; }
  // @cmember Incremente il numero progressivo volume
  void inc_volume () 
  { _volume++; }

  // @cmember Aggiunge il nome di un file temporaneo
  void add_file (TFilename nomef) 
  { _tmp_files.add(nomef); }

  // @cmember Apre il file
  void open();
  // @cmember Chiude il file
  void close();

  //  void scrivi();
  // @cmember Genera i dischetti
  bool genera_dischetti();

  // @cmember Setta i parametri di stampa su disco
  virtual bool set ();

  //
  // tipo_disco: 
  //              0 per 360
  //              1 per 1.2
  //              2 per 720
  //              3 per 1,44
  //              4 per 2,88
  
  // @cmember Costruttore
  TFile_printer (const char* file, const char* label, int len_rec, int num_rec_inizio = 1, int num_rec_fine = 1, int tipo_disco=0);
  // @cmember Distruttore
  virtual ~TFile_printer();
};

// @func Ritorna la stampante corrente
//
// @rdesc Ritorna l'identificatore della stamapnte corrente
TPrinter& printer();
// @func Distrugge la stampante corrente
void printer_destroy();


#endif  // __PRINTER_H