campo-sirio/include/xvtility.cpp

#define XVT_INCL_NATIVE
#include <applicat.h>
#include <colors.h>
#include <config.h>
#include <controls.h>
#include <mask.h>
#include <prefix.h>
#include <statbar.h> 
#include <urldefid.h>
#include <utility.h>     
 
#include <nditte.h>     

short CHARX = 8;
short CHARY = 14;
short ROWY = -CHARY;    // Not so good!

HIDDEN bool _ignore_xvt_errors = FALSE;

void ignore_xvt_errors(bool ixe)
{ _ignore_xvt_errors = ixe; }

// ERROR HOOK che intercetta errori XVT: put breakpoint here
HIDDEN BOOLEAN error_hook(XVT_ERRMSG err, DATA_PTR)
{        
  if (_ignore_xvt_errors)
    return TRUE;
  const XVT_ERRSEV sev = xvt_errmsg_get_sev_id(err);
#ifdef DBG
  return sev == 0 ? FALSE : FALSE;
#else
  return sev < SEV_ERROR;
#endif
}

PNT xvtil_taskwin_size()
{
  RCT max_rct; xvt_vobj_get_client_rect(TASK_WIN, &max_rct);
  PNT pnt = { max_rct.bottom, max_rct.right };

  int sbh = xvtil_statbar_height(); 
  if (sbh <= 0) sbh = 24;
  pnt.v -= sbh;                    // Tolgo lo spazio occupato dalla status bar
  pnt.v -= sbh;                    // Tolgo lo spazio occupato dai tab buttons
  pnt.v -= TOOL_SIZE + 8;          // Tolgo lo spazio occupato dalle icone della toolbar
  pnt.v -= TOOL_TEXT ? 12 : 0;     // Tolgo lo spazio occupato dal testo della toolbar
  return pnt;
}


// @doc INTERNAL

// @func Calcola dimensioni e posizione di un controllo contenuto nella finestra
//
// @rdesc Ritorna il rettangolo
RCT& resize_rect(
  short x,        // @parm Coordinata x del controllo (espresso in caratteri)
  short y,        // @parm Coordinata y del controllo (espresso in caratteri)
  short dx,       // @parm Larghezza del controllo (espresso in caratteri)
  short dy,       // @parm Altezza del controllo (espresso in caratteri)
  WIN_TYPE wt,    // @parm Tipo di controllo da creare
  WINDOW parent)  // @parm Identificatore della finestra padre
{
  static RCT r;      
  
  if (parent != TASK_WIN)
  {
    if (xvt_vobj_get_type(parent) == W_PLAIN) // Mask with Toolbar
    {
      if (x > 0 || (wt != WO_TE && wt != W_PLAIN && x == 0))
      { 
        if (!is_full_screen_interface(parent))    // Not Full screen?
        {
          RCT pc; xvt_vobj_get_client_rect(parent, &pc);   // Get parent window size
          const int width = pc.right;               
          const int tot = 80*CHARX;
          if (width > tot) x += (width-tot) / (CHARX<<1);
        }
      }
    }
    wt = WC_TEXTEDIT;     // Campo di maschera
  }
  else
  {
    if (ROWY <= 0)         // Not yet initialized
    {
      const PNT tws = xvtil_taskwin_size();
      ROWY = tws.v / min(MAX_MASK_ROWS, tws.v / CHARY);
    }  
  }

  switch (wt)
  {
  case WC_TEXTEDIT :
    if (x == 0 && dx == 0 && y == 0 && dy == 0) // Campo a tutta pagina!
    {
      xvt_vobj_get_client_rect(parent, &r);
    }
    else
    {
      int BASEY; xvt_dwin_get_font_metrics(parent, NULL, &BASEY, NULL);
      r.left   = (x+1)*CHARX;
      r.top    = y*ROWY;
      r.right  = dx*CHARX;
      r.bottom = (CHARY << 1) - BASEY;
      if (dy > 1)
        r.bottom += ROWY*(dy-1);
    }
    break;
  case W_DOC:
    r.left   = x * CHARX;
    r.top    = y * ROWY;
    r.right  = dx * CHARX;
    r.bottom = dy * ROWY;
    break;
  default:
    r.left   = x * CHARX;
    r.top    = y * ROWY;
    r.right  = (dx+2)*CHARX;
    r.bottom = dy*ROWY-1;
    break;
  }

  if (x < 0 || y < 0 || dx <= 0 || dy <= 0)
  {
    RCT pc;
    if (parent == NULL_WIN) parent = TASK_WIN;
    xvt_vobj_get_client_rect(parent, &pc);     // Get parent window size
    if (parent == TASK_WIN)
    {
      int sbh = xvtil_statbar_height(); 
      if (sbh <= 0) sbh = 22;
      pc.bottom -= (sbh+2);
    }
    const short MAXX = pc.right;
    const short MAXY = pc.bottom;

    if (x < 0)
    {
      x = -x;
      if (wt != WC_TEXTEDIT && x == 1) x = 11;
      if (x > 10)
      {
        const int num = x/10 -1;
        const int tot = x%10;
        const int spc = (MAXX - tot*r.right) / (tot+1);
        r.left = spc + num*(spc+r.right);
      }
      else
        r.left = MAXX - r.right - x*CHARX;
    }

    if (y < 0)
    {
      y = -y;
      if (wt != WC_TEXTEDIT && y == 1) 
        y = 11;
      if (y > 10)
      {
        const int num = y/10 -1;
        const int tot = y%10;
        int height = r.bottom;
        if (wt == W_DOC)
        {
          height += short(xvt_vobj_get_attr(parent, ATTR_TITLE_HEIGHT));
          height += short(2*xvt_vobj_get_attr(parent, ATTR_DOCFRAME_HEIGHT));
        }
        const int spc = (MAXY - tot*height) / (tot+1);
        r.top = spc + num*(spc+height);
      }
      else
        r.top = MAXY - r.bottom - (y-1)*ROWY;
    }

    if (dx <= 0) 
      r.right = MAXX + dx*CHARX;
    else 
      r.right += r.left;
    if (dy <= 0) 
      r.bottom = MAXY + dy*ROWY;
    else
      r.bottom += r.top;
  }
  else
  {
    r.right += r.left;
    r.bottom += r.top;
  }
  return r;
}

RCT& xvtil_align_rect(const RCT& inner, const RCT& outer, char halign, char valign, char grow)
{
  static RCT r;      

  const int ow = xvt_rect_get_width(&outer);
  const int oh = xvt_rect_get_height(&outer);
  int iw = xvt_rect_get_width(&inner);
  int ih = xvt_rect_get_height(&inner);
  int ix = outer.left, iy = outer.top;
  if (iw > ow || ih > oh)
  {
    if (grow == '-' || grow == '*')
    {
      const double rx = double(ow)/iw;
      const double ry = double(oh)/ih;
      const double r = rx < ry ? rx : ry;
      ih = int(ih*r);
      iw = int(iw*r);
    }
  } else
  if (iw < ow && ih < oh)
  {
    if (grow == '+' || grow == '*')
    {
      const double rx = double(ow)/iw;
      const double ry = double(oh)/ih;
      if (rx < ry)
        ih = int(ih*rx);
      else
        iw = int(iw*ry);
    }
  }
  switch (halign)
  {
  case 'R': ix = outer.right-iw; break;
  case 'C': ix = (outer.left + outer.right - iw) / 2; break;
  default : break;
  }
  switch (valign)
  {
  case 'B': iy = outer.bottom-ih; break;
  case 'C': iy = (outer.top + outer.bottom - ih) / 2; break;
  default : break;
  }
  xvt_rect_set(&r, ix, iy, ix+iw, iy+ih);
  return r;
}


// @doc EXTERNAL

// @func Emette un suono di default 
void beep(int severity)
{ 
  xvt_sys_beep(severity);
}

///////////////////////////////////////////////////////////
// Event Handling
///////////////////////////////////////////////////////////

class TEvent_manager
{             
  enum { MAX = 16 };
  WINDOW _w[MAX];
  EVENT _e[MAX];
  int _begin, _end;
  
public:  
  TEvent_manager() : _begin(0), _end(0) {}
  void push(WINDOW win, const EVENT& event);
  void pop();
};

HIDDEN TEvent_manager EM;

void TEvent_manager::push(WINDOW w, const EVENT& e)
{    
  CHECK(w, "You shouldn't send events to NULL_WIN!");
  _w[_end] = w;
  _e[_end] = e;
  const int next = (_end+1) % MAX;
  if (next == _begin)
  {
    TString msg; msg.format(FR("Hey %s, clicca pi<70> piano!"), (const char*)user());
    xvt_dm_popup_message(msg);
  }
  else  
    _end = next;  
}

void TEvent_manager::pop()
{
  if (_begin != _end)
  {
    const int i = _begin;
    _begin = (++_begin) % MAX;                     // Other events may occur!
    xvt_win_dispatch_event(_w[i], &_e[i]);
  }  
  
  WINDOW cw = cur_win();
  if (cw != NULL_WIN)
  {
    TWindow* w = (TWindow*)xvt_vobj_get_data(cw);
    if (w != NULL)
      w->on_idle();
  }
  main_app().on_idle();
}

// @doc EXTERNAL

// @func Processa tutti gli eventi rimasti in coda
void do_events()
{ 
  xvt_app_process_pending_events();
  EM.pop();
}

// @doc EXTERNAL

// @func Permette di convertire un evento carattere in un codice carattere premuto
//
// @rdesc Ritorna il codice del carattere corrispondente all'evento
KEY e_char_to_key(
  const EVENT* ep) // @parm Evento da codificare

  // @comm Viene controllato se l'evento e' un e_car e viene tradotto, in caso
  //       controrio viene emesso un segnale d'errore.
{
  CHECK(ep->type == E_CHAR, "I can't convert a Non-E_CHAR event to a key");

  KEY key = ep->v.chr.ch;
  if (key < K_INS || key > K_HELP)
  {
    if (ep->v.chr.shift && (key < ' ' || key >= K_UP))
      key += K_SHIFT;
    //if (ep->v.chr.control && key >=  ' ') key += K_CTRL;
    if (ep->v.chr.control && (key > K_SHIFT || (key >= K_F1 && key <= K_F12) ||
        xvt_chr_is_alnum(key) || strchr("\r+-*/",key) != NULL)) 
      key += K_CTRL;
  }
  return key;
}

// @doc EXTERNAL

// @func Simula un evento

void dispatch_event(
  WINDOW win,      // @parm Finestra destinataria dell'evento
  const EVENT& e,  // @parm Evento da generare
  bool post) 
{ 
  if (post)
    EM.push(win, e);
  else
    xvt_win_dispatch_event(win, (EVENT*)&e);
}

// @doc EXTERNAL

// @func Simula la scelta di una voce di menu
void dispatch_e_menu(
  WINDOW win,    // @parm Finestra che contiene il menu
  MENU_TAG item) // @parm Voce del menu da selezionare

  // @xref <f dispatch_e_char> <f dispatch_e_scroll>
{
  EVENT e; memset(&e, 0, sizeof(e));
  e.type = E_COMMAND;
  e.v.cmd.tag = item;
  dispatch_event(win, e, true);
}

// @doc EXTERNAL

// @func Simula la scelta di una combinazione di caratteri
void dispatch_e_char(
  WINDOW win,  // @parm Finestra che contiene il menu
  KEY key)     // @parm Combinazione di caratteri da utilizzare

  // @xref <f dispatch_e_menu> <f dispatch_e_scroll>
{
  EVENT e; memset(&e, 0, sizeof(e));

  e.type = E_CHAR;

  if (key > K_CTRL)  
  { e.v.chr.control = TRUE; key -= K_CTRL;  }
  
  if (key > K_SHIFT) 
  { e.v.chr.shift   = TRUE; key -= K_SHIFT; }
  
  e.v.chr.ch = short(key);

  dispatch_event(win, e, TRUE);
}

// @doc EXTERNAL

// @func Simula uno scroll all'interno di una finestra
void dispatch_e_scroll(
  WINDOW win,  // @parm Finestra nella quale operare
  KEY key)     // @parm Tasto utilizzato per lo scroll nella finestra

  // @xref <f dispatch_e_menu> <f dispatch_e_char>
{
  EVENT e; memset(&e, 0, sizeof(e));
  EVENT_TYPE& t = e.type;
  SCROLL_CONTROL& w = e.v.scroll.what;
  short& p = e.v.scroll.pos;

  w = SC_NONE;

  switch(key)
  {
  case K_HOME:
    t = E_HSCROLL;
    w = SC_THUMB;
    p = 0;
    break;
  case K_LHOME:
    t = E_VSCROLL;
    w = SC_THUMB;
    p = 0;
    break;
  case K_UP:
    t = E_VSCROLL;
    w = SC_LINE_UP;
    break;
  case K_DOWN:
    t = E_VSCROLL;
    w = SC_LINE_DOWN;
    break;
  case K_BTAB:
    t = E_HSCROLL;
    w = SC_PAGE_UP;
    break;
  case K_TAB:
    t = E_HSCROLL;
    w = SC_PAGE_DOWN;
    break;
  case K_PREV:
    t = E_VSCROLL;
    w = SC_PAGE_UP;
    break;
  case K_NEXT:
    t = E_VSCROLL;
    w = SC_PAGE_DOWN;
    break;
  case K_LEFT:
    t = E_HSCROLL;
    w = SC_LINE_UP;
    break;
  case K_RIGHT:
    t = E_HSCROLL;
    w = SC_LINE_DOWN;
    break;
  default:
    break;
  };

  if (w != SC_NONE) 
    dispatch_event(win, e, FALSE);
}    

void set_xvt_hooks()
{
  xvt_vobj_set_attr(NULL_WIN,ATTR_ERRMSG_HANDLER, (long)error_hook);
  xvt_vobj_set_attr(NULL_WIN,ATTR_WIN_PM_DRAWABLE_TWIN, TRUE);

  long twin_style = xvt_vobj_get_attr(NULL_WIN,ATTR_WIN_PM_TWIN_STARTUP_STYLE);
  twin_style |= WSF_ICONIZABLE | WSF_CLOSE; // WSF_SIZE pare azzardato

  const int scx = xvt_vobj_get_attr(NULL_WIN, ATTR_SCREEN_WIDTH);
  const int scy = xvt_vobj_get_attr(NULL_WIN, ATTR_SCREEN_HEIGHT);

  TToken_string stres(ini_get_string(CONFIG_GUI, "Colors", "Resolution"), 'x');
  const int resx = stres.get_int(0);
  int resy = stres.get_int();
  if (resy <= 0)
    resy = scy*resx/scx;

  if (resx >= 240 && resx < scx)
  {
    const int fx = xvt_vobj_get_attr(NULL_WIN, ATTR_FRAME_WIDTH);
    const int fy = xvt_vobj_get_attr(NULL_WIN, ATTR_FRAME_HEIGHT);
    const int cy = xvt_vobj_get_attr(NULL_WIN, ATTR_TITLE_HEIGHT);
    const int width = resx + 2*fx;
    const int height = resy+ 2*fy + cy;
    const int deltax = (scx - width) / 2;
    const int deltay = (scy - height) / 2;
  
    RCT rct;
    rct.left   = deltax;
    rct.top    = deltay;
    rct.right  = deltax + width;
    rct.bottom = deltay + height;
    xvt_vobj_set_attr(NULL_WIN, ATTR_WIN_PM_TWIN_STARTUP_RCT, long(&rct));
  }
  else
    twin_style |= WSF_MAXIMIZED;  
  
  xvt_vobj_set_attr(NULL_WIN,ATTR_WIN_PM_TWIN_STARTUP_STYLE, twin_style);
}

// @doc INTERNAL

// @func Stabilisce i parametri standard dei controlli
void customize_controls(
  bool on) // @parm Permette di inizializzare (TRUE) o scaricare (FALSE) i parametri
{    
  if (on)
  {
    customize_colors();
    init_controls();
  }
  else
  {       
    free_controls();
  }
}

// @doc INTERNAL

// @func Permette di settare il font attivo nella finestra
void xvtil_set_font(
  WINDOW win,         // @parm Finestra nella quale settare il font
  const char* family, // @parm Nome del font da settare
  int style,          // @parm Stile da applicare al font
  int dim)            // @parm Dimensione del font
{
  CHECK(win != NULL_WIN, "Can't set the font in a NULL window");

  if ((family == NULL || *family == '\0') && 
      (style == XVT_FS_NONE || style == XVT_FS_BOLD) &&
      dim == 0)
  {
    xvt_dwin_set_font(win, xvtil_default_font(style == XVT_FS_BOLD));
  }
  else
  {
    XVT_FNTID font = xvt_dwin_get_font(TASK_WIN);
    if (family && *family)    xvt_font_set_family(font, family);
    if (dim != 0)             xvt_font_set_size(font, dim);
    if (style != XVT_FS_NONE) xvt_font_set_style(font, style);

    if (!xvt_font_is_mapped(font))
      xvt_font_map(font, win);
    
    xvt_dwin_set_font(win, font);
    xvt_font_destroy(font);
  }  
}

// @doc INTERNAL

// @func Permette di creare una finestra
//
// @rdesc Ritorna l'identificatore della finestra creata
WINDOW xvtil_create_window(
  WIN_TYPE wt,           // @parm Tipo di finestra da creare
  short x,               // @parm Coordinata x della finestra (espresso in caratteri)
  short y,               // @parm Coordinata y della finestra (espresso in caratteri)
  short dx,              // @parm Larghezza della finestra (espresso in caratteri)
  short dy,              // @parm Altezza della finestra (espresso in caratteri)
  const char* caption,   // @parm Titolo da assegnare alla finestra
  int menu,              // @parm Menu della finestra (definito nelle risorse, 0=senza)
  WINDOW parent,         // @parm Identificatore della finestra padre
  long flags,            // @parm Attributi della finestra
  EVENT_HANDLER eh,      // @parm Funzioni per la gestione degli eventi diretti alla finestra
  long app_data)         // @parm Puntatore alla classe C++ che gestisce la finestra

{
  RCT& rect = resize_rect(x, y, dx, dy, wt, parent);
  if (wt == WD_MODAL) 
    wt = W_DOC;
  WINDOW win = xvt_win_create(wt,
                              &rect,
                              (char*)caption,
                              menu, parent,
                              flags,
                              EM_ALL, eh,
                              app_data);
  CHECK(win, "Can't create a window: XVT error");

  if (x == 0 && y == 0 && dx == 0 && dy == 0)
    xvt_vobj_maximize(win); // Molto piu' preciso di resize_rect(0,0,0,0,parent)
  
	// Utile per migliorare il calcolo delle dimensioni dei caratteri
  xvt_dwin_set_font(win, xvtil_default_font());

  return win;
}

///////////////////////////////////////////////////////////
// Gestione Status bar
///////////////////////////////////////////////////////////

HIDDEN WINDOW _statbar = NULL_WIN;

// @doc INTERNAL

// @func Permette di creare la barra di stato del programma
//
// @rdesc Ritorna l'identificatore della barra di stato creata
WINDOW xvtil_create_statbar()
// @xref <f xvt_statbar_set> <f xvt_statbar_refresh>
{
  if (TASK_WIN != NULL_WIN) // Puo' succedere in chiusura menu
  {
    const int p_count = 4;
    char* p_list[p_count+1] =
    {
      "Status bar",
      "HEIGHT=24",
      "TASK_WIN",
      "FIELD_OFFSET=24",
      NULL
    };

    if (_statbar == NULL_WIN)
    {
      _statbar = statbar_create(0, 0, 600, 1024, 800, p_count, p_list, TASK_WIN, 0, 0, "");
      statbar_set_fontid(_statbar, xvtil_default_font());
    }
  }
  return _statbar;
}

// @doc INTERNAL

// @func Permette di settare una finestra con la barra di stato
void xvtil_statbar_set(
  const char* text, // @parm Testo da inserire nella barra di stato
  bool def)         // @parm (default FALSE)

  // @comm Nella barra di stato vi e' sempre presente la data del sistema
  //
  // @xref <f xvt_create_statbar> <f xvt_statbar_refresh>
{                    
  if (_statbar != NULL_WIN)
  {
    TToken_string t(80, '\t');
    t.add(text);
    t.add(ini_get_string(CONFIG_DITTA, "Main", "RAGSOC")); // NON aprire pi<70> LF_NDITTE
    TApplication& a = main_app();
    t.add(a.title());
    if (def)                                          
      statbar_set_default_title(_statbar, t);
    statbar_set_title(_statbar, t);
  }  
}

// @doc INTERNAL

// @func Setta il testo standard della barra di stato
void xvtil_statbar_refresh()
  // @xref <f xvt_create_statbar> <f xvt_statbar_set>
{
  if (_statbar)
    statbar_set_title(_statbar, NULL);
}

void xvtil_statbar_destroy()
{
  if (_statbar != NULL_WIN && statbar_destroy(_statbar))
    _statbar = NULL;
}

int xvtil_statbar_height()
{
  int h = 0;
  if (_statbar != NULL_WIN)
  {
    RCT rct; xvt_vobj_get_outer_rect(_statbar, &rct);
    h = rct.bottom - rct.top;
  }
  return h;
}

static bool xvtil_popup_something(int severity, const char* msg)
{
  if (ADVANCED_GRAPHICS && ANIMATED_BOXES && is_power_reseller())
  {
    switch (severity)
    {
    case  1: xvt_dm_popup_warning(msg); break;
    case  2: xvt_dm_popup_error(msg); break;
    default: xvt_dm_popup_message(msg); break;
    }
  }
  else
  {
    beep(severity);
    xvtil_statbar_set(msg);
  }
  return false;
}

bool xvtil_popup_message(const char* msg)
{ return xvtil_popup_something(0, msg); }

bool xvtil_popup_warning(const char* msg)
{ return xvtil_popup_something(1, msg); }

bool xvtil_popup_error(const char* msg)
{ return xvtil_popup_something(2, msg); }

bool xvtil_system_error(unsigned long error, ...)
{ 
  va_list args;
  va_start(args, error);
  LPSTR messageBuffer = NULL;
  size_t size = ::FormatMessageA(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM,
                                 NULL, error, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), 
                                 (LPSTR)&messageBuffer, 0, &args);
  ::MessageBoxA(0, messageBuffer, NULL, MB_SERVICE_NOTIFICATION | MB_ICONSTOP | MB_OK);
  ::LocalFree(messageBuffer);
  va_end(args);
  return false;
}


///////////////////////////////////////////////////////////                      
// Test menu
///////////////////////////////////////////////////////////                      

HIDDEN bool test_menu_tag(MENU_ITEM* mi, MENU_TAG tag)
{              
  while (mi->tag)
  {
    if (mi->tag == tag) return TRUE;
    if (mi->child != NULL) 
    {
      const bool ok = test_menu_tag(mi->child, tag);
      if (ok) return TRUE;
    }  
    mi++;
  }  
  return FALSE;
}

// @doc INTERNAL

// @func Controlla se e' esiste una voce del menu'
//
// @rdesc Ritorna i seguenti valori
//
// @flag TRUE | Se esiste la voce di menu'
// @flag FALSE | Se non esiste la voce di menu'
bool xvtil_test_menu_tag(
  MENU_TAG tag) // @parm Menu' nel quale cercare la voce

{ 
	bool ok = FALSE;
  MENU_ITEM *mi = xvt_menu_get_tree(TASK_WIN);
	if (mi)
	{
    ok = test_menu_tag(mi, tag);
    xvt_res_free_menu_tree(mi);
	}
  return ok;
}

// @doc INTERNAL

// @func Permette di convertire in attributi grafici i codici caratteri usati
//       dalle funzioni di stampa
//
// @rdesc Ritorna il codice del colore convertito in attributo grafico
COLOR trans_color(
  char c) // @parm Codice carattere da convertire
{          
  COLOR col = COLOR_WHITE;
  switch (c) 
  {
  case 'b':  col = COLOR_BLUE;      break;
  case 'c':  col = COLOR_CYAN;      break;
  case 'd':  col = COLOR_DKGRAY;    break;
  case 'g':  col = COLOR_GREEN;     break;
  case 'k':  col = COLOR_GRAY;      break;
  case 'l':  col = COLOR_LTGRAY;    break;
  case 'm':  col = MASK_BACK_COLOR; break;
  case 'n':  col = COLOR_BLACK;     break;
  case 'r':  col = COLOR_RED;       break;
  case 'v':  col = COLOR_MAGENTA;   break;
  case 'w':  col = COLOR_WHITE;     break;
  case 'y':  col = COLOR_YELLOW;    break;
  default :  NFCHECK("trans_color: Undefined color '%c'", c); break;
  }
  return col; 
}

// @doc INTERNAL

// @func Permette di converitire lo stile del pattern in attributi grafici da
//       codici carattere.
//
// @rdesc Ritorna il pattern convertito
PAT_STYLE trans_brush(
  char p) // @parm Codice carattere da convertire
{
  switch (p)
  {
  case 'n' :  
    return PAT_NONE;  
  case 'h' :  
    return PAT_HOLLOW;
  case 's' :  
    return PAT_SOLID;
  case '-' :  
    return PAT_HORZ;   
  case '|' :  
    return PAT_VERT;
  case '/' :  
    return PAT_FDIAG;  
  case '\\': 
    return PAT_BDIAG;
  case 'X' :  
    return PAT_DIAGCROSS;
  case '+' :  
    return PAT_CROSS;    
    default  : 
    CHECK(0,"trans_brush: Undefined pattern"); break;
  }
  return PAT_NONE; 
}

// @doc INTERNAL

// @func Permette di convertire lo stile della penna da codice carattere
//
// @rdesc Ritorna lo stilo convertito
PEN_STYLE trans_pen(
  char p) // @parm Codice carattere da convertire
{    
  PEN_STYLE ps = P_SOLID;
  switch (p)
  {
  case 'n' : 
    ps = P_SOLID; break;
  case '.' : 
    ps = P_DOT; break;
  case '-' : 
    ps = P_DASH; break;
  default: 
    CHECK(0, "trans_pen: Undefined pattern"); break;
  }
  return ps;
}