campo-sirio/include/window.cpp

#define XI_INTERNAL
#include <xinclude.h>

#include <applicat.h>
#include <colors.h>
#include <os_dep.h>
#include <urldefid.h>

#define __WINDOW_CPP
#include <window.h>  
#include <xvtility.h>

HIDDEN MENU_ITEM* find_menu_item(MENU_ITEM* menu, MENU_TAG id, bool ismbar)
{                                               
  MENU_ITEM* fnd = NULL;  
  MENU_ITEM* mn  = ismbar ? &menu[0] : &menu->child[0];

  for (int m = 0; mn != NULL && mn->tag != 0; m++, mn=ismbar?&menu[m]:&menu->child[m])
  {
    fnd = mn->tag == id ? mn : find_menu_item(mn, id, FALSE);
    if (fnd != NULL) break;
  } 
  
  return fnd;
}

HIDDEN bool remove_menu_item(MENU_ITEM* menu, MENU_TAG id, bool ismbar)
{                                               
  MENU_ITEM* mn  = ismbar ? &menu[0] : &menu->child[0];

  for (int m = 0; mn != NULL && mn->tag != 0; m++, mn=ismbar?&menu[m]:&menu->child[m])
  {
    if (mn->tag == id) 
    { 
      do    
      {
        xvt_mem_rep((DATA_PTR)mn, (DATA_PTR)(mn+1), sizeof(MENU_ITEM), 1);
        mn++;
      } 
      while (mn->tag != 0); 
      return TRUE;
    }
    else if (remove_menu_item(mn, id, FALSE)) 
      return TRUE;
  }
  
  return FALSE;
}


HIDDEN void set_menu_item(MENU_ITEM& m, TToken_string& tt)
{                        
  MENU_TAG tag  = tt.get_int(0);
  TString  flag = tt.items() <=  2 ? "": tt.get(2);
  char* text = NULL; 
  if (strlen(tt.get(1)) > 0)
  {
    text = (char*)xvt_mem_alloc(strlen(tt.get(1)) + 1);
    strcpy(text, tt.get(1));  
  }

  m.tag       = tag;
  m.text      = text;
  m.enabled   = !(flag.find('D') != -1);
  m.checkable = flag.find('C') != -1 || flag.find('c') != -1;
  m.checked   = flag.find('c') != -1;      
  m.separator = text == NULL;
} 

///////////////////////////////////////////////////////////
// TWindow_manager
///////////////////////////////////////////////////////////
          
// @doc INTERNAL          
          
// @class TWindow_manager | Classe per la gestione di un array di finestre modali
class TWindow_manager
{
  // @author:(INTERNAL) Guido

  // @access:(INTERNAL) Private Member
  
  // @ccost:(INTERNAL) MAX_WIN | 8 | Numero massimo di finestre modali
  enum { MAX_WIN = 8 };         

  // @cmember:(INTERNAL) Stack contenente la finestra attiva
  TWindow* _window[MAX_WIN];    
  // @cmember:(INTERNAL) Stack pointer
  char _current;                
  // @cmember:(INTERNAL) Permette di abilitare/disabilitare il menu' della task window (stesso 
  //                                    funzionamento della <mf TMask::enable>)
  void menu_enable(bool) const; 
  
  // @cmember:(INTERNAL) Tiene sempre disponibile un file con un numero di handle inferiore a 20
  //                                    (per sopperire ad una mancanza di XVT)
  FILE* _lowhandle;

// @access Public Member  
public:
  // @cmember Costruttore
  TWindow_manager(); 
  // @cmember Distruttore
  ~TWindow_manager();
  
  // @cmember Libera lo spazio per aprire il file (vedi <p _lowhandle>)
  void free_handle();
  // @cmember Occupa lo spazio per aprire il file (vedi <p _lowhandle>)
  void lock_handle();

  // @cmember Registra la finestra <p m> corrente 
  void reg(TWindow* m);
  // @cmember De-registra la finestra corrente
  void unreg(const TWindow* m);
  
  // @cmember Ritorna il puntatore alla finestra corrente
  TWindow* cur_win() const 
  { return (_current < 0) ? NULL : _window[_current]; } 

  // @cmember Chiude tutte le finestre modali aperte
  void destroy();
  // @cmember Ritorna TRUE se la finestra corrente puo' essere chiusa
  bool can_close() const; 
} WinManager;



TWindow_manager::TWindow_manager() : _current(-1), _lowhandle(NULL)
{
  lock_handle();
}

TWindow_manager::~TWindow_manager()
{ 
  destroy(); 
  free_handle();
}  

void TWindow_manager::destroy()
{
  while (_current >= 0)
  {
    TWindow* w = cur_win();
    w->stop_run(K_FORCE_CLOSE);
    w->close_modal();
  }
}

void TWindow_manager::lock_handle()
{
#if XVT_OS == XVT_OS_WIN
  CHECK(_lowhandle == NULL, "Can't relock low handle");
  _lowhandle = fopen("con", "r");
  CHECK(_lowhandle != NULL, "Can't lock low handle");
#endif
}

void TWindow_manager::free_handle()
{
#if XVT_OS == XVT_OS_WIN
  CHECK(_lowhandle, "Can't unlock low handle");
  fclose(_lowhandle);
  _lowhandle = NULL;
#endif
}


bool TWindow_manager::can_close() const 
{ 
  bool ok = TRUE;
  if (_current >= 0)
    ok = cur_win()->can_be_closed();
  return ok;
}


// Dis/abilitazione del menu principale
HIDDEN void xvt_menu_enable(MENU_ITEM* m, bool on)
{
  while (m->tag)
  {
    if (m->tag > BAR_ITEM(0) && m->tag < BAR_ITEM(16))
      xvt_menu_set_item_enabled(TASK_WIN, m->tag, on);
    m++;
  }
}


void TWindow_manager::menu_enable(bool on) const
{
  MENU_ITEM *mi = xvt_menu_get_tree(TASK_WIN);
  xvt_menu_enable(mi, on);
  xvt_menu_update(TASK_WIN);
  xvt_res_free_menu_tree(mi);
}


void TWindow_manager::reg(TWindow* m)
{
  _current++;
  CHECK(_current < MAX_WIN, "Too many windows");

  switch (_current)
  {
  case 0 : 
    menu_enable(FALSE);                      
    {                                                                                   
      const bool on = main_app().firm_change_enabled();
      xvt_menu_set_item_enabled(TASK_WIN, M_FILE_NEW, on);
      xvt_menu_set_item_enabled(TASK_WIN, M_FILE_REVERT, on);
    }
    break;
  case 1 : 
    xvt_menu_set_item_enabled(TASK_WIN, M_FILE_QUIT, FALSE); 
    xvt_menu_set_item_enabled(TASK_WIN, M_FILE_NEW, FALSE);  
    xvt_menu_set_item_enabled(TASK_WIN, M_FILE_REVERT, FALSE);
  default: 
    _window[_current-1]->deactivate(); break;
  }

  _window[_current] = m;
}


void TWindow_manager::unreg(const TWindow* m)
{
#ifdef DBG
  if (m != cur_win())
  {
    yesnofatal_box("E' successo un casino nel Window Manager");
    return;
  }
#endif

  _current--;
  
  if (_current < 0)
  {
    menu_enable(TRUE);
  }  
  else
  {
    cur_win()->activate();
    
    xvt_menu_set_item_enabled(TASK_WIN, M_FILE_QUIT, _current == 0);
    
    const bool cf = _current == 0 && main_app().firm_change_enabled();
    xvt_menu_set_item_enabled(TASK_WIN, M_FILE_NEW, cf);
    xvt_menu_set_item_enabled(TASK_WIN, M_FILE_REVERT, cf);
    
    xvt_menu_update(TASK_WIN);
    cur_win()->set_focus();
  }     
}


// @func Chiude tutte le finestre aperte
void close_all_dialogs()
{
  WinManager.destroy();
}

// @doc EXTERNAL

// @func Indica se l'applicazione puo' essere terminata
//
// @rdesc Ritorna il risultato della ricerca:
//
// @flag TRUE | Se l'aplicazione puo' essere chiusa
// @flag FALSE | Se l'applicazione non puo' essere chiusa
bool can_close()
{
  return WinManager.can_close();
}

bool is_valid_window(WINDOW w)
{
  bool ok = FALSE;
  if (w != NULL_WIN)
    ok = xvt_vobj_get_attr(w, ATTR_NATIVE_WINDOW) != NULL;
  return ok;
}

// @func Ritorna l'handle della finestra corrente
//
// @rdesc Restituisce l'handle della finestra corrente.
WINDOW cur_win()

  // @comm Se non esiste una finestra corrente allora ritorna NULL_WIN
{
  WINDOW win = NULL_WIN;
  TWindow* w = WinManager.cur_win();
  if (w)
  { 
    win = w->win();
    if (!is_valid_window(w->win()))
    {
      w->stop_run(K_FORCE_CLOSE);
      win = NULL_WIN;
    }  
  }  
  return win;  
}

///////////////////////////////////////////////////////////
// TImage
///////////////////////////////////////////////////////////


// Certified 99%
// @doc EXTERNAL

// @mfunc Setta l'immagine e le sue dimensioni
//
// @rdesc Ritorna l'immagine stessa
XVT_IMAGE TImage::set(
  XVT_IMAGE i) // @parm Immagine da settare

  // @comm L'immagine precedente viene cancellata quando viene settata una nuova
{
  if (_image) 
    xvt_image_destroy(_image);
  _image = i;
  if (i)
  {
    _src.left = _src.top = 0;
    xvt_image_get_dimensions(i, &_src.right, &_src.bottom);
    _dst = _src;
  } 
  return _image;
}

// Certified 100%
// @doc EXTERNAL

// @mfunc Legge l'immagine dal file
XVT_IMAGE TImage::load(
  const char* n) // @parm Nome del file contenente l'immagine
{               
  WinManager.free_handle();    
  XVT_IMAGE i = xvt_image_read_bmp((char*)n);
  WinManager.lock_handle();    
  
  if (i != NULL) set(i);
  return i;  
}

// Certified 100%
XVT_IMAGE TImage::load(short id)
{                         
  return set(xvt_res_get_image(id));
}


// Certified 100%
TImage::TImage(const char* n) : _image(NULL)
{
  if (n && *n) load(n);
}

// Certified 100%
TImage::TImage(short id) : _image(NULL)
{
  if (id > 0) load(id);
}

// Certified 90%
TImage::TImage(const TImage& im, short w, short h) : _image(NULL)
{ 
  const XVT_IMAGE_FORMAT fmt = xvt_image_get_format(im._image);
  set(xvt_image_create(fmt, w, h, NULL));
  
  if (ok())
  { 
    if (fmt == XVT_IMAGE_CL8)
    {
      const short colors = xvt_image_get_ncolors(im._image);
      xvt_image_set_ncolors(_image, colors);
      for (short c = 0; c < colors; c++) 
        xvt_image_set_clut(_image, c, xvt_image_get_clut((XVT_IMAGE)im._image, c));
    }    
    xvt_image_transfer(_image, (XVT_IMAGE)im._image, &_src, (RCT*)&im._src);
  }  
}

// Certified 90%
TImage::TImage(short w, short h, XVT_IMAGE_FORMAT fmt) : _image(NULL)
{ 
  set(xvt_image_create(fmt, w, h, NULL));
}

// Certified 100%
TImage::~TImage()
{     
  if (_image != NULL)                    
    xvt_image_destroy(_image);
}

// Certified 100%
// @doc EXTERNAL

// @mfunc Permette di settare la posizione della figura
void TImage::set_pos(
  int x, // @parm Coordinata x dell'immagine da settare
  int y) // @parm Coordinata y dell'immagine da settare
  
  // @comm Permette di aggiornare il mebro <p _dst> sommandogli i valori                 
  //                     passati con <p x> e <p y>
{
  _dst = _src;
  xvt_rect_offset(&_dst, x, y);
}               

// Certified 100%
void TImage::draw(WINDOW w) const
{   
  xvt_dwin_draw_image(w, _image, (RCT*)&_dst, (RCT*)&_src);
}

// Certified 100%
// @doc EXTERNAL

// @mfunc Permette di gestire il disegno dell'immagine sullo schermo
void TImage::draw(
  WINDOW w,    // @parm Immagine da disegnare
  int x,       // @parm Coordinata x in cui disegnare l'immagine
  int y) const // @parm Coordinata y in cui disegnare l'immagine
  // @parm RCT& | _src | Rettangolo contenente l'immagine da disegnare
  // @parm RCT& | _dst | Rettangolo in cui disegnare l'immagine

  // @syntax void draw(WINDOW w);
  // @syntax void draw(WINDOW w, int x, int y);
  // @syntax void draw(WINDOW w, const RCT& dst);
  // @syntax void draw(WINDOW w, const RCT& dst, const RCT& src);

  // @comm Nel caso utilizzo l'ultima sintassi e' possibile disegnare solo una parte
  //                     dell'immagine, precisamente delle dimensioni <p _dst> se tale parametro e'
  //                     minore di <p _pst>
{                                       
  RCT dst = _src;
  xvt_rect_offset(&dst, x, y);
  xvt_dwin_draw_image(w, _image, &dst, (RCT*)&_src);
}

// Certified 100%
void TImage::draw(WINDOW w, const RCT& dst) const
{
  xvt_dwin_draw_image(w, _image, (RCT*)&dst, (RCT*)&_src);
}

// Certified 100%
void TImage::draw(WINDOW w, const RCT& dst, const RCT& src) const
{
  xvt_dwin_draw_image(w, _image, (RCT*)&dst, (RCT*)&src);
}

// Certified 99%
// @doc EXTERNAL

// @mfunc Fa corrispondere la palette della finestra a quella dell'immagine 
void TImage::set_palette(
  WINDOW w) const // @parm Finestra a cui settare la palette
{
  XVT_PALETTE wp = xvt_vobj_get_palet(w);
  if (wp != NULL)
  {
    XVT_PALETTE p = xvt_palet_create(XVT_PALETTE_USER, NULL);
    const int ncolors = xvt_palet_get_ncolors(wp);
    COLOR* color = new COLOR[ncolors];
    xvt_palet_get_colors(wp, color, ncolors);
    xvt_palet_add_colors(p, color, ncolors);
    delete color;
    xvt_palet_add_colors_from_image(p, _image);
    xvt_vobj_set_palet(w, p);
    xvt_palet_destroy(wp);
  }  
}

// Certified 100%
void TImage::set_clut(byte n, COLOR c)
{
  if (xvt_image_get_format(_image) == XVT_IMAGE_CL8)                  
    xvt_image_set_clut(_image, n, c);
}

// Certified 99%
// @doc EXTERNAL

// @mfunc Setta i colori dell'immagine in modo da renderla trasparente
void TImage::convert_to_default_colors()

  // @comm Legge nell'immagine i colori CYAN e DARK_CYAN e li setta a seconda del colore
  //                     della finestra per fare in modo di rendere trasparenti tali colori.
{
  if (MASK_BACK_COLOR != COLOR_DKCYAN && xvt_image_get_format(_image) == XVT_IMAGE_CL8)                  
  { 
    short dx, dy; xvt_image_get_dimensions(_image, &dx, &dy);
    for (short y = 0; y < dy; y++) for (short x = 0; x < dx; x++)
    {     
      const COLOR c = xvt_image_get_pixel(_image, x, y);
      switch (c)
      {
      case COLOR_DKCYAN & 0x00FFFFFF:
        xvt_image_set_pixel(_image, x, y, MASK_BACK_COLOR); break;
      case COLOR_CYAN & 0x00FFFFFF:
        xvt_image_set_pixel(_image, x, y, MASK_LIGHT_COLOR); break;
      case COLOR_GRAY & 0x00FFFFFF:
        xvt_image_set_pixel(_image, x, y, MASK_DARK_COLOR); break;
      default:
        break;  
      }
    }
  } 
}

// @mfunc Setta i colori dell'immagine  in modo da renderla trasparente
void TImage::convert_transparent_color(COLOR transparent)

  // @comm Legge nell'immagine i pixel uguali a quello in alto a sinistra e li setta 
  // uguali allo sfondo delle maschere
{                               
  if (_image)
  {
    const COLOR trans = xvt_image_get_pixel(_image, 0, 0) & 0x00FFFFFF;
    if (trans != (transparent & 0x00FFFFFF) && 
        xvt_image_get_format(_image) == XVT_IMAGE_CL8)                  
    {                  
      for (int index = xvt_image_get_ncolors(_image)-1; index >=0; index--)
        if (trans == (xvt_image_get_clut(_image, index) & 0x00FFFFFF))
        {
          xvt_image_set_clut(_image, index, transparent);
          // break; don't break: replace all colors equal to upper left in the palette
        }
    } 
  }  
}

///////////////////////////////////////////////////////////
// TWindow
///////////////////////////////////////////////////////////

DRAW_CTOOLS TWindow::_ct;
bool TWindow::_ctools_saved;


TWindow::TWindow()
: _win(NULL_WIN), _open(FALSE), _modal(FALSE), _active(TRUE),
  _running(FALSE), _pixmap(FALSE), _lastkey(0)
{}

word TWindow::class_id() const
{ return CLASS_WINDOW; }

long XVT_CALLCONV1 TWindow::window_handler(WINDOW win, EVENT* ep)
{
  TWindow* w = (TWindow*)xvt_vobj_get_data(win);
  CHECK(w != NULL, "Invalid window");
  w->handler(win, ep);

  return 0L;
}


// @doc EXTERNAL

// @mfunc Crea la finestra
//
// @rdesc Ritorna l'handle della finestra creata
WINDOW TWindow::create(
  short x,           // @parm Coordinata x della finestra
  short y,           // @parm Coordinata y della finestra
  short dx,          // @parm Larghezza della finestra
  short dy,          // @parm Altezza della finestra
  const char* title, // @parm Titolo da assegnare alla finestra (default "")
  long flags,        // @parm Flag della finestra (default WSF_NONE)
  WIN_TYPE wt,       // @parm Tipo di finestra da creare (default W_DOC)
  WINDOW parent,     // @parm Handler della finestra padre (default NULL_WIN)
  int menu)          // @parm Menu' da assegnare alla finestra (default 0)
{
  if (menu == 0) flags |= WSF_NO_MENUBAR;

  if (parent == NULL_WIN) parent = TASK_WIN;
  if (parent == TASK_WIN) flags |= WSF_INVISIBLE;

  _win = xvt_create_window(
    wt,
    x, y, dx, dy,
    title, 
    menu, parent,
    flags, 
    window_handler,
    PTR_LONG(this)
    );

  CHECK(_win, "Can't create a window");

  return _win;
}


TWindow::~TWindow()
{
  if (_win != NULL_WIN)
  {   
    if (is_valid_window(_win));
      xvt_vobj_destroy(_win);
    _win = NULL_WIN;
  }
}


void TWindow::open()
{
  WINDOW w = win();
  CHECK(is_valid_window(w), "Can't open a NULL window");
  xvt_vobj_set_visible(w, _open = TRUE);
  xvt_scr_set_focus_vobj(w);  
  xvt_vobj_raise(w);          
}


void TWindow::open_modal()
{
  set_modal(TRUE);
  _open = TRUE;
  open();

  WinManager.reg(this);
}


void TWindow::close()
{
  CHECK(_win != NULL_WIN, "Can't close a NULL window");
  if (is_valid_window(_win))
    xvt_vobj_set_visible(_win, _open = FALSE);
}


void TWindow::close_modal()
{            
  CHECK(is_modal(), "Can't modal-close a non-modal window");
  WinManager.unreg(this);
  close();
  _open = FALSE;
  set_modal(FALSE);
}

bool TWindow::stop_run(KEY key)
{
  _running = FALSE;
  _lastkey = key;     
  return TRUE;
}

bool TWindow::can_be_closed() const
{
  const bool ok = !is_modal();
  if (!ok) 
    error_box("Chiudere la finestra attiva prima di uscire dal programma");
  return ok;
}

// @doc EXTERNAL

// @mfunc Esegue la finestra
//
// @rdesc Ritorna l'ultimo tasto premuto nella finestra
KEY TWindow::run()

  // @comm Se la finestra non era aperta la apre in modo modale
{
  const bool was_open = is_open();

  start_run();
  _running = TRUE;

  if (!was_open) open_modal();
  else open();

  while (_running)
    do_events();

  if (!was_open) close_modal();
  do_events();

  return last_key();
}

void TWindow::on_button(short dlg)
{   
  switch(dlg)
  {
  case DLG_OK: 
    stop_run(K_ENTER); 
    break;
  case DLG_CANCEL: 
    stop_run(K_ESC); 
    break;
  case DLG_QUIT: 
    stop_run(K_QUIT); 
    break;
  default:
    break;
  }
}

// @doc EXTERNAL

// @mfunc Gestisce l'handler della finestra
void TWindow::handler(
  WINDOW win, // @parm Finestra da gestire
  EVENT* ep)  // @parm Evento da gestire nella finestra
{
  switch(ep->type)
  {
  case E_CLOSE:
    stop_run(K_ESC);
    break;
  case E_CONTROL:
    if (ep->v.ctl.ci.type == WC_PUSHBUTTON)
      on_button(ep->v.ctl.id);
    break;  
  case E_UPDATE:
    update();
    break;
  case E_CHAR:
    on_key(e_char_to_key(ep));
    break;
  case E_DESTROY:
    _win = NULL_WIN;
    break;
  default:
    break;
  }
}

void TWindow::on_idle()
{
  // Non c'e' niente da fare qui, ma non si puo' mai sapere
}


TPoint TWindow::size() const
{
  RCT r;
  xvt_vobj_get_client_rect(win() ? win() : TASK_WIN, &r);
  return TPoint(r.right / CHARX, r.bottom / CHARY);
}

WINDOW TWindow::parent() const
{
  return xvt_vobj_get_parent(win());
}


void TWindow::set_focus()
{ 
  WINDOW w = win();
  if (w)
  {
    xvt_scr_set_focus_vobj(w);
    xvt_vobj_raise(w);        
  }
}

void TWindow::iconize() const
{
  os_iconize_window(win());
}

void TWindow::maximize() const
{
  os_maximize_window(win());
} 

void TWindow::set_background_color(COLOR col)
{
  XI_OBJ* itf = xi_get_itf(win());
  itf->v.itf->back_color = col;
  force_update();
}

// @doc EXTERNAL

// @mfunc Attiva/disattiva la finestra
void TWindow::activate(
  bool on) // @parm Indica l'operazione da svolgere sulla finestra:
  //
  // @flag TRUE | Abilita la finestra (default)
  // @flag FALSE | Disabilita la finestra
{
  xvt_vobj_set_enabled(win(), _active = on);
}


void TWindow::set_caption(const char* title)
{
  xvt_vobj_set_title(win(), (char*)title);
}


const char* TWindow::get_caption(TString& str) const
{
  char* title = str.get_buffer(128);
  xvt_vobj_get_title(win(), title, str.size());
  return title;
}


void TWindow::force_update()
{
  if (win() != NULL_WIN)
    xvt_dwin_invalidate_rect(win(), NULL);
}


bool TWindow::save_ctools()
{
  if (_ctools_saved == FALSE)
  {
    xvt_dwin_get_draw_ctools(win(), &_ct);
    return _ctools_saved = TRUE;
  }
  return FALSE;
}


bool TWindow::restore_ctools()
{
  if (_ctools_saved)
  {
    xvt_dwin_set_draw_ctools(win(), &_ct);
    _ctools_saved = FALSE;
    return TRUE;
  }
  return FALSE;
}


void TWindow::set_color(COLOR fore, COLOR back)
{
  WINDOW w = win();
  xvt_dwin_set_fore_color(w, fore);
  xvt_dwin_set_back_color(w, back);
}

// @doc EXTERNAL

// @mfunc Sceglie la penna da utilizzare nella finestra
void TWindow::set_pen(
  COLOR color,     // @parm Colore della penna
  int width,       // @parm Larghezza del tratto (default 1)
  PAT_STYLE pat,   // @parm Stile del pattern (default PAT_SOLID)
  PEN_STYLE style) // @parm Stile della penna (default P_SOLID)
{
  CPEN pen;

  pen.width = width;
  pen.pat   = pat;
  pen.style = style;
  pen.color = color;

  xvt_dwin_set_cpen(win(), &pen);
}


void TWindow::hide_pen()
{
  xvt_dwin_set_std_cpen(win(), TL_PEN_HOLLOW);
}


void TWindow::set_brush(COLOR color, PAT_STYLE pat)
{
  CBRUSH brush = { pat, color };
  xvt_dwin_set_cbrush(win(), &brush);
}


void TWindow::hide_brush()
{
  CBRUSH brush = { PAT_HOLLOW, COLOR_WHITE };
  xvt_dwin_set_cbrush(win(), &brush);
}


HIDDEN void swap(short& a, short& b)
{
  short tmp = a;
  a = b;
  b = tmp;
}

// @doc EXTERNAL

// @mfunc Disegna un rettangolo con la possibilita' di settare la penna e il draw_mode
void TWindow::frame(
  short left,   // @parm Lato sinistro del rettangolo
  short top,    // @parm Lato superiore del rettangolo
  short right,  // @parm Lato destro del rettangolo
  short bottom, // @parm Lato inferiore del rettangolo
  int flag)     // @parm Flag da assegnare per il disegno del rettangolo

  // @comm Se <p left> <gt> <p right> oppure <p top> <gt> <p bottom> i valori
  //       vengono scambiati per permettere il disegno corretto del rettangolo
{
  if (left > right) swap(left, right);
  if (top > bottom) swap(top, bottom);

  const bool saved = flag && save_ctools();

  if (flag & 1) hide_pen();
  if (flag & 2) hide_brush();
  if (flag & 4)
  {
    set_mode(M_XOR);
    set_brush(COLOR_BLACK);     // Needed for Windows
  }

  const PNT f = log2dev(left,top);
  const PNT t = log2dev(right,bottom);
  RCT r;
  r.top = f.v; r.left = f.h;
  r.bottom = t.v; r.right = t.h;

#if XVT_OS == XVT_OS_WIN || XVT_OS == XVT_OS_WIN32
  if (!_pixmap && (flag & 2))
  {
    r.left += CHARX>>1; r.top += CHARY>>1;
    r.right-= CHARX>>1; r.bottom -= CHARY>>1;
  }
#endif

  xvt_dwin_draw_rect(win(), &r);

  if (saved) restore_ctools();
}


void TWindow::rect(short left, short top, short right, short bottom)
{
  frame(left, top, right, bottom, 2);
}


void TWindow::bar(short left, short top, short right, short bottom)
{
  frame(left, top, right, bottom, 1);
}


void TWindow::invert_bar(short left, short top, short right, short bottom)
{
  frame(left, top, right, bottom, 5);
}

// @doc EXTERNAL

// @mfunc Setta opaque_text
void TWindow::set_opaque_text(
  bool o) // @parm Indica la modalita' di scrittura dell'opaque_text
{
  // @comm Quando <p o> e' FALSE il testo viene scritto in modo trasparente
  DRAW_CTOOLS ct;
  xvt_dwin_get_draw_ctools(win(), &ct);
  ct.opaque_text = o;
  xvt_dwin_set_draw_ctools(win(), &ct);
}

// @doc EXTERNAL

// @mfunc Sceglie il font da utilizzare nella finestra
void TWindow::set_font(
  const char* family, // @parm Famiglia di appartenenza del font (default XVT_FFN_FIXED)
  int style,          // @parm Stile del font (default 0)
  int dim)            // @parm Dimensione del font (default 0)
{
  xvt_set_font(win(), family, style, dim);
}

PNT TWindow::log2dev(long x, long y) const
{
  PNT pnt;

  pnt.h = (int)x;
  pnt.v = (int)y;

  if (!_pixmap)
  {
    pnt.h *= CHARX;
    pnt.v *= CHARY;
  }
  
  return pnt;
}

TPoint TWindow::dev2log(const PNT& p) const
{
  TPoint pnt(_pixmap ? p.h : p.h/CHARX, _pixmap ? p.v : p.v/CHARY);
  return pnt;
}


void TWindow::stringat(short x, short y, const char* str)
{
  PNT pnt = log2dev(x,y);
#if XVT_OS == XVT_OS_WIN || XVT_OS == XVT_OS_WIN32
  pnt.v += BASEY;
#endif

  xvt_dwin_draw_text(win(), pnt.h, pnt.v, (char *)str, -1);
}

// @doc EXTERNAL

// @mfunc Scrive il testo formattato nella finestra alla posizione indicata
void TWindow::printat(
  short x,         // @parm Coordinata x della finestra in cui scrivere il testo
  short y,         // @parm Coordinata y della finestra in cui scrivere il testo
  const char* fmt, // @parm Formato che deve essere dato al testo
  ...)             // @parmvar Uno o piu' parametri corrispondenti ai codici in <p fmt>
{      
  TString str(256);
  char* tmp = str.get_buffer();
  va_list argptr;
  va_start(argptr, fmt);    
  vsprintf(tmp, fmt, argptr);
  va_end(argptr);
  stringat(x, y, tmp);
}

void TWindow::line(short x0, short y0, short x1, short y1)
{
  PNT f = log2dev(x0,y0);
  PNT t = log2dev(x1,y1);

  if (!_pixmap) 
  {
    if (f.h == 0) f.h = -CHARX; else f.h += CHARX>>1;
    if (f.v == 0) f.v = -CHARY; else f.v += CHARY>>1;
    if (t.h == 0) t.h = -CHARX; else t.h += CHARX>>1;
    if (t.v == 0) t.v = -CHARY; else t.v += CHARY>>1;
  }

  xvt_dwin_draw_set_pos(win(), f);
  xvt_dwin_draw_line(win(), t);
}

void TWindow::icon(short x0, short y0, int iconid)
{
#if XVT_OS == XVT_OS_SCOUNIX
  bar(x0, y0, x0+1, y0+1);
#else
  PNT f = log2dev(x0,y0);
  if (iconid < 0) iconid = ICON_RSRC;
  xvt_dwin_draw_icon(win(), f.h, f.v, iconid);
#endif
}

void TWindow::clear(COLOR color)
{ xvt_dwin_clear(win(), color); }

void TWindow::set_mode(DRAW_MODE mode)
{ xvt_dwin_set_draw_mode(win(), mode); }

// @doc EXTERNAL

// @mfunc Aggiunge voci di menu' durante l'esecuzione di una finestra
//
// @rdesc Ritorna se e' riuscito ad aggiungere la voce al menu':
//
// @flag TRUE | Se ha ggiunto la voce
// @flag FALSE | Se non ha ggiunto la voce
bool TWindow::add_menu(
  TString_array& menu, // @parm Array da aggiungere al menu'
  MENU_TAG id,         // @parm Identificatore del menu' a cui aggiungere le voci
  bool force)          // @parm Mai usato
  
  // @comm Nel caso <p id> sia uguale a 0 la voce veine aggiunte nella barra dei menu'
{ 
  CHECK(menu.items() > 0, "TWindow::add_menu: no menus to add");

  // get menu tree
  MENU_ITEM* menubar = xvt_menu_get_tree(win());
  
  if (id == 0)  // add to menubar
  {
    // count menus
    for (int nmen = 0; menubar[nmen].tag != 0; nmen++);           
    menubar = (MENU_ITEM*)xvt_mem_realloc((DATA_PTR)menubar, 
                                          sizeof(MENU_ITEM)*(nmen+menu.items()+1));
    // zero new
    xvt_mem_rep((DATA_PTR)&menubar[nmen], "\0", 1, sizeof(MENU_ITEM)*(menu.items()+1));

    // add new menus
    for (int i = 0; i < menu.items(); i++)
      set_menu_item(menubar[nmen+i], menu.row(i));
  }   
  else  // add to menu
  {
    MENU_ITEM* father = find_menu_item(menubar, id, TRUE);
    CHECK(father != NULL, "TWindow::add_menu: you're adding to a NULL menu item");
    
    // count children
    for (int nmen = 0; father->child != NULL && father->child[nmen].tag != 0; nmen++);           
    father->child = (MENU_ITEM*)xvt_mem_realloc((DATA_PTR)father->child, 
                                                sizeof(MENU_ITEM)*(nmen+menu.items()+1));
    // zero new
    xvt_mem_rep((DATA_PTR)&(father->child[nmen]), "\0", 1, sizeof(MENU_ITEM)*(menu.items()+1));

    // add new menus
    for (int i = 0; i < menu.items(); i++)
      set_menu_item(father->child[nmen+i], menu.row(i));    
  }
  
  xvt_menu_set_tree(win(), menubar);              
  xvt_res_free_menu_tree(menubar);
  
  return TRUE;
}

bool TWindow::remove_menu(MENU_TAG id)
{
  MENU_ITEM* menubar = xvt_menu_get_tree(win());
  if (remove_menu_item(menubar, id, TRUE))
  {
    xvt_menu_set_tree(win(),menubar);
    xvt_res_free_menu_tree(menubar);
  }                                 
  return TRUE;
}                                                          


///////////////////////////////////////////////////////////
// TTemp_window
///////////////////////////////////////////////////////////

TTemp_window::TTemp_window(WINDOW w)
{
  set_win(w);
}

TTemp_window::~TTemp_window()
{
  set_win(NULL_WIN);    // I don't want to be closed!
}

///////////////////////////////////////////////////////////
// TScroll_window
///////////////////////////////////////////////////////////

TScroll_window::TScroll_window()
: _origin(0, 0), _max(0, 0), _shift(0), _autoscroll(TRUE),
  _has_hscroll(TRUE), _has_vscroll(TRUE)
{
}

WINDOW TScroll_window::create(short x, short y, short dx, short dy,
                              const char* title, long flags, WIN_TYPE wt, WINDOW parent, int menu)
{
  _has_hscroll = (flags & WSF_HSCROLL) != 0;
  _has_vscroll = (flags & WSF_VSCROLL) != 0 ;
  return TWindow::create(x, y, dx, dy, title, flags, wt, parent, menu);
}

PNT TScroll_window::log2dev(long x, long y) const
{
  if (_autoscroll)
  {      
    if (_pixmap)
    {
      x -= _origin.x * CHARX;
      y -= (_origin.y >> _shift) * CHARY;
    }
    else
    {
      x -= _origin.x;
      y -= _origin.y >> _shift;
    } 
  }
  return TWindow::log2dev(x,y);
}

void TScroll_window::set_scroll_max(long maxx, long maxy)
{
  if (_has_hscroll && maxx >= 0)
  {
    _max.x = maxx;
    xvt_sbar_set_range(win(), HSCROLL, 0, int(maxx));
  }
  if (_has_vscroll && maxy >= 0)
  {
    _shift = 0;
    while ((maxy >> _shift) > 0x7FFF) _shift++;
    _max.y = maxy;
    xvt_sbar_set_range(win(), VSCROLL, 0, int(maxy >> _shift));
  }
}

// @doc EXTERNAL

// @mfunc Aggiorna la scrollbar
void TScroll_window::update_thumb(
  long x, // @parm Indica la posizione in x in cui spostare la finestra (default -1)
  long y) // @parm Indica la posizione in x in cui spostare la finestra (default -1)
  
  // @comm Nel caso si voglia aggiornare solamente una coordinata l'altra dovra' essere
  //                     settata a -1     
{
  if (x >= 0 && x <= _max.x) _origin.x = x;
  if (y >= 0 && y <= _max.y) _origin.y = y;

  if (_has_hscroll)
    xvt_sbar_set_pos(win(), HSCROLL, int(_origin.x));
  if (_has_vscroll)
    xvt_sbar_set_pos(win(), VSCROLL, int(_origin.y >> _shift));
}

void TScroll_window::handler(WINDOW win, EVENT* ep)
{
  if (ep->type == E_HSCROLL || ep->type == E_VSCROLL)
  {
    long& pos = (ep->type == E_HSCROLL) ? _origin.x : _origin.y;
    const long oldpos = pos;
    const long max = (ep->type == E_HSCROLL) ? _max.x : _max.y;
    const short pag = (ep->type == E_HSCROLL) ? columns()/2+1 : rows()/2+1;
    switch(ep->v.scroll.what)
    {
    case SC_PAGE_UP:
      pos -= pag;
      break;
    case SC_LINE_UP:
      pos--;
      break;
    case SC_PAGE_DOWN:
      pos += pag;
      break;
    case SC_LINE_DOWN:
      pos++;
      break;
    case SC_THUMB:
      pos = ep->v.scroll.pos;
      break;
    default:
      break;
    }
    if (pos < 0) pos = 0;
    if (pos > max) pos = max;

    if (pos != oldpos)
    {
      update_thumb();
      force_update();
    }
  }

  TWindow::handler(win, ep);
}

bool TScroll_window::on_key(KEY key)
{
  switch(key)
  {
  case K_LHOME:
    update_thumb(0,0);
    force_update();
    break;
  case K_LEND:
    update_thumb(0,range().y);
    force_update();
    break;
  case K_TAB:
    update_thumb(origin().x+8);
    force_update();
    break;
  case K_BTAB:
  {
    long x = origin().x-8;
    if (x < 0) x = 0;
    update_thumb(x);
    force_update();
  }
    break;
  case K_UP:
  case K_DOWN:
  case K_PREV:
  case K_NEXT:
  case K_LEFT:
  case K_RIGHT:
    dispatch_e_scroll(win(), key);
    break;
  default:
    break;
  }

  return TWindow::on_key(key);
}