campo-sirio/ci/cilib.cpp

#include <colors.h>
#include <diction.h>
#include <image.h>

#include "cilib.h"
#include "RILORE.h"
#include "cimsk.h"

///////////////////////////////////////////////////////////
// TAlmanac_window
///////////////////////////////////////////////////////////

// @doc EXTERNAL

// @class TAlmanac_window | Finestra associata ad un TAlmanac_field
//
// @base public | TField_window
class TAlmanac_window : public TField_window
{
  // @author:(INTERNAL) Brugno

  // @access Protected Member
protected:
  // override da TField_window
  virtual void update();
  // override da TField_window
  virtual long handler(WINDOW win, EVENT* ep);

  // @access Public Member
public:
  // override da TField_window
  virtual bool on_key(KEY k);

  // @access Public Member
public:
  // @cmember Costruttore
  TAlmanac_window(int x, int y, int dx, int dy, WINDOW parent, TWindowed_field *owner);
  // @cmember Distruttore
  virtual ~TAlmanac_window() {}
};

void TAlmanac_window::update()
{
  COLOR col_f, col_b;
  RCT rct; xvt_vobj_get_client_rect(win(), &rct);
  RCT rcttd;
  TString str;
	TAlmanac_field& o = (TAlmanac_field&)owner();

  TField_window::update();
  TDate cdate = o.selected_date();
  cdate.set_day(1);

  int cpage = o.mask().curr_page();

  int rct_l, rct_t;
  int rct_w = (rct.right - rct.left) / 9;
  int rct_h = (rct.bottom - rct.top) / 9;
  int pad = o.padding();
  int row = 3;

  set_font("", XVT_FS_BOLD);
  set_color(NORMAL_COLOR, NORMAL_BACK_COLOR);
  int fh = CHARY;

  if (o.show_month_name())
  {
    str.format("%s %d", itom(cdate.month()),cdate.year());
    rct_l = rct.left + rct_w;
    rct_t = rct.top + rct_h;
    xvt_dwin_draw_text(win(), rct_l + pad + 2, fh + rct_t + pad + 2, str, -1);
  }

  for (int i=1;i<=7;i++)
  {
    str.format("%.3s", itow(i));
    rct_l = rct.left + rct_w*i;
    rct_t = rct.top + rct_h*2;
    xvt_dwin_draw_text(win(), rct_l + pad + 2, fh + rct_t + pad + 2, str, -1);
  }

  --cdate;

  do
  {
    if ((++cdate).wday()==1 && cdate.day() > 1) row++;

		col_b = NORMAL_BACK_COLOR;
    col_f=NORMAL_COLOR;

		if (o.is_date_void(cpage, cdate))
		{
			if (!o.can_insert(cdate))
				col_b = DISABLED_BACK_COLOR;
		}
    else
      col_b = FOCUS_BACK_COLOR;

    set_pen(col_f);
    set_brush(col_b);

    rct_l = rct.left + rct_w*cdate.wday();
    rct_t = rct.top + rct_h*row;
    
    str.format("%2d", cdate.day());

    rcttd.top = rct_t + pad;
    rcttd.left = rct_l + pad;
    rcttd.bottom = rct_t + rct_h - pad;
    rcttd.right = rct_l + rct_w - pad;

    xvt_dwin_draw_rect(win(), &rcttd);
		if (cdate.is_holiday())
		{
			set_brush(o.can_insert(cdate) ? DISABLED_BACK_COLOR : NORMAL_COLOR, PAT_FDIAG);
	    xvt_dwin_draw_rect(win(), &rcttd);
		}

    if (o.is_selected(cdate.day()))
    {
      set_pen(FOCUS_COLOR,1);
      rcttd.top++; rcttd.left++; rcttd.bottom--; rcttd.right--;
      xvt_dwin_draw_rect(win(), &rcttd);
    }

    xvt_dwin_draw_text(win(), rct_l + pad + 2, fh + rct_t + pad, str, -1);
  }
  while (!cdate.is_end_month());
}

bool TAlmanac_window::on_key(KEY key)
{
	TAlmanac_field& o = (TAlmanac_field&)owner();
  TAlmanac_mask& m = (TAlmanac_mask&)o.mask();

  const int smonth = o.selected_month();
  const int syear = o.selected_year();

  switch (key)
	{
	case K_RIGHT:	o.move_selected_day(1); break;
	case K_LEFT:  o.move_selected_day(-1); break;
	case K_UP:		o.move_selected_day(-7); break;
	case K_DOWN:	o.move_selected_day(+7); break;
  case K_SPACE:
	case K_ENTER:	m.open_day_mask(); break;
	case K_PREV:
	case K_NEXT:
	case K_CTRL+K_F1:
	case K_CTRL+K_F2:
	case K_CTRL+K_F3:
	case K_CTRL+K_F4:
	case K_CTRL+K_F5:
	case K_CTRL+K_F6:
	case K_CTRL+K_F7:
	case K_CTRL+K_F8:
	case K_CTRL+K_F9:
	case K_CTRL+K_F10:
	case K_CTRL+K_F11:
	case K_CTRL+K_F12:
		m.on_key(key);
    break;
	default:
		return TField_window::on_key(key);
  }
  
  if(syear != o.selected_year())
  {
    m.set_year(o.selected_year());
  }
	return true;
}

long TAlmanac_window::handler(WINDOW win, EVENT* ep)
{
  switch(ep->type)
  {
  case E_MOUSE_DOWN:
  case E_MOUSE_DBL:
    {
	    TAlmanac_field & o = (TAlmanac_field&)owner();
      TDate cdate = o.selected_date();
      TDate fdate = cdate; fdate.set_day(1);

      RCT rct; xvt_vobj_get_client_rect(win, &rct);
      int rct_w = ((rct.right - rct.left) / 9);
      int rct_h = ((rct.bottom - rct.top) / 9);
      int pnt_c = (ep->v.mouse.where.h) / rct_w;
      int pnt_r = (ep->v.mouse.where.v) / rct_h;
      int delta = 7*pnt_r + pnt_c - (7*(3+cdate.week()-fdate.week()) + cdate.wday());
      o.move_selected_day(delta);
      if (ep->type==E_MOUSE_DBL)
			  ((TAlmanac_mask&)o.mask()).open_day_mask();
    }
    break;
  default:
    break;
  }
  return TField_window::handler(win, ep);
}

TAlmanac_window::TAlmanac_window(int x, int y, int dx, int dy, WINDOW parent, TWindowed_field *owner)
               : TField_window(x, y, dx, dy, parent, owner)
{
	set_scroll_max(0, 0);  // Get rid of that useless scrollbars
}

///////////////////////////////////////////////////////////
// TImage_window
///////////////////////////////////////////////////////////

// @doc EXTERNAL

// @class TAlmanac_window | Finestra associata ad un TAlmanac_field
//
// @base public | TField_window
class TImage_window : public TField_window
{
  // @author:(INTERNAL) Brugno
	int _curr_month;

  // @access Protected Member
protected:
  // override da TField_window
  virtual void update();

  // @access Public Member
public:
  // @cmember Costruttore
  TImage_window(int x, int y, int dx, int dy, WINDOW parent, TWindowed_field *owner);
 // @cmember Distruttore
  virtual ~TImage_window() {}
};

void TImage_window::update()
{
  RCT rct; xvt_vobj_get_client_rect(win(), &rct);
	TAlmanac_field & f = (TAlmanac_field&) owner();
	const int month = f.selected_date().month();

  _curr_month = month;
	clear(MASK_BACK_COLOR);

	TFilename month_img; month_img.format("%2smn%02d.jpg", (const char *) f.mask().source_file().left(2), _curr_month);

	if (month_img.custom_path())
  {                     
		TImage bmp(month_img);
		const double ratiox = (double) (rct.right) / (double) bmp.width();
		const double ratioy = (double) (rct.bottom) / (double) bmp.height();
			
		if (ratiox < ratioy)
		{
			int h = int(bmp.height() * ratiox);

			rct.top = (rct.bottom - h) / 2;
			rct.bottom = rct.top + h;
		}
		else
		{
			int w = int(bmp.width() * ratioy);
			rct.left = (rct.right - w) / 2;
			rct.right = rct.left + w;
		}

		bmp.draw(win(), rct);
  }
}

TImage_window::TImage_window(int x, int y, int dx, int dy, WINDOW parent, TWindowed_field *owner)
             : TField_window(x, y, dx, dy, parent, owner), _curr_month(0)
{
	set_scroll_max(0, 0);  // Get rid of that useless scrollbars
}

///////////////////////////////////////////////////////////
// TAlmanac_field
///////////////////////////////////////////////////////////

TField_window* TAlmanac_field::create_window(int x, int y, int dx, int dy, WINDOW parent)
{
  TAlmanac_window* obj = new TAlmanac_window(x, y, dx, dy, parent, this);
  RCT rct; xvt_vobj_get_outer_rect(obj->win(), &rct);
	const int pad = 6;

	if (rct.left > pad * 4)
	{
		_image = new TImage_window(-1, y, -1, dy, parent, this);
		RCT img_rect; xvt_vobj_get_outer_rect(_image->win(), &img_rect);
		img_rect.right = rct.left - pad;
		img_rect.left = pad;
    xvt_vobj_move(_image->win(), &img_rect);
	}

  return obj;
}

void TAlmanac_field::create(short id, const RCT& rect, WINDOW parent)
{
  int x = rect.left/CHARX, y = rect.top/ROWY;
  int h = (rect.bottom - rect.top)/ROWY, w = (rect.right - rect.left)/CHARX;
  if (x+w > 80)
    x = x + w - mask().columns() - 1;
  TWindowed_field::create(id, x, y, w, h, parent);
}

bool TAlmanac_field::is_date_void(int currpage, const TDate& cdate)
{
	return ((TAlmanac_mask &)mask()).is_date_void(currpage, cdate);
}

void TAlmanac_field::force_update(bool update_image)
{
	win().force_update();
	if (update_image && _image != NULL)
		_image->force_update();
}

void TAlmanac_field::adjust_selected_day()
{
  const int last = TDate::last_day(_selecteddate.month(), _selecteddate.year());
  if (_selecteddate.day() > last)
    _selecteddate.set_day(last);
}

void TAlmanac_field::set_selected_day(int nday)
{ 
  if (nday>=1 && nday<=31 && nday != _selecteddate.day())
	{
    _selecteddate.set_day(nday);
    adjust_selected_day();
		force_update(false); // Dont'update the picture
	}
}

void TAlmanac_field::move_selected_day(int ddays)
{ 
	const int old_month = _selecteddate.month();
  _selecteddate += ddays;
  force_update(old_month != _selecteddate.month()); // Dont'update the picture if needed
}

void TAlmanac_field::set_selected_month(int nmonth)
{ 
  if (nmonth >= 1 && nmonth <= 12 && nmonth != _selecteddate.month())
	{
    _selecteddate.set_month(nmonth);
    adjust_selected_day();
		force_update(true); // Update the picture too
	}
}

void TAlmanac_field::move_selected_month(int dmonths)
{ 
	_selecteddate.addmonth(dmonths);
  force_update(true); // Update the picture too
}

void TAlmanac_field::set_selected_year(int nyear)
{ 
  _selecteddate.set_year(nyear);
  adjust_selected_day();
  force_update(false); // Don't update the picture
}

///////////////////////////////////////////////////////////
// TAlmanac_mask
///////////////////////////////////////////////////////////

TMask_field* TAlmanac_mask::parse_field(TScanner& scanner)
{
  const TString& k = scanner.key();
  if (k.starts_with("AL", true))
  {
    TAlmanac_field* na = new TAlmanac_field(this);
    _almanacs.add(na);
    return na;
  }
  return TAutomask::parse_field(scanner);
}

bool TAlmanac_mask::on_field_event(TOperable_field& o, TField_event e, long jolly)
{
	switch (o.dlg())
	{
	case F_PREVMONTH:
	case F_NEXTMONTH:
		if (e == fe_button)
		{
			TAlmanac_field& al = almanac();
      const int old_year = al.selected_year();
      al.move_selected_month(o.dlg() == F_PREVMONTH ? -1 : +1);
      const int new_year = al.selected_year();
      if (old_year != new_year) // Se cambio anno
			  set_year(new_year);
		}
		break;
  case F_PREVYEAR:
	case F_NEXTYEAR:
		if (e == fe_button)
    {
			TAlmanac_field& al = almanac();
			const int year = al.selected_year();
			set_year(year + (o.dlg() == F_PREVYEAR ? -1 : +1));
    }
		break;    
	default:
		break;
	}     

  return true;
}  

void TAlmanac_mask::set_focus()
{
  TAutomask::set_focus();

  int i;
  for (i = _almanacs.last(); i >= 0; i = _almanacs.pred(i))
  {
    if (almanac(i).parent() == curr_win())
      break;
  }
  
  const bool nav = i >= 0;
  enable(F_PREVYEAR,  nav);
  enable(F_PREVMONTH, nav);
  enable(F_NEXTMONTH, nav);
  enable(F_NEXTYEAR,  nav);
}

int TAlmanac_mask::activate_almanac(const short id, const char* title)
{
  int i = -1; // Calendario non trovato

  const int pos = id2pos(id);
  if (pos >= 0) // Calendario esistente
  {
    for (i = _almanacs.last(); i >= 0; i = _almanacs.pred(i))
      if (almanac(i).dlg() == id)
        break;
    if (i < 0)                     // Calendario non ancora censito ...
      i = _almanacs.add(fld(pos)); // ... non dovrebbe mai succedere
  }

  if (i < 0) // Devo creare al volo un calendario 
  {
    WINDOW parent = create_page(TR("Calendario"), -1);
    const TAlmanac_field& ca = almanac(0);
    RCT rect; ca.get_rect(rect);
    TAlmanac_field* na = new TAlmanac_field(this);
    na->create(id, rect, parent);
    add_field(na);
    i = _almanacs.add(na);
  }
  
  TAlmanac_field& na = almanac(i);
  if (title && *title)
  {
    const int page = find_parent_page(na);
    xvt_notebk_set_tab_title(notebook(), page, title);
  }
  const TDate sdate(TODAY); // Inizilizzo con la data odierna
  na.set_selected_date(sdate);

  return i;
}

TAlmanac_field & TAlmanac_mask::almanac(byte page) const
{ 
	if (page >= _almanacs.items()) // Calcolo dell'indice del calendario corrente
  {
    for (page = _almanacs.last(); page > 0; page = _almanacs.pred(page))
    {
      if (almanac(page).parent() == curr_win())
        break;
    }
  }
	return (TAlmanac_field&)_almanacs[page];
} 

void TAlmanac_mask::set_year(int newyear) 
{ 
  for (int i = _almanacs.last(); i >= 0; i = _almanacs.pred(i)) 
    almanac(i).set_selected_year(newyear); 
  change_year(newyear);
}

const TDate& TAlmanac_mask::selected_day() const 
{ return almanac().selected_date(); }

void TAlmanac_mask::change_year(int newyear) 
{ 
  // Funzione virtuale da ridefinire!
}

bool TAlmanac_mask::is_date_void(int currpage, const TDate& cdate) 
{ 
  return true;
}

TAlmanac_mask::TAlmanac_mask(const char* name)
{
	read_mask(name, 0, -1); // Deve funzionare la virtual parse_field 
	set_handlers();
}

                                ////////////////////////////
                                ////    TRISOATT_KEY    ////
                                ////////////////////////////

//TIPO: metodo che restituisce il tipo (<R>isorsa o <A>ttrezzatura)
const char TRisoatt_key::tipo() const
{
  return left(1)[0];
}

//COD: metodo che restituisce il codice della risorsa op dell'attrezzatura
const TString& TRisoatt_key::cod() const
{
  return mid(1, 16);
}

//ANNO: metodo che restituisce l'anno a cui fa riferimento la risorsa o l'attrezzatura
const int TRisoatt_key::anno() const
{
  return atoi(mid(17, 4));
}

//MESE: metodo che restituisce il mese a cui fa riferimento la risorsa o l'attrezzatura
const TString& TRisoatt_key::mese() const
{
  return mid(21, 2);
}

//TPORA: metodo che restituisce il tipo dell'ora a cui fa riferimento la risorsa o l'attrezzatura
const TString& TRisoatt_key::tpora() const
{
  return right(2);
}

TRisoatt_key::TRisoatt_key(const char risoatt, const char* codice, const int anno, const char* mese, const char* tpora)
{
   TString16 cod = codice; cod.left_just(16);

   TString chiave; chiave << risoatt << cod << anno << mese << tpora;
   set(chiave);
}

TRisoatt_key::TRisoatt_key(const char* roakey)
{
  set(roakey);
}

                                ////////////////////////
                                ////    TRISOATT    ////
                                ////////////////////////

bool TRisoatt::read(const TRisoatt_key& chiave)
{
  int err = _iskeynotfound;

  TModule_table tabmod("&ROA");

  tabmod.put("CODTAB", chiave);  
  err = tabmod.read();  
  
  if (err != NOERR)
    zero();

  return err == NOERR;
}

//CHIAVE: metodo che restituisce la chiave della tabella di modulo
const TString& TRisoatt::chiave() const
{
  return get("CODTAB");
}

//DESCR: metodo che restituisce la descrizione contenuta nella tabella di modulo
const TString& TRisoatt::descr() const
{
  return get("S0");
}

//VALUNI: metodo che restituisce il valore unitario contenuto nella tabella di modulo
const real TRisoatt::valuni() const
{
  return get_real("R1");
}

//costruttore
TRisoatt::TRisoatt(const TRectype& r)
        : TRectype(r)
{
  CHECK(r.num() == LF_TABMOD, "Tipo record errato");
}

TRisoatt::TRisoatt(const TRisoatt_key &chiave)
        : TRectype(LF_TABMOD)
{
  read(chiave);
}

                                /////////////////////////////
                                ////    TDISP_RISOATT    ////
                                /////////////////////////////

//CHIAVE: metodo che restituisce la chiave della tabella di modulo
const TString& TDisp_risoatt::chiave() const
{
  return get("CODTAB");
}

//DESCR: metodo che restituisce la descrizione contenuta nella tabella di modulo
const TString& TDisp_risoatt::descr() const
{
  return get("S0");
}

//VALUNI: metodo che restituisce il valore unitario contenuto nella tabella di modulo
const int TDisp_risoatt::ore_prev() const
{
  return get_int("I0");
}

//VALUNI: metodo che restituisce il valore unitario contenuto nella tabella di modulo
const int TDisp_risoatt::ore_cons() const
{
  return get_int("I1");
}

//costruttore
TDisp_risoatt::TDisp_risoatt(const TRectype& r)
              : TRectype(r)
{
  CHECK(r.num() == LF_TABMOD, "Tipo record errato");
}

                                ////////////////////////////////
                                ////    TRILEVAMENTO_ORE    ////
                                ////////////////////////////////

//READ: cerca una riga rilevamento ore in base alla chiave primaria
int TRilevamento_ore::read(const char tipo, const int anno, const int mese, const int giorno, const char tipora, const char *codice, const char *tpora, const char* codcosto, const char* codcms, const char* codfase, TReclock lock)
{
  TLocalisamfile rilore(LF_RILORE);

  zero();
	put(RILORE_TIPO,     tipo);
  put(RILORE_ANNO,     anno);
  put(RILORE_MESE,     mese);
  put(RILORE_GIORNO,   giorno);
  put(RILORE_TIPORA,   tipora);
  put(RILORE_CODICE,   codice);
  put(RILORE_TPORA,    tpora);
  put(RILORE_CODCOSTO, codcosto);
  put(RILORE_CODCMS,   codcms);
  put(RILORE_CODFASE,  codfase);
	TRectype saverec(*this);

  int err = NOERR;
	while ((err = TRectype::read(rilore,_isequal, lock)) == _islocked)
		if (!yesno_box("Dati in uso da parte di un altro utente"))
			break;

	if (err != NOERR)
    *this = saverec;
  return err;
}

int TRilevamento_ore::write_rewrite()
{
	if (!empty())
	{
		TLocalisamfile rilore(LF_RILORE);

		return TRectype::write_rewrite(rilore);
	}
	return _iskeynotfound;
}

int TRilevamento_ore::rewrite_write()
{
	if (!empty())
	{
		TLocalisamfile rilore(LF_RILORE);

		return TRectype::rewrite_write(rilore);
	}
	return _iskeynotfound;
}

int TRilevamento_ore::remove()
{
	if (!empty())
	{
		TLocalisamfile rilore(LF_RILORE);

		return TRectype::remove(rilore);
	}
	return _iskeynotfound;
}

//TIPO: indica se si tratta di una riga di <D>efault, <P>reventivo o <C>onsuntivo
const char TRilevamento_ore::tipo() const
{
  return get(RILORE_TIPO)[0];
}

//TIPORA: indica se si tratta din una <R>isorsa o di una <A>ttrezzatura
const char TRilevamento_ore::tipora() const
{
  return get(RILORE_TIPORA)[0];
}

//CODICE: restiruisce il codice della risorsa o dell'attrezzatura
const TString& TRilevamento_ore::codice() const
{
  return get(RILORE_CODICE);
}

//ANNO: restituisce l'anno a cui fa riferimento la riga
const int TRilevamento_ore::anno() const
{
  return get_int(RILORE_ANNO);
}

//MESE: restituisce il mese  a cui fa riferimento la riga
const int TRilevamento_ore::mese() const
{
  return get_int(RILORE_MESE);
}

//GIORNO: restituisce il giorno  a cui fa riferimento la riga
const int TRilevamento_ore::giorno() const
{
  return get_int(RILORE_GIORNO);
}

//TPORA: restituisce il tipo ora
const TString& TRilevamento_ore::tpora() const
{
  return get(RILORE_TPORA);
}

//CODCOSTO: restituisce il codice del centro di costo
const TString& TRilevamento_ore::codcosto() const
{
  return get(RILORE_CODCOSTO);
}

//CODCMS: restituisce il codice commessa
const TString& TRilevamento_ore::codcms() const
{
  return get(RILORE_CODCMS);
}

//CODFASE: restituisce il codice della fase
const TString& TRilevamento_ore::codfase() const
{
  return get(RILORE_CODFASE);
}

//DADATA: restituisce la data di inizio validit<69> della riga
const TDate TRilevamento_ore::dadata() const
{
  return get_date(RILORE_DADATA);
}

//ADATA: restituisce la fata di fine validit<69> della riga
const TDate TRilevamento_ore::adata()const
{
  return get_date(RILORE_ADATA);
}

//QTAORE: restituisce il numero di ore
const int TRilevamento_ore::qtaore() const
{
  return get_int(RILORE_QTAORE);
}

//COSTO: restitusce il costo unitario
const real TRilevamento_ore::costo() const
{
  return get_real(RILORE_COSTO);
}

//SET_TIPO: setta <D>efault, <P>reventivo o <C>onsuntivo
void TRilevamento_ore::set_tipo(const char tipo)
{
  put(RILORE_TIPO, tipo);
}

//SET_TIPORA: setta <R>isorsa o <A>ttrezzatura
void TRilevamento_ore::set_tipora(const char tipora)
{
  put(RILORE_TIPORA, tipora);
}

//SET_CODICE: setta il codice
void TRilevamento_ore::set_codice(const char* codice)
{
  put(RILORE_CODICE, codice);
}

//SET_ANNO: setta l'anno di riferimento
void TRilevamento_ore::set_anno(const int anno)
{
  put(RILORE_ANNO, anno);
}

//SET_MESE: setta il mese di riferimento
void TRilevamento_ore::set_mese(const int mese)
{
  put(RILORE_MESE, mese);
}

//SET_GIORNO: setta il giorno di riferimento
void TRilevamento_ore::set_giorno(const int giorno)
{
  put(RILORE_GIORNO, giorno);
}

//SET_TPORA: setta il tipo ora
void TRilevamento_ore::set_tpora(const char* tpora)
{
  put(RILORE_TPORA, tpora);
}

//SET_CODCOSTO: setta il codice del centro di costo
void TRilevamento_ore::set_codcosto(const char* codcosto)
{
  put(RILORE_CODCOSTO, codcosto);
}

//SET_CODCMS: setta il codice commessa
void TRilevamento_ore::set_codcms(const char* codcms)
{
  put(RILORE_CODCMS, codcms);
}

//SET_CODFASE: setta il codice della fase
void TRilevamento_ore::set_codfase(const char* codfase)
{
  put(RILORE_CODFASE, codfase);
}

//SET_DADATA: setta la data di inizio validit<69> della riga
void TRilevamento_ore::set_dadata(const TDate& dadata)
{
  put(RILORE_DADATA, dadata);
}

//SET_ADATA: setta la data di fine validit<69> della riga
void TRilevamento_ore::set_adata(const TDate& adata)
{
  put(RILORE_ADATA, adata);
}

//SET_QTAORE: setta il numero di ore rilevato
void TRilevamento_ore::set_qtaore(const int qtaore)
{
  put(RILORE_QTAORE, qtaore);
}

//SET_COSTO: metodo che setta il costo unitario (da listino)
void TRilevamento_ore::set_costo(const real& costo)
{
  put(RILORE_COSTO, costo);
}

//Metodi costruttori
TRilevamento_ore::TRilevamento_ore(const TRectype& rec)
                : TRectype(rec)
{
}

TRilevamento_ore::TRilevamento_ore(const TRilevamento_ore& rilore)
                : TRectype(rilore)
{
}

TRilevamento_ore::TRilevamento_ore(const char tipo, const int anno, const int mese, const int giorno, const char tipora, const char* codice, const char* tpora, const char* codcosto, const char* codcms, const char* codfase)
                : TRectype(LF_RILORE)
{
  read(tipo, anno, mese, giorno, tipora, codice, tpora, codcosto, codcms, codfase);
}

TRilevamento_ore::TRilevamento_ore()
                : TRectype(LF_RILORE)
{
  zero();
}