campo-sirio/include/progind.cpp

//	$Id: progind.cpp,v 1.1.1.1 1994-08-12 10:52:04 alex Exp $

#include <defmask.h>
#include <progind.h>  

const char* const CANCEL_TEXT = "Annulla";
const char* const TITLE_TEXT  = "Attesa";

// Certified 70%
TIndwin::TIndwin(long max, const char* txt, bool cancel,  bool bar, int div)
{
  _cancel = _bar = _text = NULL_WIN;

  _status = 0l;
  _max = max;
  if (_max <= 0) _max = 1; 
  _flags = 0x0;

  word maxlen = div, lines;
  measure_text(txt, maxlen, lines);
  
  int ver = lines+3;
  
  int hor = maxlen+2; if (hor > 78) hor = 78;
  
  if (bar) 
  {
    _bar = ver * CHARY;
    ver += 3;
  }  
  ver += cancel ? 3 : 0;

  create(-1, -1, hor, ver, TITLE_TEXT);
          
  RCT r; r.left = CHARX; r.top = CHARY; r.right = CHARX*(hor-2); r.bottom = r.top + lines*CHARY+4;        
  _text = create_control(WC_TEXT, &r, (char*)txt, win(), CTL_FLAG_CENTER_JUST, 0l, DLG_NULL);
  
  if (cancel)
    _cancel = xvt_create_control(WC_PUSHBUTTON, -11, -1, 9, 2,
			                           CANCEL_TEXT, win(), 0, 0l, DLG_CANCEL);
  open_modal();
  do_events();
} 

void TIndwin::set_text(const char* t)
{
  set_title(_text, (char*)t);
}

TIndwin::~TIndwin()
{ close_modal(); }


void TIndwin::measure_text(const char* txt, word& maxlen, word& lines) const
{
  TToken_string s(txt, '\n');
  lines = 0;
  for(const char* t = s.get(0); t; t = s.get())
  {
    const word l = strlen(t);
    if (l > maxlen) maxlen = l;
    lines++;
  }
}


KEY TIndwin::check_stop()
{
  KEY k = 0;
  if (_flags & IND_FINISHED || _flags & IND_CANCELLED)
  {        
    k = (_flags & IND_FINISHED) ? K_ENTER : K_ESC;
	  stop_run(k);
	}  
	return k;
}

void TIndwin::update_bar()
{
  if (_status >= _max)
	{
	  _status = _max;
	  _flags |= IND_FINISHED;
	}

  const double prc = (double)_status/_max;
  
  RCT r; get_client_rect(win(), &r);
  r.left = CHARX; r.right -= CHARX;
  r.top = (int)_bar; 
  r.bottom = r.top + 3*CHARY;
#if XVT_OS == XVT_OS_WIN
  r.top += 6;
  r.bottom -= 6;
#endif  
  const int width = r.right - r.left;
  
  RCT b = r;
  set_brush(COLOR_BLUE);
  b.right = b.left + int(width*prc);
  win_draw_rect(win(), &b);

  set_brush(COLOR_WHITE);
  b.left = b.right; b.right = r.right;
  win_draw_rect(win(), &b);
                                 
  set_mode(M_XOR);
  win_set_fore_color(win(), COLOR_BLUE);
  char n[8]; sprintf(n, "%d%%", int(100*prc));                               
  win_draw_text(win(), r.left+width/2-CHARX, (r.bottom+r.top+CHARY)/2-3, n, -1);
  set_mode(M_COPY);
  
  check_stop();
}

void TIndwin::update()
{
  if (_bar) update_bar();
}     


void TIndwin::handler(WINDOW w, EVENT* e)
{
  switch(e->type) 
  {
    case E_UPDATE:
      clear_window(w, COLOR_WHITE);
      update();
      return;
    case E_CONTROL:
      if (e->v.ctl.id == DLG_CANCEL)
	      dispatch_e_char(w, K_ESC);
	    break;
    case E_CHAR:
      // allowed only if cancel button is there
      if (e->v.chr.ch == K_ESC)
      {
        if (_cancel) 
        {
          _flags |= IND_CANCELLED;
          check_stop();
        }  
        else return;
	    } 
      break;
    default:
      break;
  }
  TWindow::handler(w,e);
}


// TProgind --------------------------------------------------------------

TProgind::TProgind(long max, const char* txt, bool cancel, bool bar, int div) 
        : TIndwin(max, txt, cancel, bar, div)
{}

// TTimerind ------------------------------------------------------------

long TTimerind::_timer_id = 0L;

void TTimerind::handler(WINDOW w, EVENT* e)
{
  switch(e->type)
  {
    case E_CREATE:
    case E_UPDATE:
      if (_status == 0L)
	      _timer_id = set_timer(w, _interval);
      break;
    case E_TIMER:
      if (e->v.timer.id == _timer_id)
	    {
	      _status += _interval;
	      force_update();
	      set_timer(w, _interval);
	    }
      break;
    default:
      break;
  }
  TIndwin::handler(w,e);
}

TTimerind::TTimerind(long msec, const char* txt,
		     bool cancel, bool bar, int div, int i) :
		     TIndwin(msec, txt, cancel, bar, div)
{
  _interval = i;
  _timer_id = 0L;
}

TTimerind::~TTimerind()
{ kill_timer(_timer_id); }

// C-style binding
// uses static pointer for single instance of TIndwin

static TIndwin* __indwin__p = NULL;

void progind_create(long m, char* t, bool b, bool c, int n)
{ 
  CHECK(__indwin__p == NULL, "Cannot have more than one progress indicator");
  __indwin__p = new TProgind(m,t,b,c,n);
}

void progind_set_status(long l)
{
  ((TProgind*)__indwin__p)->setstatus(l);
}

void progind_cancel()
{
  __indwin__p->cancel();
}

bool  progind_iscancelled()
{
  return __indwin__p->iscancelled();
}

bool  progind_isfinished()
{
  return __indwin__p->isfinished();
}

void progind_destroy()
{
  delete __indwin__p;
  __indwin__p = NULL;
}

void timerind_create(long l, char* title, bool bar, bool cancel,
		     int divisions, int interval)
{
  CHECK(__indwin__p == NULL, "Cannot have more than one progress indicator");
  __indwin__p = new TTimerind(l,title,bar,cancel,divisions,interval);
}

void timerind_cancel()
{
  __indwin__p->cancel();
}

bool  timerind_iscancelled()
{
  return __indwin__p->iscancelled();
}

bool  timerind_isfinished()
{
  return __indwin__p->isfinished();
}

void timerind_destroy()
{
  delete __indwin__p;
  __indwin__p = NULL;
}