campo-sirio/include/progind.h

#ifndef __PROGIND_H
#define __PROGIND_H 

#ifdef __cplusplus

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

#ifndef __CONTROLS_H
class TControl;
class TField_control;
#endif 

// @doc EXTERNAL

// @class TIndwin | Classe base per la gestione delle finestre con le barre di attesa   
// 
// @base public | TWindow
class TIndwin : public TWindow 
// @author:(INTERNAL) Villa
{
  // @access:(INTERNAL) Private Member
  
  enum { 
    // @ccost:(INTERNAL) IND_CANCELLED | 0x01 | Controlla se e' stato premuto il tasto "Annulla"
    IND_CANCELLED = 0x01,
    // @ccost:(INTERNAL) IND_FINISHED | 0x02 | Controlla se l'operazione e' terminata
    IND_FINISHED= 0x02 }; 

  TString_array _text;
  short _bar_top;
  bool _can_cancel;

  // @cmember:(INTERNAL) Movimento della barra e percentuale
  WINDOW _gauge;
  // @cmember:(INTERNAL) ora inizio elaborazione
  clock_t _start_time;

  // @cmember:(INTERNAL) Flag che indica quali operazioni sono state effettuate
  byte _flags;  

  // @access Protected Member
protected:
  // @cmember Massimo valore da ricercare
  long _max;
  // @cmember Stato corrente dell'esecuzione (settato dell'utente)
  long _status;  
  // @cmember Ritorna il numero di linee necessarie per scrivere il testo nella finestra
  word measure_text(TToken_string& t, word& len) const;

  // @cmember Calcola il rettangolo della barra di attesa
  virtual void get_bar_rct(RCT& r) const;
  // @cmember Calcola il rettangolo del testo
  virtual void get_txt_rct(RCT& r) const;

  // @cmember converte secondi in una stringa nel formato hh:mm:ss
  void sec2str(unsigned long ss, TString& str) const;

  // @cmember Gestisce gli eventi tasto della finestra
  virtual bool on_key(KEY k);
  virtual bool stop_run(KEY k);
  
  // @cmember Aggiorna la barra di attesa (chiama update_bar)
  virtual void update();
  
  // @cmember Aggiorna la barra di attesa            
  virtual void update_bar();
  virtual void update_txt();

  // @cmember Controlla se ha terminato la barra di attesa
  KEY check_stop();

  // @access Public Member
public:
  // @cmember Controlla se e' stato premuto il tasto "Annulla"
  bool iscancelled() const { return (_flags & IND_CANCELLED) != 0; }
  // @cmember Controlla se e' finito l'operazione
  bool isfinished() const { return (_flags & IND_FINISHED) != 0;  }
  // @cmember Ritorna lo stato dell'operazione (quantita' dell'applicazione gia' fatta)
  long status() const { return _status; }
  // @cmember Ferma l'operazione (chiude la finestra)
  void cancel()
  { _flags |= IND_CANCELLED; do_events(); check_stop(); }
  
  // @cmember Controlla se l'operazione puo' essere chiusa
  virtual bool can_be_closed() const;

  // @cmember Setta il testo della finestra
  void set_text(const char* t);

  // @cmember Setta il valore massimo della barra d'attesa
  void setmax(long m);

  virtual bool setstatus(long l);

  // @cmember Forza il timer d'inizio (serve solo a TProgress_monitor)
  void set_start_time(unsigned long st) { _start_time = st; }

  // @cmember Costruttore
  TIndwin(long max, const char* txt, bool cancel = TRUE, bool bar = TRUE, int div = 60);
  // @cmember Distruttore
  virtual ~TIndwin();
};

// @doc EXTERNAL

// @class TProgind | Classe per la gestione della barra di attesa di una applicazione
//
// @base public | TIndwin
class TProgind : public TIndwin
// @author:(INTERNAL) Villa
{
  clock_t _next_update;

  // @access Public Member
public:
  // @cmember Setta lo stato della barra d'attesa
  virtual bool setstatus(long l);
  // @cmember Aggiorna la barra d'attesa aggiungendo l'incremento fatto dell'applicazione
  bool addstatus(long l)
  { return setstatus(_status+l); }
  // @cmember Costruttore
  TProgind(long max, const char* txt = NULL, bool cancel = TRUE, bool bar = TRUE, int div = 60);
  // @cmember Distruttore
  virtual ~TProgind() 
  {}
};

// @doc EXTERNAL

// @class TTimerind | Classe per la definizione di una barra d'attesa gestita
//                      dal tempo e non dallo stato dell'applicazione
//
// @base public | TIndwin
class TTimerind : public TIndwin
// @author:(INTERNAL) Villa
{
  // @access:(INTERNAL) Private Member

  // @cmember:(INTERNAL) Intervallo di tempo
  int _interval;
  // @cmember:(INTERNAL) Indice di tempo
  long _timer_id;

  // @access Protected Member
protected:
  // @cmember Gestisce gli eventi della finestra
  virtual long handler(WINDOW w, EVENT* e);

  // @access Public Member
public:
  // @cmember Costruttore
  TTimerind(long msec, const char* txt = NULL, bool cancel = TRUE, bool bar = TRUE, int div = 10, int interval = 1000);
  // @cmember Distruttore
  virtual ~TTimerind();
};

// @doc EXTERNAL

// @class TProgress_monitor | Classe per gestire intelligentemente clessidra o barra di attesa
//
// @base public | TObject
class TProgress_monitor : public TObject
{
  long _total, _status;
  TString _txt;
  bool _cancellable;
  TProgind* _pi;
  clock_t _start;

public:
  virtual bool set_status(long n);
  void set_max(long tot);
  bool add_status(long i = 1) { return set_status(_status+i); }
  void set_text(const char* msg);

  // deprecated TProgind compatibility methods
  bool setstatus(long n) { return set_status(n); }
  bool addstatus(long n) { return add_status(n); }

  TProgress_monitor(long items, const char* txt, bool cancellable = true);
  ~TProgress_monitor();
};


#endif

#ifdef __cplusplus
extern "C" {
#endif
  // Non commentate perche' destinate a sparire
  void progind_create(long, const char*, bool, bool);
  bool progind_set_status(long s);
  void progind_cancel();
  bool progind_iscancelled();
  bool progind_isfinished();
  void progind_destroy();

  /* NEVER used stuff!
  void timerind_create(long, const char*, bool, bool, int);
  void timerind_cancel();
  bool timerind_iscancelled();
  bool timerind_isfinished();
  void timerind_destroy();
  */
#ifdef __cplusplus
}
#endif

#endif  /* __PROGIND_H */