campo-sirio/xvaga/xvaga.cpp

#include "wxinc.h"

#include <wx/clipbrd.h>
#include <wx/calctrl.h>
#include <wx/colordlg.h>
#include <wx/dialup.h>
#include <wx/fileconf.h>
#include <wx/filename.h>
#include <wx/fontdlg.h>
#include <wx/image.h>
#include <wx/filefn.h>
#include <wx/snglinst.h>
#include <wx/statline.h>
#include <wx/sysopt.h>
#include <wx/thread.h>
#include <wx/tokenzr.h>
#include <wx/aui/aui.h>

#include "xvt.h"
#include "statbar.h"

#include "agasys.h"
#include "fstrcmp.h"
#include "matche.h"
#include "xvtwin.h"

#ifdef WIN32
#include "oswin32.h"
#else
#include <errno.h>
#include <unistd.h>
#include "oslinux.h"
#include <wx/dcps.h>
#include <wx/hash.h>
#endif

#define XVT_ASSERT(test) _AssertBox((test), __FUNCTION__, __FILE__, __LINE__)
#define CAST_WIN(win,w) wxWindow& w = *wxStaticCast((wxObject*)win, wxWindow);
#define CAST_TWIN(win,w) TwxWindow& w = *wxStaticCast((wxObject*)win, TwxWindow);
#define CAST_TDC(win,dc) TDC& dc = GetTDCMapper().GetTDC(win);
#define CAST_DC(win,dc) wxDC& dc = GetTDCMapper().GetDC(win);
#define CAST_FONT(font_id, font) TFontId& font = *wxStaticCast(font_id, TFontId);

wxWindow* _mouse_trapper = NULL;
RCT       _startup_rect = { 0,0,0,0 };
long      _startup_style = 0;
wxString  _startup_dir;
wxString  _strDefaultStatbarText;
wxString  _appl_name;
wxLocale* _locale = NULL;

static wxHashTable _nice_icons;
static XVT_ERRMSG_HANDLER _error_handler = NULL;

const wxString& _GetAppTitle()
{ return _appl_name; }

class TMessageBox : public wxDialog
{
protected:
  void OnButton(wxCommandEvent& evt);
  void AddButton(wxSizer* sz, int id, int ico);
  DECLARE_EVENT_TABLE()

public:
  TMessageBox(const wxString& msg, int nStyle);
};

BEGIN_EVENT_TABLE(TMessageBox, wxDialog)
  EVT_BUTTON(wxID_ANY, TMessageBox::OnButton)
END_EVENT_TABLE()

void TMessageBox::OnButton(wxCommandEvent& evt)
{
  int ec = wxCANCEL;
  switch (evt.GetId())
  {
  case wxID_YES: ec = wxYES;    break;
  case wxID_OK : ec = wxOK;     break;
  case wxID_NO : ec = wxNO;     break;
  default      : ec = wxCANCEL; break;
  }
  EndModal(ec);
}

void TMessageBox::AddButton(wxSizer* sz, int id, int WXUNUSED(ico))
{
  sz->Add(new wxButton(this, id, wxEmptyString, wxDefaultPosition, 
                       wxSize(80, 32)), 0, wxALL, 4);
}

TMessageBox::TMessageBox(const wxString& msg, int nStyle)
           : wxDialog(NULL, wxID_ANY, _GetAppTitle(), wxDefaultPosition, wxDefaultSize,
                      wxCAPTION | wxRAISED_BORDER)
{
  wxBoxSizer* sizer = new wxBoxSizer(wxVERTICAL);
  SetSizer(sizer);

  wxBoxSizer* sz1 = new wxBoxSizer(wxHORIZONTAL);
  sizer->Add(sz1);
  int nIco = 162;
  if (nStyle & wxICON_ERROR) nIco = 201;
  if (nStyle & wxICON_QUESTION) nIco = 202;
  if (nStyle & wxICON_EXCLAMATION) nIco = 203;
  const int nBorder = 8;
  sz1->Add(new wxStaticBitmap(this, nIco, _GetToolResource(nIco, 64)), 0, wxALL, nBorder);
  wxStaticText* ss = new wxStaticText(this, wxID_ANY, wxEmptyString);
  ss->Wrap(160);
  ss->SetLabel(msg);
  sz1->Add(ss, 0, wxALL | wxALIGN_CENTER | wxALIGN_CENTER_VERTICAL, nBorder);
  
  sizer->Add(new wxStaticLine(this), 0, wxALL | wxEXPAND, nBorder);

  wxBoxSizer* sz2 = new wxBoxSizer(wxHORIZONTAL);
  sizer->Add(sz2, 0, wxALIGN_CENTER);
  if (nStyle & wxYES_NO)
  {
    SetAffirmativeId(wxID_YES);
    if (nStyle & wxNO_DEFAULT)
    {
      AddButton(sz2, wxID_NO,  102);
      AddButton(sz2, wxID_YES, 101);
    }
    else
    {
      AddButton(sz2, wxID_YES, 101);
      AddButton(sz2, wxID_NO,  102);
    }
  }
  if (nStyle & wxOK)
  {
    SetAffirmativeId(wxID_OK);
    AddButton(sz2, wxID_OK, 101);
  }
  if (nStyle & wxCANCEL)
  {
    SetEscapeId(wxID_CANCEL);
    AddButton(sz2, wxID_CANCEL, 102);
  }

  sizer->SetSizeHints(this);

  if (nStyle & wxCENTRE)
    Centre();
}

int _MessageBox(const wxString& msg, int nStyle)
{
  xvt_dm_post_speech(msg, 1, TRUE);

//int ret = ::wxMessageBox(msg, _GetAppTitle(), nStyle);
  TMessageBox dlg(msg, nStyle);
  const int ret = dlg.ShowModal(); 

  switch(ret)
  {
  case wxOK : xvt_dm_post_speech("ok",      7, TRUE); break;
  case wxYES: xvt_dm_post_speech("si",      7, TRUE); break;
  case wxNO : xvt_dm_post_speech("no",      7, TRUE); break;
  default   : xvt_dm_post_speech("annulla", 7, TRUE); break;
  }
  return ret;
}

void _AssertBox(bool test, const char* func, const char* file, int line)
{
	if (!test)
	{
		bool display = (_error_handler == NULL) || (_error_handler(SEV_FATAL, NULL) == FALSE);
    if (display)
		{
    	wxString strMessage;
      strMessage.Printf("Sorry, the application passed some invalid parameters to\nfunction %s in file %s at line %d .", 
                        func, file, line);
      _MessageBox(strMessage, wxOK|wxICON_ERROR);
		}
	}
}

void xvt_sys_sorry_box(const char* func, const char* file, int line)
{
  static wxHashTable sorry(wxKEY_STRING);
	if (sorry.Get(func) == NULL)
	{
		sorry.Put(func, &sorry); // Dummy
		wxString strMessage;
    strMessage.Printf("Function %s in file %s at line %d\nis not implemented yet: be patient...", 
                      func, file, line);
    _MessageBox(strMessage, wxOK | wxICON_WARNING);
	}
}

void xvt_sys_deprecated_box(const char* func, const char* file, int line)
{
  static wxHashTable deprecated;
	if (deprecated.Get(func) == NULL)
	{
		deprecated.Put(func, &deprecated); // Dummy
    wxString strMessage;
    strMessage.Printf("Function %s in file %s at line %d is deprecated:\nYou can blame Guy for this, if you're bold enough!", 
                      func, file, line);
    _MessageBox(strMessage, wxOK | wxICON_WARNING);
	}
}

static bool RectIntersect(const wxRect &rect1, const wxRect &rect2)
{
	if (rect1.GetRight() < rect2.GetLeft())
  	return false;
	if (rect2.GetRight() < rect1.GetLeft())
  	return false;
	if (rect1.GetBottom() < rect2.GetTop())
  	return false;
	if (rect2.GetBottom() < rect1.GetTop())
  	return false;
	return true;
}

wxString GetResourceIni()
{
	wxString strName;
  strName = _startup_dir;
  strName += "/res/resource.ini";
  return strName;
}

wxString _GetResourceName(const char* type, int rid)
{
	wxString strName(type); strName << "s";
  wxString strKey;  strKey.Printf("%d", rid);
	wxString val;

#ifdef WIN32
  char* buff = val.GetWriteBuf(260);
  ::GetPrivateProfileString(strName, strKey, "", buff, 260, GetResourceIni());
  val.UngetWriteBuf();
#else
	wxFileConfig ini("", "", GetResourceIni());
  strName.insert(0, '/');
	ini.SetPath(strName);
  ini.Read(strKey, &val);
#endif

	if (!val.IsEmpty())
	{
		strName = _startup_dir;
		strName += "/custom/";
		strName += val;
    if (!wxFileExists(strName))
    {
      strName = _startup_dir;
		  strName += "/res/";
		  strName += val;
    }
	}
	else
		strName.Empty();
	return strName;
}

const wxIcon& _GetIconResource(int rid)
{
  wxIcon* icon = wxDynamicCast(_nice_icons.Get(rid), wxIcon);
  if (icon == NULL)
	{
		wxString strName = _GetResourceName("Icon", rid);
		if (::wxFileExists(strName))
		{
			icon = new wxIcon(strName, wxBITMAP_TYPE_ICO);
		}
		else
    {
		  icon = wxDynamicCast(_nice_icons.Get(ICON_RSRC), wxIcon);
      if (icon == NULL)
      {
        strName.Printf("%d", ICON_RSRC);
        icon = new wxIcon(strName); // Icona di salvezza
      }
    }
    _nice_icons.Put(rid, icon);
	}
	return *icon;
}

const wxCursor* GetCursorResource(int rid)
{
	static wxHashTable _nice_cursors;
  const wxCursor* cursor = wxDynamicCast(_nice_cursors.Get(rid), wxCursor);
  if (cursor == NULL)
	{
		switch (rid)
		{
    case CURSOR_CROCE: cursor = new wxCursor(wxCURSOR_CROSS);	break;
		case CURSOR_IBEAM: cursor = new wxCursor(wxCURSOR_IBEAM);	break;
		default:
			{
				const wxString strName = _GetResourceName("Cursor", rid);
				if (::wxFileExists(strName))
				{
          if (strName.Find(".ico") > 0)
            cursor = new wxCursor(strName, wxBITMAP_TYPE_ICO);
          else
					  cursor = new wxCursor(strName, wxBITMAP_TYPE_CUR);

					if (!cursor->Ok())
					{
						delete cursor;
						cursor = NULL;
					}
				}
			}
			break;
		}
		if (cursor == NULL)
		{
    	XVT_ASSERT(false);
			cursor = wxSTANDARD_CURSOR;
		}
		_nice_cursors.Put(rid, (wxCursor*)cursor);
	}
	return cursor;
}

///////////////////////////////////////////////////////////
// Font cache
///////////////////////////////////////////////////////////

WX_DECLARE_HASH_MAP(wxString, wxFont*, wxStringHash, wxStringEqual, wxFontHashMap);

class TFontCache
{
  wxFontHashMap* m_map;

public:
  wxFont& FindOrCreate(int pointSize, int family, int style, int weight,
                       bool underline, const wxString& face);
  void Destroy();
  TFontCache() : m_map(NULL) { }
  ~TFontCache() { Destroy(); }

} XVT_FONT_CACHE;

void TFontCache::Destroy() 
{ 
  if (m_map)
  {
    m_map->clear(); 
//    delete m_map; // NON funziona ma non si capisce perche': PAZIENZA!
    m_map = NULL; 
  }
}

wxFont& TFontCache::FindOrCreate(int pointSize, int family, int style, int weight,
                                 bool underline, const wxString& face)
{
  if (m_map == NULL)
    m_map = new wxFontHashMap; 
  
  wxString key;
  key.Printf("%s_%d_%d_%d_%d", face, pointSize, style, weight, underline);
  wxFont* pFont = (*m_map)[key];
  if (pFont == NULL)
  {
    pFont = new wxFont(pointSize, family, style, weight, underline, face);
    pFont->SetPointSize(pointSize);  // Colpo di classe indispensabile per i PDF :-)
    (*m_map)[key] = pFont;
  }
  return *pFont;
}

///////////////////////////////////////////////////////////
// Speech support
///////////////////////////////////////////////////////////

// 0   Errors
// 1   Warnings
// 2   Messages
// 3   Requests
// 7   Buttons 
static int m_nSpeechMode = 0;

void xvt_dm_enable_speech(int mode)
{
#ifdef SPEECH_API
  m_nSpeechMode = mode;
#ifdef WIN32
  if (m_nSpeechMode != 0)
  {
    if (!OsWin32_InitializeSpeech())
      m_nSpeechMode = 0;
  }
  else
  {
    OsWin32_DeinitializeSpeech();
  }
#endif
#endif
}

///////////////////////////////////////////////////////////
// XVT
///////////////////////////////////////////////////////////

void xvt_app_allow_quit(void)
{
  wxTheApp->ExitMainLoop();  // Gi<47> lo fa la destroy
}

XVTDLL void xvt_app_pre_create(void)
{
  DIRECTORY dir;
  xvt_fsys_get_default_dir(&dir); // Init Startup Directory
  wxString strResPath = dir.path; strResPath += "/res";

  _locale = new wxLocale(wxLANGUAGE_DEFAULT); // wxLANGUAGE_ITALIAN
  _locale->AddCatalogLookupPathPrefix(strResPath);
  _locale->AddCatalog("wxstd", wxLanguage(_locale->GetLanguage()), NULL);

 	::wxInitAllImageHandlers();

#ifdef WIN32
  if (::wxDisplayDepth() >= 32 && wxTheApp->GetComCtl32Version() >= 600)
    wxSystemOptions::SetOption(wxT("msw.remap"), 2);
  else
    wxSystemOptions::SetOption(wxT("msw.remap"), 0);
#endif

#ifdef SPEECH_API
  xvt_dm_enable_speech(0xFF);
#endif
}

void xvt_app_create(int argc, char **argv, unsigned long WXUNUSED(flags),
										EVENT_HANDLER eh, XVT_CONFIG *config)
{
	_task_win_handler = eh;
	_appl_name = config->appl_name;

	const wxString title = config->taskwin_title;

	wxPoint pos = wxDefaultPosition;
	wxSize size = wxDefaultSize;
	long style = wxDEFAULT_FRAME_STYLE;

  wxWindow* pParent = NULL;
  bool bHasMenu = true, bCanChangeFirm = true;

#ifdef WIN32
  HWND hwndParent = (HWND)OsWin32_FindMenuContainer();
  if (hwndParent != NULL)
  {
    pParent = new wxWindow;
    pParent->AssociateHandle(hwndParent);
    const wxSize szWin = pParent->GetSize();
    const wxSize szCli = pParent->GetClientSize();
    xvt_rect_set(&_startup_rect, 0, 0, szWin.x, szWin.y);
    style = wxSYSTEM_MENU;  // Lo stile si riduce al minimo: niente cornici

    bHasMenu = (szWin.y - szCli.y) < 2;
    bCanChangeFirm = false;
  }
#endif
  
  if (_startup_rect.right > _startup_rect.left)
  {
	  pos.x = _startup_rect.left;
	  pos.y = _startup_rect.top;
	  size.x = _startup_rect.right - _startup_rect.left;
	  size.y = _startup_rect.bottom - _startup_rect.top;
  }
  else
  {
#ifdef WIN32
		style |= wxMAXIMIZE;
#else
	  style &= ~wxMAXIMIZE;
    const wxRect rect = wxGetClientDisplayRect();
    pos = rect.GetPosition();
    size = rect.GetSize();
#endif
  }

  if (_startup_style & WSF_NO_TASKBAR)
    style |= wxFRAME_NO_TASKBAR;

  _task_win = new TTaskWin(ICON_RSRC, title, pos, size, style);
  _task_win->SetBackgroundStyle(wxBG_STYLE_CUSTOM); // Lo sfondo viene disegnato nella OnPaint
	_nice_windows.Put((WINDOW)_task_win, _task_win);

  if (pParent != NULL)
  {
    _task_win->Reparent(pParent);
    pParent->DissociateHandle();
    pParent = NULL;
  }

  if (bHasMenu)
  {
	  wxMenu* Menus[3];
	  wxString Title[3];
	  Title[0] = "&File";
    Menus[0] = new wxMenu;
    
    if (bCanChangeFirm)
    {
	    Menus[0]->Append(M_FILE_NEW, "Scelta &Ditta...");
	    Menus[0]->AppendSeparator();
    }
	  Menus[0]->Append(M_FILE_PG_SETUP, "&Impostazione Stampante...");
	  Menus[0]->Append(M_FILE_PRINT, "&Stampa");
	  Menus[0]->AppendSeparator();
	  Menus[0]->Append(M_FILE_QUIT, "&Fine");
	  Title[1] = "&Modifica";
    Menus[1] = new wxMenu;
	  Menus[1]->Append(M_EDIT_CUT, "&Taglia\tCtrl+X");
	  Menus[1]->Append(M_EDIT_COPY, "&Copia\tCtrl+C");
	  Menus[1]->Append(M_EDIT_PASTE, "&Incolla\tCtrl+V");
	  Menus[1]->Append(M_EDIT_CLEAR, "&Elimina\tCanc");
	  Title[2] = "&?";
    Menus[2] = new wxMenu;
    Menus[2]->Append(M_HELP_CONTENTS, "&Sommario");
    Menus[2]->Append(M_HELP_ONCONTEXT, "&Aiuto contestuale");
    Menus[2]->AppendSeparator();
    Menus[2]->Append(M_FILE_ABOUT, "&Informazioni");
  	
  #ifdef WIN32
    wxMenuBar* pMenubar = new wxMenuBar(3, Menus, Title);
  #else
	  wxMenuBar* pMenubar = new wxMenuBar();
    for (int i= 0; i < 3; i++)
      pMenubar->Append(Menus[i], Title[i]);
  #endif
	  _task_win->SetMenuBar(pMenubar);
  }

  if (style & wxMAXIMIZE)
		_task_win->Maximize();
  _task_win->Show();

  wxApp* a = wxTheApp;
  a->SetTopWindow(_task_win);

	EVENT e; memset(&e, 0, sizeof(e));
  e.type = E_CREATE;
	long ret = _task_win_handler((WINDOW)_task_win, &e);
	if (ret != 0)
  {
    // Simula main loop
	  xvt_app_process_pending_events();
  }
	a->ExitMainLoop(); // Non entrare nel main loop di wxWindows
}

void xvt_app_destroy(void)
{
	wxTheApp->ExitMainLoop();
  if (_task_win != NULL)
    _task_win->Destroy();

#ifdef SPEECH_API
  xvt_dm_enable_speech(0x00);
#endif

  if (_locale != NULL)
  {
    delete _locale;
    _locale = NULL;
  }
}

DRAW_CTOOLS* xvt_app_get_default_ctools(DRAW_CTOOLS *ct)
{	
	XVT_ASSERT(ct != NULL);
	TDC dc(NULL);
	memcpy(ct, &dc._dct, sizeof(DRAW_CTOOLS));
	return ct;
}

void xvt_app_process_pending_events(void)
{
  wxApp* a = wxTheApp;  // Memorizzo il risultato di wxGetInstance
	if (a != NULL)
  {
    while (a->Pending())
	    a->Dispatch();
    a->ProcessIdle();  // Necessario per wxAUI
  	a->Yield(true);    // Non so se serva veramente
  }
}

///////////////////////////////////////////////////////////
// Clipboard functions
///////////////////////////////////////////////////////////

static DATA_PTR ptrClipboardData = NULL;

char* xvt_cb_alloc_data(long size)
{
	xvt_cb_free_data();
	if (size > 0)
    ptrClipboardData = xvt_mem_zalloc(size+1);
	return ptrClipboardData;
}

BOOLEAN xvt_cb_close(void)
{
	wxTheClipboard->Close();
	wxTheClipboard->Flush();
	return TRUE;
}

void xvt_cb_free_data(void)
{
	if (ptrClipboardData != NULL)
	{
		xvt_mem_free(ptrClipboardData);
		ptrClipboardData = NULL;
	}
}

char* xvt_cb_get_data(CB_FORMAT cbfmt, char *name, long *sizep)
{
	if (xvt_cb_has_format(cbfmt, name))
  {
    wxTextDataObject data;
    wxTheClipboard->GetData(data);
		*sizep = data.GetDataSize();
    if (*sizep > 0)
    {
		  xvt_cb_alloc_data(*sizep);
      memcpy(ptrClipboardData, data.GetText(), *sizep);
      (*sizep)--; // Elimino lo '/0' finale che non piace a XI
		  return ptrClipboardData;
    }
	}
	sizep = 0;
	return NULL;
}

BOOLEAN xvt_cb_has_format(CB_FORMAT fmt, char* WXUNUSED(name))
{
	return (fmt == CB_TEXT) && wxTheClipboard->IsSupported(wxDF_TEXT);
}

BOOLEAN xvt_cb_open(BOOLEAN WXUNUSED(writing))
{
	return wxTheClipboard->Open();
}

BOOLEAN xvt_cb_put_data(CB_FORMAT cbfmt, char* WXUNUSED(name), long WXUNUSED(size), PICTURE WXUNUSED(pic))
{
	BOOLEAN ok = cbfmt == CB_TEXT && ptrClipboardData != NULL;
	if (ok)
		wxTheClipboard->SetData(new wxTextDataObject(ptrClipboardData));
	return ok;
}

///////////////////////////////////////////////////////////
// Debug functions
///////////////////////////////////////////////////////////

void xvt_debug_printf(const char* fmt, ...)
{
#ifndef NDEBUG
  static FILE* f = NULL;
  if (f == NULL)
    f = fopen("trace.log", "w");
  if (f != NULL)
  {
		char msg[256];
		va_list argptr;
		va_start(argptr,fmt);
		vsprintf(msg,fmt,argptr);
		va_end(argptr);
    fprintf(f, "%s\n", msg);
    fflush(f);
  }
#endif
}

///////////////////////////////////////////////////////////
// Dongle functions
///////////////////////////////////////////////////////////

BOOLEAN xvt_dongle_hl_crypt(unsigned short* data) // Array di 4 words (8 bytes)
{
#ifdef WIN32
  return OsWin32_HL_Crypt(data);
#else
  return OsLinux_HL_Crypt(data);
#endif
}

BOOLEAN xvt_dongle_hl_login(unsigned short address, const unsigned char* label, const unsigned char* password)
{
#ifdef WIN32
  return OsWin32_HL_Login(address, label, password);
#else  
  return OsLinux_HL_Login(address, label, password);
#endif
}

BOOLEAN xvt_dongle_hl_logout()
{
#ifdef WIN32
  return OsWin32_HL_Logout();
#else
  return OsLinux_HL_Logout();
#endif
}

BOOLEAN  xvt_dongle_hl_read(unsigned short reg, unsigned short* data)
{
#ifdef WIN32
  return OsWin32_HL_Read(reg, data);
#else
  return OsLinux_HL_Read(reg, data);
#endif
}

BOOLEAN xvt_dongle_hl_read_block(unsigned char* data)
{
#ifdef WIN32
  return OsWin32_HL_ReadBlock(data);
#else
  return OsLinux_HL_ReadBlock(data);
#endif
}

BOOLEAN xvt_dongle_hl_write(unsigned short reg, unsigned short data)
{
#ifdef WIN32
  return OsWin32_HL_Write(reg, data);
#else
  return OsLinux_HL_Write(reg, data);
#endif
}

BOOLEAN xvt_dongle_sl_crypt(unsigned short* data)
{
#ifdef WIN32
  return OsWin32_SL_Crypt(data);
#else
  return OsLinux_SL_Crypt(data);
#endif
}

BOOLEAN xvt_dongle_sl_login(const unsigned char* label, const unsigned char* password)
{
#ifdef WIN32
  return OsWin32_SL_Login(label, password);
#else
  return OsLinux_SL_Login(label, password);
#endif
}

BOOLEAN xvt_dongle_sl_logout()
{
#ifdef WIN32
  return OsWin32_SL_Logout();
#else
  return OsLinux_SL_Logout();
#endif
}

BOOLEAN xvt_dongle_sl_read_block(unsigned short reg, unsigned short size, unsigned short* data)
{
#ifdef WIN32
  return OsWin32_SL_ReadBlock(reg, size, data);
#else
  return OsLinux_SL_ReadBlock(reg, size, data);
#endif
}

BOOLEAN xvt_dongle_sl_write_block(unsigned short reg, unsigned short size, const unsigned short* data)
{
#ifdef WIN32
  return OsWin32_SL_WriteBlock(reg, size, data);
#else
  return OsLinux_SL_WriteBlock(reg, size, data);
#endif
}

///////////////////////////////////////////////////////////
// Common dialogs
///////////////////////////////////////////////////////////

COLOR xvt_dm_post_choose_color(WINDOW win, COLOR xc)
{
  CAST_COLOR(xc, wc);

  wxColourData cd;
  cd.SetChooseFull(true);
  cd.SetColour(wc);
  for (int i = 0; i < 16; i++)
  {
    const unsigned char val   = (i & 0x8) ? 255 : 127;
    const unsigned char red   = (i & 0x1) ? val : 0;
    const unsigned char green = (i & 0x2) ? val : 0;
    const unsigned char blue  = (i & 0x4) ? val : 0;
    wxColour col(red, green, blue);
    cd.SetCustomColour(i, col);
  }

  CAST_WIN(win, w);
  wxColourDialog dialog(&w, &cd);
  if (dialog.ShowModal() == wxID_OK)
    xc = MAKE_XVT_COLOR(dialog.GetColourData().GetColour());

  return xc;
}

class TwxCalendarDlg : public wxDialog
{
  enum { ID_CAL = 1883 };
  wxDateTime& m_date;
  wxCalendarCtrl* m_cal;

protected:
  virtual bool TransferDataFromWindow();
  void OnCalendar(wxCalendarEvent& e);

public:
  TwxCalendarDlg(wxWindow* parent, const wxPoint& pnt, wxDateTime& date);

  DECLARE_EVENT_TABLE()
};

BEGIN_EVENT_TABLE(TwxCalendarDlg, wxDialog)
  EVT_CALENDAR(wxID_ANY, TwxCalendarDlg::OnCalendar)
END_EVENT_TABLE()

void TwxCalendarDlg::OnCalendar(wxCalendarEvent& WXUNUSED(e))
{
  wxCommandEvent evt(wxEVT_COMMAND_BUTTON_CLICKED, wxID_OK);
  AddPendingEvent(evt);
}

bool TwxCalendarDlg::TransferDataFromWindow()
{
  bool ok = wxDialog::TransferDataFromWindow();
  if (ok)
  {
    m_date = m_cal->GetDate();
  }
  return ok;
}

TwxCalendarDlg::TwxCalendarDlg(wxWindow* parent, const wxPoint& pnt, wxDateTime& date) 
              : wxDialog(parent, wxID_ANY, "Data", pnt, wxDefaultSize, wxRAISED_BORDER), m_date(date)
{

  m_cal = new wxCalendarCtrl(this, ID_CAL, m_date,
                             pnt, wxDefaultSize,
                             wxCAL_MONDAY_FIRST | wxCAL_SHOW_HOLIDAYS | wxCAL_SHOW_SURROUNDING_WEEKS);

  wxButton* button = new wxButton(this, wxID_OK, "OK");

  wxGridSizer* sizer = new  wxFlexGridSizer(2, 1, 8, 8);
  sizer->Add(m_cal, 0, wxALIGN_CENTER);
  sizer->Add(button, 0, wxALIGN_CENTER);
  SetSizer(sizer);
  sizer->SetSizeHints(this);
}

unsigned int xvt_dm_post_choose_date(WINDOW win, PNT pos, unsigned int ansidate)
{
  int d = ansidate%100;
  int m = (ansidate/100)%100;
  int y = ansidate / 10000;

  wxDateTime date;
  if (d >= 1 && d <= 31 && m >= 1 && m <= 12 && y > 1900)
    date.Set(d, wxDateTime::Month(m-1), y);
  else
    date = wxDateTime::Today();
  
  CAST_WIN(win, w);

  wxPoint pnt(pos.h, pos.v);
  if (pos.h < 0 || pos.v < 0)
    pnt = wxDefaultPosition;
  else
    pnt = w.ClientToScreen(pnt);

  wxDialog* dlg = new TwxCalendarDlg(&w, pnt, date);

  if (dlg->ShowModal() == wxID_OK)
  {
    d = date.GetDay();
    m = date.GetMonth()+1;
    y = date.GetYear();
    ansidate = y*10000 + m*100 + d;
  }
  dlg->Destroy();
  
  return ansidate;
}

BOOLEAN xvt_dm_post_speech(const char* text, int priority, BOOLEAN async)
{
  BOOLEAN ok = FALSE;
#ifdef SPEECH_API
  if ((m_nSpeechMode & (1 << priority)) != 0)
  {
#ifdef WIN32
    ok = OsWin32_Speak(text, async != 0);
#endif
  }
#endif
  return ok;
}

ASK_RESPONSE xvt_dm_post_ask(const char* Btn1, const char* Btn2, const char* Btn3, const char* fmt)
{
  int nFlags = wxCENTRE | wxICON_QUESTION | wxYES_NO;
  if (Btn3 == NULL)
  {
    if (wxStricmp(Btn1, "no") == 0)
      nFlags |= wxNO_DEFAULT;
  }
  else
    nFlags |= wxCANCEL;

  const int answer = _MessageBox(fmt, nFlags);
  return answer == wxYES ? RESP_DEFAULT : (answer == wxNO ? RESP_2 : RESP_3);
}

void xvt_dm_post_error(const char *fmt)
{
  _MessageBox(fmt, wxOK | wxCENTRE | wxICON_HAND);
}

void xvt_dm_post_fatal_exit(const char *fmt)
{
  xvt_dm_post_speech(fmt, 1, TRUE);
  wxLogFatalError(fmt);
  xvt_dm_post_speech("OK", 7, TRUE);
}

static wxString MakeFileName(const wxChar* name, const wxChar* ext)
{
  wxString f = name;
  if (ext && *ext)
  {
    if (*ext != '.')
      f += '.';
    f += ext;
  }
  return f;
}

static FL_STATUS xvt_dm_post_file_ask(FILE_SPEC *fsp, const char *msg, int flags)
{
	wxString path = fsp->dir.path;
	wxString name = MakeFileName(fsp->name, fsp->type);
	wxString extension = fsp->type;
  wxString mask = MakeFileName("*", fsp->type);

  wxString selectedname = wxFileSelector(msg, path, name, extension , mask, flags);
  if (selectedname.IsEmpty())
  	return FL_CANCEL;
  xvt_fsys_convert_str_to_fspec(selectedname, fsp);

  return FL_OK;
}

FL_STATUS xvt_dm_post_file_open(FILE_SPEC *fsp, const char *msg)
{
  const int flags = wxOPEN | wxFILE_MUST_EXIST;
  return xvt_dm_post_file_ask(fsp, msg, flags);
}

FL_STATUS xvt_dm_post_file_save(FILE_SPEC *fsp, const char *msg)
{
  const int flags = wxSAVE | wxOVERWRITE_PROMPT;
  return xvt_dm_post_file_ask(fsp, msg, flags);
}

FL_STATUS xvt_dm_post_dir_sel(DIRECTORY *dir)
{
  wxDirDialog dlg(_task_win);
	dlg.SetPath(dir->path);
	if (dlg.ShowModal() == wxID_OK)
	{
		xvt_fsys_convert_str_to_dir(dlg.GetPath(), dir);
		return FL_OK;
	}
	return FL_CANCEL;
}

BOOLEAN xvt_dm_post_font_sel(WINDOW win, XVT_FNTID font_id, PRINT_RCD* WXUNUSED(precp), unsigned long reserved)
{
	CAST_FONT(font_id, font);
	wxFontData data;
	data.SetInitialFont(font.Font(NULL, win));
	data.EnableEffects(reserved != 0);
  wxFontDialog dlg(_task_win, data);
	BOOLEAN ok = dlg.ShowModal() == wxID_OK;
  if (ok)
	{
    font.Copy(dlg.GetFontData().GetChosenFont());
    if (win == (WINDOW)_task_win)
    {
      EVENT e; memset(&e, 0, sizeof(EVENT));
	    e.type = E_FONT;
		  e.v.font.font_id = font_id;
	    _task_win_handler(win, &e);
    }
	}
	return ok;
}

void xvt_dm_post_message(const char *fmt)
{
  _MessageBox(fmt, wxOK | wxCENTRE | wxICON_INFORMATION);
}

void xvt_dm_post_note(const char *fmt)
{
  _MessageBox(fmt, wxOK | wxCENTRE | wxICON_EXCLAMATION);
}

char* xvt_dm_post_string_prompt(const char* message, char* response, int response_len)
{
	XVT_ASSERT(message && response && response_len > 0);
  wxTextEntryDialog dlg(NULL, message, _GetAppTitle(), response);
  if (dlg.ShowModal() == wxID_OK)
  {
    wxStrncpy(response, dlg.GetValue(), response_len);
    response[response_len-1] = '\0';
  }
  else
	  *response = '\0';
	return response;
}

void xvt_dm_post_warning(const char *fmt)
{
  _MessageBox(fmt, wxOK | wxCENTRE | wxICON_EXCLAMATION);
}

///////////////////////////////////////////////////////////
// Help system
///////////////////////////////////////////////////////////

struct XVAGA_HELP_INFO
{
	wxString m_strFilename;
	bool m_hlp;
} help_info;

XVT_HELP_INFO xvt_help_open_helpfile(FILE_SPEC* WXUNUSED(fs), unsigned long WXUNUSED(flags))
{
	return (XVT_HELP_INFO)&help_info;
}

void xvt_help_close_helpfile(XVT_HELP_INFO hi)
{
  if (hi == NULL_HELP_INFO)
		hi = (XVT_HELP_INFO)&help_info;
}

BOOLEAN xvt_help_process_event(XVT_HELP_INFO hi, WINDOW win, EVENT *ev)
{
  BOOLEAN bProcessed = FALSE;

#ifdef WIN32
	WXHWND hwnd = (WXHWND)xvt_vobj_get_attr(win, ATTR_NATIVE_WINDOW);
	switch (ev->type)
	{
	case E_COMMAND:
		bProcessed = OsWin32_Help(hwnd, "", ev->v.cmd.tag, NULL);
		break;
	case E_HELP:
		bProcessed = OsWin32_Help(hwnd, "", M_HELP_ONCONTEXT, (const char*)ev->v.help.tid);
		break;
  default:
		break;
	}
#endif // WIN32

	return bProcessed;
}

///////////////////////////////////////////////////////////
// Image handling
///////////////////////////////////////////////////////////

class TXVT_IMAGE : public wxImage
{
  DECLARE_DYNAMIC_CLASS(TXVT_IMAGE);

  int m_nDepth;
	bool m_bDirty;

#ifdef WIN32
  HBITMAP m_bitmap;
#else
 	wxBitmap* m_bitmap;
#endif

protected:
  void Destroy();

public:
	const wxImage& Image() const { return *this; }
	wxImage& Image() { m_bDirty = true; return *this; }
	
#ifdef WIN32
  HBITMAP Bitmap(wxDC& dc);
#else
  const wxBitmap& Bitmap(wxDC& dc);
#endif
  COLOR GetPixel(int x, int y) const;
  void SetPixel(int x, int y, COLOR color);
	
  TXVT_IMAGE() : m_bitmap(NULL), m_nDepth(0), m_bDirty(false) { }
  ~TXVT_IMAGE();
};

IMPLEMENT_DYNAMIC_CLASS(TXVT_IMAGE, wxImage);

#define CAST_TIMAGE(xvtimg, img) TXVT_IMAGE* img = wxDynamicCast(xvtimg, TXVT_IMAGE);
#define CAST_IMAGE(xvtimg, img) const wxImage* img = wxDynamicCast(xvtimg, wxImage);

COLOR TXVT_IMAGE::GetPixel(int x, int y) const
{
  // Chissa' perche' non esiste la GetRGB
  const long pos = XYToIndex(x, y) * 3;
  unsigned char* data = GetData() + pos;
  return XVT_MAKE_COLOR(data[0], data[1], data[2]);
}

void TXVT_IMAGE::SetPixel(int x, int y, COLOR color)
{
  SetRGB(x, y, XVT_COLOR_GET_RED(color), XVT_COLOR_GET_GREEN(color), XVT_COLOR_GET_BLUE(color));
  m_bDirty = true;
}


#ifdef WIN32

HBITMAP TXVT_IMAGE::Bitmap(wxDC& dc)
{
	if (m_bDirty || m_bitmap == NULL || dc.GetDepth() != m_nDepth)
	{
    Destroy();
    m_nDepth = dc.GetDepth();
    m_bitmap = OsWin32_CreateBitmap(*this, dc);
		m_bDirty = false;
	}
	return m_bitmap;
}

#else

const wxBitmap& TXVT_IMAGE::Bitmap(wxDC& dc)
{
	if (m_bDirty || m_bitmap == NULL || dc.GetDepth() != m_nDepth)
	{
    Destroy();
    m_nDepth = dc.GetDepth();
    m_bitmap = new wxBitmap(*this, m_nDepth);
		m_bDirty = false;
	}
	return *m_bitmap;
}

#endif

void TXVT_IMAGE::Destroy()
{
  if (m_bitmap != NULL)
#ifdef WIN32
    ::DeleteObject(m_bitmap);
#else
    delete m_bitmap;
#endif
  m_bitmap = NULL;
}

TXVT_IMAGE::~TXVT_IMAGE()
{
  Destroy();
}

///////////////////////////////////////////////////////////
// Font Handling
///////////////////////////////////////////////////////////

IMPLEMENT_DYNAMIC_CLASS(TFontId, wxObject);

void TFontId::Copy(const TFontId& rFont)
{
	m_strFace = rFont.m_strFace;
	m_nSize = rFont.m_nSize;
	m_wMask = rFont.m_wMask;
	m_win = rFont.m_win;
}

bool TFontId::IsEqual(const TFontId& rFont) const
{
	if (m_strFace != rFont.m_strFace)
		return false;
	if (m_nSize != rFont.m_nSize)
		return false;
	if (m_wMask != rFont.m_wMask)
		return false;
	return true;
}

const char* TFontId::FaceName() const
{
	if (m_strFace.IsEmpty())
		return XVT_FFN_COURIER;
	return m_strFace;
}

int TFontId::Family() const
{
	if (m_strFace.IsEmpty() || m_strFace == XVT_FFN_COURIER)
  	return wxMODERN;
	if (m_strFace == XVT_FFN_HELVETICA)
		return wxSWISS;
	if (m_strFace == XVT_FFN_TIMES)
		return wxROMAN;
	if (m_strFace == XVT_FFN_FIXED)
		return wxMODERN;
	if (m_strFace == XVT_FFN_SYSTEM)
		return wxDEFAULT;
	return wxSWISS;
}

int TFontId::Style() const
{
	return (m_wMask & XVT_FS_ITALIC) ? wxITALIC : wxNORMAL;
}

bool TFontId::Underline() const
{
	return (m_wMask & XVT_FS_UNDERLINE) != 0;
}

int TFontId::Weight() const
{
 	return (m_wMask & XVT_FS_BOLD) ? wxBOLD : wxNORMAL;
}

const wxFont& TFontId::Font(wxDC* dc, WINDOW win) const
{
 	int nSize = PointSize();
	if (win == PRINTER_WIN)
	{
    static wxDC* lastDC = NULL;
    static wxSize lastPPI;
		static double dPrintScale = 1.0;
		const wxSize ppi = dc->GetPPI();
		if (dc != lastDC || ppi != lastPPI)
		{
#ifdef WIN32
      const char* const DEFAULT_FONT_NAME = "Courier New";
#else
      const char* const DEFAULT_FONT_NAME = "Courier";
#endif
      const int nTarget10 = 10 * ppi.x;   // pixel in 10 pollici in larghezza
      const int cpi10 = 10 * 120 / nSize; // caratteri stimati in 10 pollici
      const wxString str('M', cpi10);     // stringa campione per stimare la larghezza  
      int nMin = 1, nMax = nSize*16;      // Limiti arbitrari
      int nBest = 0;
      while (nMin <= nMax)
      {
        const int nFontSize = (nMin+nMax)/2;

				wxFont courier(nFontSize, wxFIXED, wxNORMAL, wxNORMAL, FALSE, DEFAULT_FONT_NAME);
	  		dc->SetFont(courier);
				int tw;	dc->GetTextExtent(str, &tw, NULL);
        if (tw <= nTarget10)
        {
          nMin = nFontSize+1;
          nBest = nFontSize;
          if (tw == nTarget10)
            break;
        }
        else
          nMax = nFontSize-1;
      }
      if (nBest == 0)
        nBest = nMax;

#ifdef WIN32
      // Pezza per cercare di ovviare a dimensioni assurde calcolate dai sistemi Win *
      // Praticamente succede che il Courier 70 sia piu' piccolo del Curier 60
      // Per cui una volta candidata una dimensione (nBest) tramite le righe precedenti
      // cerco il primo font piu' piccolo che non sfondi
      bool bPrevGood = true;
      for (int i = 15; i > 0; i--)
      {
        const int nFontSize = nBest-i;
        wxFont courier(nFontSize, wxFIXED, wxNORMAL, wxNORMAL, FALSE, DEFAULT_FONT_NAME);

	  		dc->SetFont(courier);
				int tw, th;	dc->GetTextExtent(str, &tw, &th);
        if (tw > nTarget10 && bPrevGood)
        {
          nBest = nFontSize-1;
          break;
        }
        bPrevGood = tw <= nTarget10;
      }
#endif

      dPrintScale = double(nBest) / double(nSize);
#ifdef LINUX
     	dPrintScale /= 10.0; // * wxPostScriptDC::GetResolution()) / 72.0);
#endif
			lastDC = dc;
      lastPPI = ppi;
    }
		nSize = (int)(nSize * dPrintScale + 0.5); 
	}

  const wxFont& ff1 = XVT_FONT_CACHE.FindOrCreate(nSize, Family(), Style(), Weight(), Underline(), FaceName());
  if (ff1.GetPointSize() > 0)
    return ff1;

  XVT_FONT_CACHE.Destroy();
  const wxFont& ff2 = XVT_FONT_CACHE.FindOrCreate(nSize, Family(), Style(), Weight(), Underline(), FaceName());
  return ff2;
}

void TFontId::Copy(const wxFont& rFont)
{
	m_strFace = rFont.GetFaceName();
	m_nSize = rFont.GetPointSize();
	m_wMask = XVT_FS_NONE;
	if (rFont.GetUnderlined())
    m_wMask |= XVT_FS_UNDERLINE;
	if (rFont.GetWeight() >= wxBOLD)
    m_wMask |= XVT_FS_BOLD;
	if (rFont.GetStyle() == wxITALIC)
    m_wMask |= XVT_FS_ITALIC;
	m_win = NULL_WIN;
}

///////////////////////////////////////////////////////////
// Drawable windows
///////////////////////////////////////////////////////////

void xvt_dwin_clear(WINDOW win, COLOR col)
{
  if (win != NULL_WIN && win != PRINTER_WIN)
  {
    CAST_DC(win, dc);
    CAST_COLOR(col, colour);
    wxBrush* brush = wxTheBrushList->FindOrCreateBrush(colour, wxSOLID);
    dc.SetBackground(*brush);
    dc.Clear();
  }
}

void xvt_dwin_draw_arc(WINDOW win, const RCT* r, int sx, int sy, int ex, int ey)
{ 
  if (win != NULL_WIN && r != NULL)
  {
	  CAST_DC(win, dc);
    dc.DrawArc(sx, sy, ex, ey, (r->right+r->left)/2, (r->top+r->bottom)/2);
  }
}

void xvt_dwin_draw_gradient_circular(WINDOW win, const RCT* r, COLOR col1, COLOR col2, const PNT* center)
{
  if (win != NULL_WIN && r != NULL)
  {
    CAST_DC(win, dc);
    const wxRect rect = NormalizeRCT(r);
    CAST_COLOR(col1, color1);
    CAST_COLOR(col2, color2);

    if (center != NULL)
      dc.GradientFillConcentric(rect, color1, color2, wxPoint(center->h, center->v));
    else
      dc.GradientFillConcentric(rect, color1, color2);
  }
}

void xvt_dwin_draw_gradient_linear(WINDOW win, const RCT* r, COLOR col1, COLOR col2, int angle)
{ 
  if (win != NULL_WIN && r != NULL)
  {
	  CAST_DC(win, dc);
    const wxRect rect = NormalizeRCT(r);
    CAST_COLOR(col1, color1);
    CAST_COLOR(col2, color2);

    angle %= 360;
    if (angle < 0) 
      angle += 360;
    wxDirection dir = wxDOWN;
    switch (angle / 90)
    {
    case  0: dir = wxRIGHT; break;
    case  1: dir = wxUP; break;
    case  2: dir = wxLEFT; break;
    default: dir = wxDOWN; break;
    }

    dc.GradientFillLinear(rect, color1, color2, dir);
  }
}

void xvt_dwin_draw_icon(WINDOW win, int x, int y, int rid)
{
	const wxIcon& ico = _GetIconResource(rid);
  if (ico.IsOk())
  {
  	CAST_DC(win, dc);
    dc.DrawIcon(ico, x, y);
  }
}

static wxRect ComputeRect(const wxRect& rct, int h, int v, int k)
{
  const int sx = rct.x + h * rct.width / k;
  const int ex = rct.x + (h+1) * rct.width / k;
  const int sy = rct.y + v * rct.height / k;
  const int ey = rct.y + (v+1) * rct.height / k;
  return wxRect(sx, sy, ex-sx, ey-sy);
}

static void DrawImageOnDC(wxDC& dc, TXVT_IMAGE* image, const wxRect& dst, const wxRect& src)
{
#ifdef WIN32		
  if (!OsWin32_DrawBitmap(image->Bitmap(dc), dc, dst, src))
  {
    const int k = 4;
    for (int h = 0; h < k; h++)
    {
      for (int v = 0; v < k; v++)
      {
        const wxRect destin = ComputeRect(dst, h, v, k);
        wxRect source = ComputeRect(src, h, v, k);
        wxImage img = image->Image().GetSubImage(source);
        source.x = source.y = 0;
        wxBitmap bmp(img);
        OsWin32_DrawBitmap((HBITMAP)bmp.GetHBITMAP(), dc, destin, source);
      }
    }
  }
#else
  const wxBitmap& bmp = image->Bitmap(dc);
  const bool printing = is_printer_dc(&dc);
    
	if (src.GetPosition() == wxPoint(0,0) && src.GetSize() == dst.GetSize() && bmp.Ok())
		dc.DrawBitmap(bmp, dst.GetX(), dst.GetY(), !printing);
	else
	{
    wxImage img = image->Image().GetSubImage(src);
 		
		if (dst.GetHeight() < src.GetHeight() ||
		    dst.GetWidth() < src.GetWidth())
	 		img.Rescale(dst.GetWidth() * 4, dst.GetHeight() * 4);
 		img.Rescale(dst.GetWidth(), dst.GetHeight());
    wxBitmap bmp(img);
		dc.DrawBitmap(bmp, dst.GetX(), dst.GetY(), !printing);
 }
#endif
}

void xvt_dwin_draw_image(WINDOW win, XVT_IMAGE img, const RCT* dest, const RCT* source)
{
	CAST_TIMAGE(img, image);
	if (image != NULL)
	{
    if (xvt_dwin_is_update_needed(win, dest))
    {
		  CAST_DC(win, dc);
		  const wxRect src = NormalizeRCT(source);
		  const wxRect dst = NormalizeRCT(dest);
      DrawImageOnDC(dc, image, dst, src);
    }
	}
}

void xvt_dwin_draw_oval(WINDOW win, const RCT* rctp) 
{ 
  CAST_DC(win, dc);
	const wxRect rct = NormalizeRCT(rctp);
	dc.DrawEllipse(rct);
}

void xvt_dwin_draw_pie(WINDOW win, const RCT *rctp, int start_x, int start_y, int stop_x, int stop_y) 
{ SORRY_BOX(); }

void xvt_dwin_draw_polygon(WINDOW win, const PNT *lpnts, int npnts)
{
  if (lpnts != NULL && npnts > 1)
  {
    CAST_DC(win, dc);
    wxPoint* pt = new wxPoint[npnts];
    for (int i = 0; i < npnts; i++)
    {
      pt[i].x = lpnts[i].h;
      pt[i].y = lpnts[i].v;
    }
    dc.DrawPolygon(npnts, pt);
    delete pt;
  }
}

void xvt_dwin_draw_polyline(WINDOW win, const PNT *lpnts, int npnts)
{
  if (win != NULL_WIN && lpnts != NULL && npnts > 1) // Occorrono almeno 2 punti
  {
    xvt_dwin_draw_set_pos(win, lpnts[0]);
    for (int i = 1; i < npnts; i++)
      xvt_dwin_draw_line(win, lpnts[i]);
  }
}

void xvt_dwin_draw_rect(WINDOW win, RCT *rctp)
{
  CAST_DC(win, dc);
	const wxRect rct = NormalizeRCT(rctp);
	dc.DrawRectangle(rct);
}

void xvt_dwin_draw_roundrect(WINDOW win, const RCT *rctp, int oval_width, int oval_height)
{
  CAST_DC(win, dc);
	const wxRect rct = NormalizeRCT(rctp);
	dc.DrawRoundedRectangle(rct, min(oval_width, oval_height));
}

void xvt_dwin_draw_dotted_rect(WINDOW win, RCT *rctp)
{
#ifdef WIN32
  static int can_draw_dots = -1;
  if (can_draw_dots < 0)
    can_draw_dots = xvt_sys_get_os_version() >= XVT_WS_WIN_NT;
  if (can_draw_dots)
  {
    CAST_DC(win, dc);
    OsWin32_DrawDottedRect(dc.GetHDC(), rctp->left, rctp->top, rctp->right, rctp->bottom);
    return;
  }
#endif
  DRAW_CTOOLS dct;
  xvt_dwin_get_draw_ctools(win, &dct);

 	CPEN pen;
	pen.width = 1;
	pen.pat = PAT_SOLID;
	pen.style = P_DOT;
	pen.color = dct.fore_color;
  xvt_dwin_set_cpen(win, &pen);

 	CBRUSH brush;
  brush.color = dct.back_color;
  brush.pat = PAT_HOLLOW;
  xvt_dwin_set_cbrush(win, &brush);

  xvt_dwin_draw_rect(win, rctp);

  xvt_dwin_set_draw_ctools(win, &dct);
}

void xvt_dwin_draw_set_pos(WINDOW win, PNT pnt)
{
	CAST_TDC(win, dc);
	dc._pnt.x = pnt.h;
	dc._pnt.y = pnt.v;
}

void xvt_dwin_draw_text(WINDOW win, int x, int y, const char *s, int len)
{
  if (s && *s && len != 0)
	{
    CAST_TDC(win, tdc);
    RCT rct; 
    const bool noclip = !tdc.GetClippingBox(&rct);
    if (noclip || x < rct.right)
    {
		  wxString str(s);
		  if (len >= 0)
			  str.Truncate(len);
		  wxDC& dc = tdc.GetDC();               // Prima getto il DC ...
      const int delta = tdc.GetFontDelta(); // ... poi faccio la GetFontDelta!
#ifdef LINUX
			if (tdc._dct.opaque_text)
			{
				RCT back;	
				back.left = x;
				back.right = x + xvt_dwin_get_text_width(win, str, -1);
				back.top = y - delta;
				back.bottom = y;
				CAST_COLOR(tdc._dct.back_color, brush_color);

				wxBrush* brush = wxTheBrushList->FindOrCreateBrush(brush_color, wxSOLID);
				const wxBrush & old_brush = dc.GetBrush();
				const wxPen & old_pen = dc.GetPen();
				const wxRect rct = NormalizeRCT(&back);

				dc.SetBrush(*brush);
				dc.SetPen(*wxTRANSPARENT_PEN);
				dc.DrawRectangle(rct);
				dc.SetBrush(old_brush);
				dc.SetPen(old_pen);
			}
#endif      
      dc.DrawText(str, x, y-delta);
    }
	}
}

RCT* xvt_dwin_get_clip(WINDOW win, RCT* rct)
{
  CAST_TDC(win, dc);
	dc.GetClippingBox(rct);
	return rct;
}

DRAW_CTOOLS* xvt_dwin_get_draw_ctools(WINDOW win, DRAW_CTOOLS* ctoolsp)
{
  CAST_TDC(win, dc);
	memcpy(ctoolsp, &dc._dct, sizeof(DRAW_CTOOLS));
	return ctoolsp;
}

XVT_FNTID xvt_dwin_get_font(WINDOW win)
{
  CAST_TDC(win, dc);
	TFontId* pFont = new TFontId(dc._font);
	return pFont;
}

void xvt_dwin_get_font_metrics(WINDOW win, int *leadingp, int *ascentp, int *descentp)
{
  // Attenzione: non funziona la chiamate in cascata a xvt_font_get_metrics
  CAST_DC(win, dc);
  const wxString str = "Mq";
	int height, desc, lead;
  dc.GetTextExtent(str, NULL, &height, &desc, &lead);
	if (leadingp)
		*leadingp = lead;
  if (ascentp)
		*ascentp = height-lead-desc;
	if (descentp)
		*descentp = desc;
}

long xvt_dwin_get_font_size_mapped(WINDOW win)
{
	CAST_WIN(win, dc);
  const wxFont& font = dc.GetFont();
  int height = font.GetPointSize();
	return height;
}

int xvt_dwin_get_text_width(WINDOW win, const char *s, int len)
{
	int width = 0;
	if (s && *s && len != 0)
	{
		CAST_DC(win, dc);
		wxString str = s;
		if (str.StartsWith("ABCDEFGH") || str.StartsWith("MMMMMMMM"))
		{
			const wxString emme('G', str.Length()); // Questa lettera cambia con le mode
			str = emme;
		}
		if (len > 0)
			str.Truncate(len);
    int height = 0;
		dc.GetTextExtent(str, &width, &height);
	}	

	return width;
}

void xvt_dwin_invalidate_rect(WINDOW win, const RCT* rctp)
{
  if (win != NULL_WIN)
  {
	  CAST_WIN(win, w);
	  if (rctp != NULL)
	  {
		  const wxRect rct = NormalizeRCT(rctp);
		  w.Refresh(false, &rct);
	  }
	  else
		  w.Refresh(false);
  }
}

BOOLEAN xvt_dwin_is_update_needed(WINDOW win, const RCT* rctp)
{
	if (win != NULL_WIN && rctp != NULL)
	{
    if (win == PRINTER_WIN || win == SCREEN_WIN)
      return TRUE;
    CAST_WIN(win, w); // child windows and TASK_WIN
    const wxRect rect1 = NormalizeRCT(rctp);
		const wxRect rect2 = w.GetUpdateClientRect(); // w.GetUpdateRegion().GetBox();
    return RectIntersect(rect1, rect2);
	}
	return FALSE;
}

void xvt_dwin_scroll_rect(WINDOW win, RCT *rctp, int dh, int dv)
{
	if (dh != 0 || dv != 0)
	{
		CAST_WIN(win, w);
		if (rctp != NULL)
		{
  		const wxRect rct = NormalizeRCT(rctp);
      if (!rct.IsEmpty())			
//			  w.ScrollWindow(dh, dv, &rct);        // Metodo ortodosso ma impreciso di un pixel  
        w.Refresh(false, &rct);                // Pezza "TEMPORANEA" per evitare artefatti
		}
		else
			w.ScrollWindow(dh, dv);
	}
}

void xvt_dwin_set_back_color(WINDOW win, COLOR color)
{
	CAST_TDC(win, dc);
	dc._dct.back_color = color;
	dc.SetDirty();
}

void xvt_dwin_set_cbrush(WINDOW win, CBRUSH* cbrush)
{
	CAST_TDC(win, dc);
	memcpy(&dc._dct.brush, cbrush, sizeof(CBRUSH));
	dc.SetDirty();
}

void xvt_dwin_set_clip(WINDOW win, const RCT* rctp)
{
	CAST_TDC(win, dc);
	dc.SetClippingBox(rctp);
  dc.SetDirty();
}

void xvt_dwin_set_cpen(WINDOW win, CPEN* cpen)
{ 	
	CAST_TDC(win, dc);
	memcpy(&dc._dct.pen, cpen, sizeof(CPEN));
	dc.SetDirty();
}

void xvt_dwin_set_draw_ctools(WINDOW win, DRAW_CTOOLS* xct)
{
	CAST_TDC(win, dc);
	memcpy(&dc._dct, xct, sizeof(DRAW_CTOOLS));
	dc.SetDirty();
}

void xvt_dwin_set_draw_mode(WINDOW win, DRAW_MODE mode)
{
	CAST_TDC(win, dc);
	dc._dct.mode = mode;
	dc.SetDirty();
}

void xvt_dwin_set_font(WINDOW win, XVT_FNTID font_id)
{
	CAST_TDC(win, dc);
	CAST_FONT(font_id, font);
	if (dc._font != font)
	{
	  dc._font = font;
    dc.SetDirty();
	}
}

void xvt_dwin_set_fore_color(WINDOW win, COLOR color)
{
	CAST_TDC(win, dc);
	dc._dct.fore_color = color;
	dc.SetDirty();
}

void xvt_dwin_set_std_cbrush(WINDOW win, long flag)
{
  CBRUSH brush;
  brush.pat = PAT_SOLID;
  switch (flag)
  {
  case TL_BRUSH_BLACK: brush.color = COLOR_BLACK; break;
  case TL_BRUSH_WHITE: brush.color = COLOR_WHITE; break;
  default: SORRY_BOX(); break;
  }
	xvt_dwin_set_cbrush(win, &brush);
}

void xvt_dwin_set_std_cpen(WINDOW win, long flag)
{
	CPEN pen; memset(&pen, 0, sizeof(CPEN));
	pen.style = P_SOLID;
  pen.pat = PAT_SOLID;
	
	switch(flag)
	{
	case TL_PEN_BLACK : pen.color = COLOR_BLACK;  break;
  case TL_PEN_DKGRAY: pen.color = COLOR_DKGRAY; break;
  case TL_PEN_GRAY  : pen.color = COLOR_GRAY;   break;
  case TL_PEN_LTGRAY: pen.color = COLOR_LTGRAY; break;
	case TL_PEN_WHITE : pen.color = COLOR_WHITE;  break;
	case TL_PEN_HOLLOW: pen.pat = PAT_HOLLOW; break;
	case TL_PEN_RUBBER: pen.pat = PAT_RUBBER; break;
	default: SORRY_BOX(); break;
	}
	xvt_dwin_set_cpen(win, &pen);
}

void xvt_dwin_draw_line(WINDOW win, PNT pnt)
{
	CAST_TDC(win, tdc);
	const wxPoint to(pnt.h, pnt.v);
  wxDC& dc = tdc.GetDC();
	if (tdc._pnt != to)
	  dc.DrawLine(tdc._pnt, to);
//  dc.DrawPoint(to);   // Un giorno capiro' il perche' servisse
	tdc._pnt = to;
}

void xvt_dwin_update(WINDOW win)
{
 	CAST_WIN(win, w);
  w.Update();
}

///////////////////////////////////////////////////////////
// Debug functions
///////////////////////////////////////////////////////////

XVT_ERRSEV xvt_errmsg_get_sev_id(XVT_ERRMSG err)
{
	return (XVT_ERRSEV)err;
}

///////////////////////////////////////////////////////////
// Fonts
///////////////////////////////////////////////////////////

void xvt_font_copy(XVT_FNTID dest_font_id, XVT_FNTID src_font_id, XVT_FONT_ATTR_MASK mask)
{
	XVT_ASSERT(dest_font_id && src_font_id && mask == XVT_FA_ALL);
	CAST_FONT(dest_font_id, dst);
  CAST_FONT(src_font_id, src);
	dst = src;
}

XVT_FNTID xvt_font_create(void)
{
	TFontId* pFont = new TFontId;
	return (XVT_FNTID)pFont;
}

void xvt_font_deserialize(XVT_FNTID font_id, const char* buf)
{
  // 01\\Courier\\0\\10\\WIN01/-13/0/0/0/400/0/0/0/0/1/2/1/49/Courier

  CAST_FONT(font_id, font)
  const char* s = strchr(buf, '/');
	if (s == NULL)
		return;
	const int nSize = atoi(s+1);
	if (nSize > 0)
	  font.SetPointSize(nSize);
	else
		font.SetPointSize(-nSize * 10 / 13);

	// Ignore 4 fields
	int i;
	for (i = 0; i < 4; i++)
	{
	  s = strchr(s+1, '/');
	  if (s == NULL)
			return;
	}
  s++;
	const int nWeight = atoi(s);
	if (nWeight >= 600)
		font.SetMask(font.Mask() | XVT_FS_BOLD);

  s = strchr(s, '/');
  if (s == NULL)
		return;
	const int nItalic = atoi(s+1);
	if (nItalic)
		font.SetMask(font.Mask() | XVT_FS_ITALIC);

	// Ignore 8 fields
	for (i = 0; i < 8; i++)
	{
	  s = strchr(s+1, '/');
	  if (s == NULL)
			return;
	}

	font.SetFaceName(s+1);
	font.SetWin(NULL_WIN);
}

void xvt_font_destroy(XVT_FNTID font_id)
{
  if (font_id != NULL)
  {
    TFontId* fp = wxStaticCast(font_id, TFontId);
	  delete fp;
  }
}

BOOLEAN xvt_font_get_family(XVT_FNTID font_id, char* buf, long max_buf)
{
  BOOLEAN ok = font_id != NULL && buf != NULL && max_buf > 0;
  if (ok)
  {
    CAST_FONT(font_id, font);
    wxStrncpy(buf, font.FaceName(), max_buf);
	  buf[max_buf-1] = '\0';
  }
	return ok;
}

BOOLEAN xvt_font_get_family_mapped(XVT_FNTID font_id, char* buf, long max_buf)
{ return xvt_font_get_family(font_id, buf, max_buf); }

void xvt_font_get_metrics(XVT_FNTID font_id, int *leadingp, int *ascentp, int *descentp)
{
  CAST_FONT(font_id, font);
	WINDOW win = font.Win();
	if (win != PRINTER_WIN)
    win = TASK_WIN; // Non mi fido troppo della finestra su cui il font e' mappato
  CAST_DC(win, dc);
  
  const wxString str = "Mq";
	int height = 0, desc = 0, lead = 0;
  const wxFont& ff = font.Font(&dc, win);
  dc.GetTextExtent(str, NULL, &height, &desc, &lead, (wxFont*)&ff);
  if (height <= 0 || height > 64000) // Gestisce eventuali anomalie alla meno peggio
  {
    wxASSERT(false);
    height = ff.GetPointSize();
    desc = height / 5;
    lead = 0;
  }
	if (leadingp)
		*leadingp = lead;
  if (ascentp)
		*ascentp = height-desc-lead;
	if (descentp)
		*descentp = desc;
}

BOOLEAN xvt_font_get_native_desc(XVT_FNTID font_id, char *buf, long max_buf)
{
  const long len = xvt_font_serialize(font_id, buf, max_buf);
	return len > 0 && len < max_buf;
}

long xvt_font_get_size(XVT_FNTID font_id)
{
  CAST_FONT(font_id, font);
	return font.PointSize();
}

XVT_FONT_STYLE_MASK xvt_font_get_style(XVT_FNTID font_id)
{
  CAST_FONT(font_id, font);
	return font.Mask();
}

WINDOW xvt_font_get_win(XVT_FNTID font_id)
{
  CAST_FONT(font_id, font);
	return font.Win();
}

BOOLEAN xvt_font_is_mapped(XVT_FNTID font_id)
{
	return xvt_font_get_win(font_id) != NULL_WIN;
}

void xvt_font_map(XVT_FNTID font_id, WINDOW win)
{
  CAST_FONT(font_id, font);
	font.SetWin(win);
}

void xvt_font_map_using_default(XVT_FNTID font_id)
{
	xvt_font_map(font_id, TASK_WIN);
}

void xvt_font_set_family(XVT_FNTID font_id, const char* family)
{
  CAST_FONT(font_id, font);
  font.SetFaceName(family);
}

void xvt_font_set_size(XVT_FNTID font_id, long size)
{
  CAST_FONT(font_id, font);
	font.SetPointSize(size);
}

void xvt_font_set_style(XVT_FNTID font_id, XVT_FONT_STYLE_MASK mask)
{
  CAST_FONT(font_id, font);
	font.SetMask(mask);
}

long xvt_font_serialize(XVT_FNTID font_id, char *buf, long max_buf)
{
  // 01\\Courier\\0\\10\\WIN01/-13/0/0/0/400/0/0/0/0/1/2/1/49/Courier

  CAST_FONT(font_id, font);
  const char* name = font.FaceName();
	const int size = font.PointSize();
	const int italic = (font.Mask() & XVT_FS_ITALIC) != 0;
  const int weight = (font.Mask() & XVT_FS_BOLD) ? 700 : 400;

  wxString str;
	str = wxString::Format("01\\%s\\0\\%d\\WIN01/%d/%d/0/0/%d/0/0/0/0/0/0/0/0/%s",
		                     name, size, size, weight, italic, name);
  if (buf != NULL && max_buf > 0)
  {
    wxStrncpy(buf, str, max_buf);
	  buf[max_buf-1] = '\0';
  }
  return str.Len();
}

void xvt_font_unmap(XVT_FNTID font_id)
{
  CAST_FONT(font_id, font);
	font.SetWin(NULL_WIN);
}

///////////////////////////////////////////////////////////
// File system
///////////////////////////////////////////////////////////

BOOLEAN xvt_fsys_build_pathname(char* mbs, const char* volname, const char* dirname, const char* leafroot, const char* leafext, const char* /* leafvers */)
{
#ifdef WIN32
  _makepath(mbs, volname, dirname, leafroot, leafext);
#else
  *mbs = '\0';
  if (dirname && *dirname)
    strcpy(mbs, dirname);
  if (leafroot && *leafroot)
  {
    if (!wxEndsWithPathSeparator(mbs) && !wxIsPathSeparator(*leafroot))
      strcat(mbs, "/");
    strcat(mbs, leafroot);
  }
  if (leafext && *leafext)
  {
    if (*leafext != '.')
      strcat(mbs, ".");
    strcat(mbs, leafext);
  }
#endif
  return TRUE;
}

BOOLEAN xvt_fsys_parse_pathname(const char* mbs, char* volname, char* dirname, char* leafroot, char* leafext, char* leafvers)
{
  wxString volume, path, file, ext;
  wxFileName::SplitPath(mbs, &volume, &path, &file, &ext);
  if (volname) 
  {
		if (mbs[0] == mbs[1] && wxIsPathSeparator(mbs[0]))
		{
			volume.insert(size_t(0), size_t(2), wxFILE_SEP_PATH); // Mette due slash all'inizio
			if (!wxIsPathSeparator(path[0]))
				volume << wxFILE_SEP_PATH;          // Accoda uno slash
			path.insert(0, volume);
			*volname = '\0';
		}
		else
		{
      wxStrcpy(volname, volume);
#ifdef WIN32
      if (volname[0] != '\0' && volname[1] == '\0')
        wxStrcat(volname, ":");
#endif
    }
	}
  if (dirname) strcpy(dirname, path);
  if (leafroot) strcpy(leafroot, file);
  if (leafext) strcpy(leafext, ext);
  if (leafvers) strcpy(leafvers, "");  // TBI put here last change date/time?
  return true;
 }

BOOLEAN xvt_fsys_convert_dir_to_str(DIRECTORY* dirp, char* path, int sz_path)
{
  BOOLEAN ok = dirp != NULL && path != NULL && sz_path > 0;
  if (ok)
  {
  	wxStrncpy(path, dirp->path, sz_path-1);
	  path[sz_path-1] = '\0';
  }
  return ok;
}

BOOLEAN xvt_fsys_convert_str_to_dir(const char *path, DIRECTORY *dirp)
{
  BOOLEAN ok = path != NULL && dirp != NULL;
  if (ok)
  {
    const int sz = sizeof(dirp->path)-1;
    wxStrncpy(dirp->path, path, sz);
    dirp->path[sz] = '\0';
  }
	return ok;
}

BOOLEAN xvt_fsys_convert_fspec_to_str(const FILE_SPEC *fs, char *path, int sz_path)
{
  BOOLEAN ok = FALSE;
  if (fs != NULL && path != NULL && sz_path > 0)
  {
    char mbs[_MAX_PATH];
    xvt_fsys_build_pathname(mbs, "", fs->dir.path, fs->name, fs->type, NULL);
    wxStrncpy(path, mbs, sz_path);
    ok = *path > ' ';
  }
  return ok;
}

BOOLEAN xvt_fsys_convert_str_to_fspec(const char *mbs, FILE_SPEC *fs)
{
  BOOLEAN ok = FALSE;
  if (mbs && *mbs && fs != NULL)
  {
    memset(fs, 0, sizeof(FILE_SPEC));
    char volume[_MAX_DRIVE], path[_MAX_PATH];
		xvt_fsys_parse_pathname(mbs, volume, path, fs->name, fs->type, NULL);
    wxStrcpy(fs->dir.path, volume);
		wxStrcat(fs->dir.path, path);
    wxStrcpy(fs->creator, "CAMPO");
    ok = fs->name[0] != '\0';
  }
  return ok;
}


void xvt_fsys_get_default_dir(DIRECTORY *dirp)
{
  if (_startup_dir.IsEmpty())
    _startup_dir = ::wxGetCwd();
  xvt_fsys_convert_str_to_dir(_startup_dir, dirp);
}

BOOLEAN xvt_fsys_get_dir(DIRECTORY *dirp)
{
  return xvt_fsys_convert_str_to_dir(::wxGetCwd(), dirp);
}

static wxString get_disk_root(const char* path)
{
  wxString str;
  if (path && *path)
  {
    str = path;
    if (!wxEndsWithPathSeparator(str))
      str << wxFILE_SEP_PATH;

    wxChar drive[_MAX_DRIVE], dir[_MAX_DIR];
    xvt_fsys_parse_pathname(str,drive,dir,NULL,NULL,NULL);

    if (*drive)
      str = drive;
    else
      str = dir;

    if (!wxEndsWithPathSeparator(str))
      str << wxFILE_SEP_PATH;
  }
  return str;
}

// Il disco e' un floppy?
BOOLEAN xvt_fsys_is_floppy_drive(const char* path)
{
  BOOLEAN yes = xvt_fsys_is_removable_drive(path);
  if (yes)
  {
    const unsigned long mb = xvt_fsys_get_disk_size(path, 'M'); // Dimensioni in Mb
    yes = mb < 4; // E' un vero floppy solo se e' piu' piccolo di 4 Mb
  }
  return yes;
}

// Il disco e' rimuovibile? (floppy / memory stick)
BOOLEAN xvt_fsys_is_removable_drive(const char* path)
{
  BOOLEAN yes = FALSE;
  
  if (path && *path)
  {
#ifdef WIN32
    const wxString strRoot = get_disk_root(path);
    yes = ::GetDriveType(strRoot) == DRIVE_REMOVABLE;
#else
    char dev[_MAX_PATH];
    OsLinux_GetFileSys(path, dev, NULL, NULL);
    yes = strncmp(dev, "/dev/fd", 7) == 0;
#endif
  }
  return yes;
}

BOOLEAN xvt_fsys_is_network_drive(const char* path)
{
  BOOLEAN yes = FALSE;
  if (path && *path)
  {
    if (wxIsPathSeparator(path[0]) && wxIsPathSeparator(path[1]))
      yes = TRUE;
    else
    {
#ifdef WIN32
      const wxString strRoot = get_disk_root(path);
      yes = ::GetDriveType(strRoot) == DRIVE_REMOTE;
#else
      yes = OsLinux_IsNetworkDrive(path);
#endif
    }
  }
  return yes;
}

BOOLEAN xvt_fsys_is_fixed_drive(const char* path)
{
  BOOLEAN yes = FALSE;
  if (path && *path)
  {
    if (!wxIsPathSeparator(path[0]) || !wxIsPathSeparator(path[1]))
    {
#ifdef WIN32
      const wxString strRoot = get_disk_root(path);
      yes = ::GetDriveType(strRoot) == DRIVE_FIXED;
#else
      yes = !(xvt_fsys_is_network_drive(path) || xvt_fsys_is_removable_drive(path));
#endif
    }
  }
  return yes;
}

static unsigned long compute_disk_size(const char* path, bool tot, char unit)
{
  long nVal = 0;
  if (path && *path)
  {
    const wxString strRoot = get_disk_root(path);
    wxLongLong total = 0, unused = 0;
    wxGetDiskSpace(strRoot, &total, &unused);
    __int64 nBytes = tot ? total.ToDouble() : unused.ToDouble();

    if (nBytes > 0)
    {
      switch (unit)
	    {
	    case 'K': nBytes >>= 10; break; // Kilobytes
	    case 'M': nBytes >>= 20; break; // Megabytes
	    case 'G': nBytes >>= 30; break; // Gigabytes
	    case 'T': nBytes >>= 40; break; // Terabytes
	    default :	break;
	    }
      const unsigned long nMax = (unsigned long)(~0L);
      nVal = nBytes > nMax ? nMax : (unsigned long)nBytes;
    }
  }
  return nVal;
}

unsigned long xvt_fsys_get_disk_size(const char* path, char unit)
{
  return compute_disk_size(path, true, unit);
}

unsigned long xvt_fsys_get_disk_free_space(const char* path, char unit)
{
  return compute_disk_size(path, false, unit);
}

BOOLEAN xvt_fsys_test_disk_free_space(const char* path, unsigned long filesize)
{
	// Arrotonda per eccesso al Kilobyte
  unsigned long kb = filesize/1024+4;
  return kb <= xvt_fsys_get_disk_free_space(path, 'K');
}

// Usr friendly implementation
long xvt_fsys_file_attr(const char* path, long attr)
{
  long ret = 0;
  if (path && *path && attr >= XVT_FILE_ATTR_MINIMUM && attr <= XVT_FILE_ATTR_MAXIMUM)
  {
    const wxString name(path);
    switch (attr)
    {
    case XVT_FILE_ATTR_EXIST: 
      ret = ::wxFileExists(name);
      break;
    case XVT_FILE_ATTR_READ: 
      ret = ::wxAccess(name, 0x1) != 0;
      break;
    case XVT_FILE_ATTR_WRITE: 
      ret = ::wxAccess(name, 0x2) != 0;
      break;
    case XVT_FILE_ATTR_DIRECTORY:
      ret = ::wxDirExists(name);
      break;
    case XVT_FILE_ATTR_SIZE:
      {
        const wxULongLong sz = wxFileName::GetSize(name);
        ret = sz.GetHi() != 0 ? INT_MAX : sz.GetLo();
      }
      break;
    case XVT_FILE_ATTR_MTIME:
      ret = ::wxFileModificationTime(name);
      break;
    default: break;
    }
  }
  return ret;
}

// Original XVT implementation
long xvt_fsys_get_file_attr(const FILE_SPEC* fs, long attr)
{
  char mbs[_MAX_PATH]; xvt_fsys_convert_fspec_to_str(fs, mbs, sizeof(mbs));
  return xvt_fsys_file_attr(mbs, attr);
}

///////////////////////////////////////////////////////////
// File system
///////////////////////////////////////////////////////////

SLIST xvt_fsys_list_files(const char *type, const char *pat, BOOLEAN dirs)
{
	SLIST list = xvt_slist_create();

  int flags = 0;
	if (dirs)
	{
		if (strcmp(type, DIR_TYPE) == 0)
	    flags = wxDIR;
	}
	else
		flags = wxFILE;

  wxString f = ::wxFindFirstFile(pat, flags);
  while (!f.IsEmpty())
	{
#ifdef WIN32
    if (f.StartsWith(".\\"))
#else
    if (f.StartsWith("./"))
#endif
      f = f.Mid(2);
    xvt_slist_add_at_elt(list, NULL, f, 0L);

		f = ::wxFindNextFile();
	}

	return list;
}

static wxString _strSavedir;

void xvt_fsys_restore_dir()
{
  wxASSERT(!_strSavedir.IsEmpty());
	::wxSetWorkingDirectory(_strSavedir);
  _strSavedir = wxEmptyString;
}

void xvt_fsys_save_dir()
{
  wxASSERT(_strSavedir.IsEmpty());
	_strSavedir = ::wxGetCwd();
}

BOOLEAN xvt_fsys_set_dir(const DIRECTORY *dirp)
{
	return ::wxSetWorkingDirectory(dirp->path);
}

///////////////////////////////////////////////////////////
// Images
///////////////////////////////////////////////////////////

XVT_IMAGE xvt_image_capture(WINDOW win, const RCT* src)
{
  wxRect r;
  if (src == NULL)
  {
    RCT rct; xvt_vobj_get_client_rect(win, &rct);
    r = NormalizeRCT(&rct);
  }
  else
    r = NormalizeRCT(src);

  wxBitmap bmp(r.GetWidth(), r.GetHeight());
  CAST_DC(win, wdc);

  wxMemoryDC mdc(bmp); 
  mdc.Blit(wxPoint(0,0), r.GetSize(), &wdc, r.GetPosition());

  TXVT_IMAGE* i = new TXVT_IMAGE;
  i->Image() = bmp.ConvertToImage();

  return (XVT_IMAGE)i;
}

XVT_IMAGE xvt_image_create(XVT_IMAGE_FORMAT format, short width, short height, long reserved)
{
	TXVT_IMAGE* i = new TXVT_IMAGE;
	i->Image().Create(width, height);
	return (XVT_IMAGE)i;
}

void xvt_image_destroy(XVT_IMAGE img)
{
	CAST_TIMAGE(img, image);
  if (image != NULL)
	  delete image;
}

int xvt_image_find_clut_index(XVT_IMAGE img, COLOR rgb)
{
	CAST_IMAGE(img, image);
  int i = -1;
	if (image && image->Ok() && image->HasPalette())
	{
		const wxPalette& pal = image->GetPalette();
    for (i = 255; i >= 0; i--)
    {
      unsigned char ri, gi, bi;
      if (pal.GetRGB(i, &ri, &gi, &bi))
      {
        const COLOR rgbi = XVT_MAKE_COLOR(ri, gi, bi);
        if ((rgbi & 0x00FFFFFF) == (rgb & 0x00FFFFFF))
          break;
      }
    }
  }
  return i;
}

COLOR xvt_image_get_clut(XVT_IMAGE img, short index)
{
	CAST_IMAGE(img, image);
	if (image && image->Ok() && image->HasPalette())
	{
		const wxPalette& pal = image->GetPalette();
		unsigned char r, g, b;
		if (pal.GetRGB(index, &r, &g, &b))
		  return XVT_MAKE_COLOR(r, g, b);
	}
	return COLOR_INVALID;
}

void xvt_image_get_dimensions(XVT_IMAGE image, short* width, short* height)
{
  *width = *height = 0;

  CAST_IMAGE(image, img);
  if (img != NULL && img->Ok())
  {
    *width = img->GetWidth();
    *height = img->GetHeight();
  }
}

XVT_IMAGE_FORMAT xvt_image_get_format(XVT_IMAGE image)
{
  CAST_IMAGE(image, img);
  if (img != NULL && img->Ok())
	  return img->HasPalette() ? XVT_IMAGE_CL8 : XVT_IMAGE_RGB;
  return XVT_IMAGE_NONE;
}

short xvt_image_get_ncolors(XVT_IMAGE image)
{
	int n = 0;
  CAST_IMAGE(image, i);
	if (i != NULL && i->Ok() && i->HasPalette())
	{
		const wxPalette& pal = i->GetPalette();
		unsigned char r, g, b;
		for (n = 16; n < 256; n++)
		{
			if (!pal.GetRGB(n, &r, &g, &b))
				break;
		}
	}
	return n;
}

COLOR xvt_image_get_pixel(XVT_IMAGE image, short x, short y)
{
  CAST_TIMAGE(image, i);
  if (i != NULL && i->Ok())
    return i->GetPixel(x, y);
  return COLOR_INVALID;	
}

XVT_IMAGE xvt_image_read(const char* filenamep)
{
	TXVT_IMAGE* i = NULL;
#ifdef WIN32
	const wxString name = filenamep;
#else
	wxString name;
	if (isalpha(filenamep[0u]))
	{
		name = _startup_dir;
		name += "/";
	}
	name += filenamep;
#endif
	if (::wxFileExists(name))
	{
		i = new TXVT_IMAGE;
		i->LoadFile(name);
		if (!i->Ok())
		{
			delete i;
			i = NULL;
		}
	}
	return (XVT_IMAGE)i;
}

XVT_IMAGE xvt_image_read_bmp(const char *filenamep)
{
	return xvt_image_read(filenamep);  // Very clever!
}

void xvt_image_set_clut(XVT_IMAGE image, short index, COLOR color)
{
  CAST_TIMAGE(image, i);
  if (i != NULL && i->Ok() && i->HasPalette())
  {
 	  CAST_COLOR(color, c);

    wxImage& bmp = i->Image(); // Set dirty!

 	  unsigned char ri, gi, bi;
    bmp.GetOrFindMaskColour(&ri,&gi, &bi);
    const int idx = xvt_image_find_clut_index(image, XVT_MAKE_COLOR(ri, gi, bi));
    if (idx == index)  
      bmp.SetMaskColour(c.Red(), c.Green(), c.Blue());

	  const wxPalette& pal = bmp.GetPalette();
	  pal.GetRGB(index, &ri, &gi, &bi);
    const COLOR old_color = XVT_MAKE_COLOR(ri, gi, bi);

	  const int w = bmp.GetWidth();
	  const int h = bmp.GetHeight();
	  for (int y = 0; y < h; y++) for (int x = 0; x < w; x++)
	  {
      const COLOR rgb = i->GetPixel(x, y);
      if (rgb == old_color)
        i->SetPixel(x, y, color);
	  }
  }
}

void xvt_image_set_ncolors(XVT_IMAGE image, short ncolors)
{
//  SORRY_BOX();
}

void xvt_image_set_pixel(XVT_IMAGE image, short x, short y, COLOR color)
{
  CAST_TIMAGE(image, i);
  if (i != NULL && i->Ok())
	  i->SetPixel(x, y, color);
}

void xvt_image_transfer(XVT_IMAGE dstimage, XVT_IMAGE srcimage, RCT *dstrctp, RCT *srcrctp)
{
  CAST_TIMAGE(dstimage, dst);
  CAST_TIMAGE(srcimage, src);
  if (dst != NULL && src != NULL)
  {
    const wxRect rctDst = NormalizeRCT(dstrctp);
    const wxRect rctSrc = NormalizeRCT(srcrctp);
    wxMemoryDC dc;
    wxBitmap bmp(*dst);
    dc.SelectObject(bmp);
    DrawImageOnDC(dc, src, rctDst, rctSrc);
	  dst->Image() = bmp.ConvertToImage();
    dc.SelectObject(wxNullBitmap);
  }
}

///////////////////////////////////////////////////////////
// Memory management
///////////////////////////////////////////////////////////

DATA_PTR xvt_mem_alloc(size_t size)
{
  DATA_PTR ptr = (DATA_PTR)malloc(size);
	return ptr;
}

void xvt_mem_free(DATA_PTR p)
{ free(p); }

DATA_PTR xvt_mem_realloc(DATA_PTR p, size_t size)
{ return (DATA_PTR)realloc(p, size); }

DATA_PTR xvt_mem_rep(DATA_PTR dst, DATA_PTR src, unsigned int srclen, long reps)
{
	XVT_ASSERT(dst != NULL || src != NULL);

	if (srclen == 1)
		memset(dst, *src, reps);
	else
	{
		for (long i = 0; i < reps; i++)
  	  memcpy(dst + i*srclen, src, srclen);
	}
	return dst;
}

DATA_PTR xvt_mem_zalloc(size_t size)
{
  DATA_PTR ptr = xvt_mem_alloc(size);
  memset(ptr, 0, size);
	return ptr;
}

///////////////////////////////////////////////////////////
// Menu management
///////////////////////////////////////////////////////////

static int xvt_menu_count(const MENU_ITEM* m)
{
  int n = 0;
  if (m != NULL)
 	  for (n = 0; m[n].tag != 0; n++);
	return n;
}

// Funzione inventata
MENU_ITEM* xvt_menu_duplicate_tree(const MENU_ITEM* m)
{
	MENU_ITEM* TheMenu = NULL;
	if (m != NULL && m->tag != 0)
	{
  	const int n = xvt_menu_count(m)+1;
    TheMenu = (MENU_ITEM*)xvt_mem_zalloc(sizeof(MENU_ITEM)*n);
		memcpy(TheMenu, m, n*sizeof(MENU_ITEM));
		for (int i = 0; i < n; i++)
		{
			MENU_ITEM* mi = &TheMenu[i];
			mi->text = xvt_str_duplicate(mi->text);
			mi->child = xvt_menu_duplicate_tree(mi->child);
		}
	}
	return TheMenu;
}

MENU_ITEM* xvt_menu_get_tree(WINDOW win)
{
	MENU_ITEM* m = NULL;
	if (win == TASK_WIN)
	{
		TTaskWin& w = *(TTaskWin*)win;
    m = xvt_menu_duplicate_tree(w.GetMenuTree());
	}
	else
	{
		CAST_TWIN(win, w);
    m = xvt_menu_duplicate_tree(w.GetMenuTree());
	}
	return m;
}

BOOLEAN xvt_menu_popup(MENU_ITEM *menu_p, WINDOW win, PNT pos, 
                       XVT_POPUP_ALIGNMENT /* alignment */, MENU_TAG /* item */)
{
	wxMenu menu;
	for (MENU_ITEM* mi = menu_p; mi != NULL && mi->tag != 0; mi++)
	{
    if (mi->separator || mi->text == NULL)
			menu.AppendSeparator();
		else
    {
      wxMenuItem* item = NULL;
    	if (mi->checkable)
        item = menu.AppendCheckItem(mi->tag, mi->text);
      else
        item = menu.Append(mi->tag, mi->text);
      // Operazioni fattibili solo dopo la menu.Append(), non prima!
      item->Enable(mi->enabled); 
      if (mi->checkable)
        item->Check(mi->checked);
    }
	}

  wxPoint mp = wxDefaultPosition;
  if (pos.h >= 0 && pos.v >= 0)
  {
    mp.x = pos.h;
    mp.y = pos.v;
  }

  CAST_WIN(win, w);
  return w.PopupMenu(&menu, mp);
}

static void TranslateMenu(wxMenu* pMenu, TRANSLATE_CALLBACK tc)
{
	wxMenuItemList& list = pMenu->GetMenuItems();
	for (unsigned i = 0; i < list.GetCount(); i++)
	{
		wxMenuItem* mi = list[i];
		if (!mi->IsSeparator())
		{
			const char* ita = mi->GetText();
			const char* eng = tc(ita);
			mi->SetText(eng);
			wxMenu* pMenu = mi->GetSubMenu();
			if (pMenu != NULL)
				TranslateMenu(pMenu, tc);
		}
	}
}

void xvt_menu_translate_tree(WINDOW win, TRANSLATE_CALLBACK tc)
{
	if (win == TASK_WIN)
	{
		wxMenuBar* pMenuBar = _task_win->GetMenuBar();
  	if (pMenuBar != NULL)
		{
		  for (int m = pMenuBar->GetMenuCount()-1; m >= 0; m--)
			{
        const wxString ita = pMenuBar->GetLabelTop(m);
   			const char* eng = tc(ita);
				pMenuBar->SetLabelTop(m, eng);

  			wxMenu* pMenu = pMenuBar->GetMenu(m);
	  		TranslateMenu(pMenu, tc);
			}
		}
	}
}

void xvt_menu_set_font_sel(WINDOW win, XVT_FNTID font_id)
{ /* Ignored */ }

static wxMenuItem* GetXvtMenuItem(WINDOW win, MENU_TAG tag)
{
  wxMenuItem* item = NULL;
  wxFrame* pFrame = wxDynamicCast((wxObject*)win, wxFrame);
  if (pFrame != NULL)
  {
	  wxMenuBar* bar = pFrame->GetMenuBar();
    if (bar != NULL)
	    item = bar->FindItem(tag);
  }
	return item;
}

void xvt_menu_set_item_checked(WINDOW win, MENU_TAG tag, BOOLEAN check)
{
	wxMenuItem* item = GetXvtMenuItem(win, tag);
	if (item)
	  item->Check(check != 0);
}

void xvt_menu_set_item_enabled(WINDOW win, MENU_TAG tag, BOOLEAN enable)
{
	wxMenuItem* item = GetXvtMenuItem(win, tag);
	if (item)
	  item->Enable(enable != 0);
}

void xvt_menu_set_item_title(WINDOW win, MENU_TAG tag, const char* text)
{
	wxMenuItem* item = GetXvtMenuItem(win, tag);
	if (item)
		item->SetText(text);
}

void xvt_menu_set_tree(WINDOW win, MENU_ITEM* tree)
{
	if (win == TASK_WIN)
	{
		TTaskWin* w = wxStaticCast((wxObject*)win, TTaskWin); //occhio
		w->SetMenuTree(tree);
	}
	else
	{
		CAST_TWIN(win, w);
		w.SetMenuTree(tree);
	}
}

void xvt_menu_update(WINDOW /*win*/)
{
	wxMenuBar* bar = _task_win->GetMenuBar();
	if (bar)
		bar->Refresh();
}

///////////////////////////////////////////////////////////
// Palette management
///////////////////////////////////////////////////////////

short       xvt_palet_add_colors(XVT_PALETTE palet, COLOR *colorsp, short numcolors) { return 0; }
short       xvt_palet_add_colors_from_image(XVT_PALETTE palet, XVT_IMAGE image) { return 0; }
XVT_PALETTE xvt_palet_create(XVT_PALETTE_TYPE type, XVT_PALETTE_ATTR reserved) { return NULL; }
void        xvt_palet_destroy(XVT_PALETTE palet) { SORRY_BOX(); }
short       xvt_palet_get_colors(XVT_PALETTE palet, COLOR *colorsp, short maxcolors) { return 0; }
short       xvt_palet_get_ncolors(XVT_PALETTE palet) { return 0; }
int         xvt_palet_get_tolerance(XVT_PALETTE p) { return 0; }
void        xvt_palet_set_tolerance(XVT_PALETTE p, int t) { SORRY_BOX(); }

///////////////////////////////////////////////////////////
// Rectangles
///////////////////////////////////////////////////////////
int	xvt_rect_get_height(const RCT *rctp)
{
  return rctp ? abs(rctp->bottom - rctp->top) : 0;
  // 3.1   return rctp ? rctp->bottom - rctp->top : 0;
}

int	xvt_rect_get_width(const RCT *rctp)
{
	return rctp ? abs(rctp->right - rctp->left) : 0;
 // 3.1 return rctp ? rctp->right - rctp->left : 0;
}

BOOLEAN xvt_rect_has_point(const RCT *rctp, PNT pnt)
{
	const wxRect rct = NormalizeRCT(rctp);
	return rct.Contains(pnt.h, pnt.v);
}

BOOLEAN xvt_rect_intersect(RCT *drctp, const RCT *rctp1, const RCT *rctp2)
{
	const wxRect rect1 = NormalizeRCT(rctp1);
	const wxRect rect2 = NormalizeRCT(rctp2);
	const BOOLEAN yes = RectIntersect(rect1, rect2);
	if (drctp)
	{
    if (yes)
    {
		  drctp->left = max(rect1.x, rect2.x);
		  drctp->top = max(rect1.y, rect2.y);
		  drctp->right = min(rect1.GetRight(), rect2.GetRight())+1;
		  drctp->bottom = min(rect1.GetBottom(), rect2.GetBottom())+1;
	  }
	  else
	  {
  	  drctp->left = drctp->right = rect1.x;
		  drctp->top = drctp->bottom = rect1.y;
	  }
	}
	return yes;
}

BOOLEAN xvt_rect_is_empty(const RCT *rct)
{
	return rct == NULL || (rct->left==rct->right && rct->top==rct->bottom);
}

void xvt_rect_offset(RCT *rctp, short dh, short dv)
{
	XVT_ASSERT(rctp != NULL);
	rctp->left += dh;
	rctp->top += dv;
	rctp->right += dh;
	rctp->bottom += dv;
}

void xvt_rect_set(RCT *rctp, short left, short top, short right, short bottom)
{
	XVT_ASSERT(rctp != NULL);
	rctp->left = left;
	rctp->top = top;
	rctp->right = right;
	rctp->bottom = bottom;
}

void xvt_rect_set_empty(RCT *rctp)
{
	XVT_ASSERT(rctp != NULL);
	rctp->right = rctp->left;
	rctp->bottom = rctp->top;
}

BOOLEAN xvt_rect_set_pos(RCT *rctp, PNT pos)
{
	BOOLEAN ok = rctp != NULL;
	if (ok)
	{
		const short w = rctp->right-rctp->left;
		const short h = rctp->bottom-rctp->top;
		rctp->left = pos.h;
		rctp->top = pos.v;
		rctp->right = pos.h + w;
		rctp->bottom = pos.v + h;
	}
	return ok;
}

void xvt_rect_inflate(RCT *rctp, short ix, short iy)
{
  if (rctp != NULL)
  {
    rctp->left -= ix; rctp->right += ix;
    rctp->top -= iy; rctp->bottom += iy;
  }
}

///////////////////////////////////////////////////////////
// Resource management
///////////////////////////////////////////////////////////

void xvt_res_free_menu_tree(MENU_ITEM* tree)
{
	XVT_ASSERT(tree != NULL);
	if (tree != NULL)
	{
		for (MENU_ITEM* item = tree; item->tag != 0; item++)
		{
			if (item->text)
				xvt_mem_free(item->text);
      if (item->child != NULL)
				xvt_res_free_menu_tree(item->child);
		}
		xvt_mem_free((DATA_PTR)tree);
	}
}

XVT_FNTID xvt_res_get_font(int rid)
{
  XVT_FNTID f = xvt_font_create();
  if (rid <= 0)
  {
    CAST_FONT(f, font);
    font.Copy(wxSystemSettings::GetFont(wxSYS_DEFAULT_GUI_FONT));
  }
  return f;
}

XVT_IMAGE xvt_res_get_icon(int rid)
{
  const wxString strFileName = _GetResourceName("Icon", rid);
	const bool ok = !strFileName.IsEmpty();
 	XVT_ASSERT(ok);
	return ok ? xvt_image_read(strFileName) : NULL;
}

XVT_IMAGE xvt_res_get_image(int rid)
{
  const wxString strFileName = _GetResourceName("Image", rid);
	const bool ok = !strFileName.IsEmpty();
 	XVT_ASSERT(ok);
	return ok ? xvt_image_read(strFileName) : NULL;
}

static int SplitString(const wxString& str, wxArrayString& a)
{
	const char* s = str;
	char* comma = "";
	a.Clear();
	while (comma)
	{
		comma = (char*)strchr(s, ',');
		if (comma)
		{
			*comma = '\0';
			a.Add(s);
			*comma = ',';
			s = comma+1;
		}
		else
			a.Add(s);
	}
	return a.GetCount();
}

static void FillMenuItem(const wxString& strValue, MENU_ITEM* mi)
{
	wxArrayString a;
	const int n = SplitString(strValue, a);
	mi->tag = n > 0 ? atoi(a[0]) : 0;
	if (mi->tag > 0)
	{
		const wxString& str = a[1];
		const int accelera = str.Find('&');
		if (accelera >= 0)
  		mi->mkey = str[accelera+1];
		mi->text = xvt_str_duplicate(str);
		mi->enabled = n < 3 || (a[2].Find('D')<0);
		mi->checkable = n >= 3 && (a[2].Find('C')>=0);
		mi->checked = n >= 3 && (a[2].Find('c')>=0);
	}
	else
	{
		mi->tag = -1;
		mi->separator = TRUE;
	}
}

MENU_ITEM* xvt_res_get_menu(int rid)
{
	wxFileConfig ini("", "", GetResourceIni());

	const int MAX_MENU = 16;
  MENU_ITEM* TheMenu = (MENU_ITEM*)xvt_mem_zalloc(sizeof(MENU_ITEM)*MAX_MENU);

	wxString strName;
	if (rid >= 10000 && rid < 10100)
	{
    wxFileName::SplitPath(wxTheApp->argv[0], NULL, &strName, NULL);
		strName.MakeUpper();
		strName = wxString::Format("/Menu_%s-%X", (const char *) strName.Left(3), (rid-1)%16);
	}
	else
		strName = wxString::Format("/Menu_%d", rid);
	ini.SetPath(strName);

	wxString strItem;
	for (int i = 0; i < MAX_MENU; i++)
	{
		MENU_ITEM* mi = &TheMenu[i];
		strItem = wxString::Format("Item_%02d", i);
		if (ini.Read(strItem, &strName))
		{
			FillMenuItem(strName, mi);
			mi = mi->child = (MENU_ITEM*)xvt_mem_zalloc(sizeof(MENU_ITEM)*MAX_MENU);

			for (int j = 0; j < MAX_MENU; j++, mi++)
			{
				strItem = wxString::Format("Item_%02d_%02d", i, j);
				if (ini.Read(strItem, &strName))
    			FillMenuItem(strName, mi);
				else
					break;
			}
		}
		else
			break;
	}
	if (TheMenu->tag == 0)
	{
		XVT_ASSERT(false);   // Menu not found
    xvt_res_free_menu_tree(TheMenu);
		TheMenu = NULL;
	}

	return TheMenu;
}

char* xvt_res_get_str(int rid, char *s, int sz_s)
{
	XVT_ASSERT(s != NULL && sz_s > 0);
	const wxString str = _GetResourceName("String", rid);
	wxStrncpy(s, str, sz_s);
	s[sz_s-1] = '\0';
	return s;
}

///////////////////////////////////////////////////////////
// Scroll bars
///////////////////////////////////////////////////////////

#define CAST_SCROLL(win, sb) XVT_ASSERT(win != NULL_WIN); wxScrollBar& sb = *(wxScrollBar*)win;
#define CAST_SCROLL_TYPE(t, dir) const int dir = t == HSCROLL ? wxHORIZONTAL : wxVERTICAL;
#define CAST_GAUGE(win, pb) XVT_ASSERT(win != NULL_WIN); wxGauge& pb = *(wxGauge*)win;
#define CAST_SLIDER(win, sc) XVT_ASSERT(win != NULL_WIN); wxSlider& sc = *(wxSlider*)win;

int xvt_sbar_get_pos(WINDOW win, SCROLL_TYPE t)
{
  int pos = 0;
  switch (t)
  {
  case HSCROLL:
  case VSCROLL:
	  {
  	  CAST_WIN(win, w);
		  CAST_SCROLL_TYPE(t, dir);
		  pos = w.GetScrollPos(dir);
	  }
    break;
  case HVGAUGE:
    {
      CAST_GAUGE(win, g);
      pos = g.GetValue();
    }
    break;
  case HVSLIDER:
    {
      CAST_SLIDER(win, g);
      pos = g.GetValue();
    }
    break;
  default:
    {
	    CAST_SCROLL(win, sb);
	    pos = sb.GetThumbPosition();
    }
    break;
  }
  return pos;
}

int xvt_sbar_get_proportion(WINDOW win, SCROLL_TYPE t)
{
  int p = 1;
  switch (t)
  {
  case HSCROLL:
  case VSCROLL:
	  {
  	  CAST_WIN(win, w);
		  CAST_SCROLL_TYPE(t, dir);
		  p = w.GetScrollThumb(dir);
	  }
    break;
  case HVSLIDER:
    {
	    CAST_SLIDER(win, sc);
	    p = sc.GetPageSize();
    }
    break;
  default:
    {
	    CAST_SCROLL(win, sb);
	    p = sb.GetThumbSize();
    }
    break;
  }
  return p;
}

void xvt_sbar_get_range(WINDOW win, SCROLL_TYPE t, int *minp, int *maxp)
{
	*minp = 0;
  switch (t)
  {
  case HSCROLL:
  case VSCROLL:
    {
  	  CAST_WIN(win, w);
		  CAST_SCROLL_TYPE(t, dir);
		  *maxp = w.GetScrollRange(dir);
	  }
    break;
  case HVGAUGE:
    {
      CAST_GAUGE(win, g);
      *maxp = g.GetRange();
    }
    break;
  default:
    {
	    CAST_SCROLL(win, sb);
	    *maxp = sb.GetRange();
    }
    break;
  }
}

void xvt_sbar_set_pos(WINDOW win, SCROLL_TYPE t, int pos)
{
	switch(t)
  {
  case HSCROLL:
  case VSCROLL:
	  {
  	  CAST_WIN(win, w);
		  CAST_SCROLL_TYPE(t, dir);
		  w.SetScrollPos(dir, pos);
	  }
    break;
  case HVGAUGE:
    {
    	CAST_GAUGE(win, g);
      if (g.GetRange() <= 1)
        g.Pulse();
      else
        g.SetValue(pos);
    }
    break;
  case HVSLIDER:
    {
    	CAST_SLIDER(win, g);
      g.SetValue(pos);
    }
    break;
  default:
    {
		  CAST_SCROLL(win, sb);
		  const int range = sb.GetRange();
		  const int size = sb.GetThumbSize();
		  sb.SetScrollbar(pos, size, range, size);
    }
    break;
	}
}

void xvt_sbar_set_proportion(WINDOW win, SCROLL_TYPE t, int proportion)
{
  switch (t)
  {
  case HSCROLL:
  case VSCROLL:
	  {
  	  CAST_WIN(win, w);
		  CAST_SCROLL_TYPE(t, dir);
		  const int pos = w.GetScrollPos(dir);
		  const int range = w.GetScrollRange(dir);
		  w.SetScrollbar(dir, pos, proportion, range);
	  }
    break;
  case HVSLIDER:
    {
		  CAST_SLIDER(win, sc);
      sc.SetPageSize(proportion);
      sc.SetTickFreq(sc.GetMax()/proportion, 0);
    }
    break;
  default:
	  {
		  CAST_SCROLL(win, sb);
		  const int pos = sb.GetThumbPosition();
		  const int range = sb.GetRange();
		  sb.SetScrollbar(pos, proportion, range, proportion);
	  }
    break;
  }
}

void xvt_sbar_set_range(WINDOW win, SCROLL_TYPE t, int min, int max)
{
	XVT_ASSERT(min == 0 && max >= min);
  switch (t)
  {
  case HSCROLL:
  case VSCROLL:
	  {
  	  CAST_WIN(win, w);
		  CAST_SCROLL_TYPE(t, dir);
		  const int pos = w.GetScrollPos(dir);
		  const int size = w.GetScrollThumb(dir);
		  w.SetScrollbar(dir, pos, size, max);
	  }
    break;
  case HVGAUGE:
    {
    	CAST_GAUGE(win, g);
      g.SetRange(max);
    }
    break;
  case HVSLIDER:
    {
    	CAST_SLIDER(win, g);
      g.SetRange(min, max);
    }
    break;
  default:
    {
		  CAST_SCROLL(win, sb);
		  const int pos = sb.GetThumbPosition();
		  const int size = sb.GetThumbSize();
		  sb.SetScrollbar(pos, size, max, size);
    }
    break;
	}
}


///////////////////////////////////////////////////////////
// Window manager
///////////////////////////////////////////////////////////

void xvt_scr_beep(void)
{	
  xvt_sys_beep(0);
}

WINDOW xvt_scr_get_focus_topwin(void)
{
  wxWindow* w = _task_win->FindFocus();
  while (w != NULL && w->IsKindOf(CLASSINFO(wxControl)))
    w = w->GetParent();
	return (WINDOW)w;
}

WINDOW xvt_scr_get_focus_vobj(void)
{
	return (WINDOW)_task_win->FindFocus();
}

SLIST xvt_scr_list_wins()
{
	SLIST list = xvt_slist_create();
  _nice_windows.BeginFind();
  for (wxHashTable::Node* node = _nice_windows.Next(); node; node = _nice_windows.Next())
	{
  	wxWindow* pWin = wxDynamicCast(node->GetData(), wxWindow);
    if (pWin != NULL)
    {
      const char* title = pWin->GetLabel();
      xvt_slist_add_at_elt(list, NULL, title, (long)pWin);
    }
  }
	return list;
}

void xvt_scr_set_busy_cursor()
{
	xvt_win_set_cursor(TASK_WIN, CURSOR_WAIT);
}

void xvt_scr_set_focus_vobj(WINDOW win)
{
  CAST_WIN(win, w);
	w.SetFocus();
}

///////////////////////////////////////////////////////////
// String lists
///////////////////////////////////////////////////////////

BOOLEAN xvt_slist_add_at_elt(SLIST list, SLIST_ELT e, const char *sx, long data)
{
	const BOOLEAN ok = list != NULL;
	if (ok)
	{
    SLIST_ELT item = new SLIST_ITEM;
		item->str = xvt_str_duplicate(sx);
		item->data = data;
		item->next = NULL;

    SLIST_ELT last = NULL;
//    if (e != NULL)  // Add at head by default (else at tail)
//    {
		  for (SLIST_ELT i = list->head; i; i = (SLIST_ELT)i->next)
		  {
			  last = i;
			  if (i == e)
				  break;
		  }
//    }		
		if (last == NULL)
    {
      item->next = list->head;
			list->head = item;
    }
		else
		{
			item->next = last->next;
			last->next = item;
		}
		list->count++;
	}
	return ok;
}

int xvt_slist_count(SLIST list)
{
	return list != NULL ? list->count : 0;
}

SLIST xvt_slist_create()
{
	SLIST list = new xvtList;
	list->head = NULL;
	list->count = 0;
	return list;
}

void xvt_slist_destroy(SLIST list)
{
	if (list != NULL)
	{
		SLIST_ELT obj = list->head;
		while (obj != NULL)
		{
			SLIST_ELT tokill = obj;
		  xvt_mem_free(tokill->str);
			obj = (SLIST_ELT)tokill->next;
			delete tokill;
		}
	  delete list;
	}
}

char* xvt_slist_get(SLIST list, SLIST_ELT e, long* datap)
{
	if (list != NULL && e != NULL)
	{
		if (datap != NULL)
			*datap = e->data;
		return e->str;
	}
	return NULL;
}

long* xvt_slist_get_data(SLIST_ELT elt)
{
	return elt != NULL ? &elt->data : NULL;
}

SLIST_ELT xvt_slist_get_first(SLIST list)
{
	return list != NULL ? list->head : NULL;
}

SLIST_ELT xvt_slist_get_next(SLIST list, SLIST_ELT item)
{
	return (SLIST_ELT)(list != NULL && item != NULL ? item->next : NULL);
}

///////////////////////////////////////////////////////////
// XVT Strings???
///////////////////////////////////////////////////////////

int xvt_str_compare_ignoring_case (const char* s1, const char* s2)
{
	return wxStricmp(s1, s2);
}

char* xvt_str_duplicate(const char* str)
{
	return str ? wxStrdup(str) : NULL; // bleah!
}

char* xvt_str_number_format(char* str, int size)
{
#ifdef WIN32
  OsWin32_NumberFormat(str, size);
#else
  wxString txt;
  for (const char* s = str; *s; s++)
  {
    if (isdigit(*s))
      txt << *s;
    else
    {
      if (*s == '.')
        txt << ',';
    }
  }
  wxStrncpy(str, txt, size);
#endif
  return str;
}

BOOLEAN xvt_str_match(const char* mbs, const char *pat, BOOLEAN case_sensitive)
{
/*
  // Attualmente la wxString::Matches funziona solo con * e ?   :-(
 	wxString text = mbs;
  wxString pattern = pat;
	if (!case_sensitive)
	{
		text.MakeUpper();
		pattern.MakeUpper();
	}
	return text.Matches(pattern);  
*/

  // Uso la vecchia funzione implementata anticamente in agalib
  if (case_sensitive)
    return match(pat, mbs);      

 	wxString text    = mbs; text.MakeUpper();
  wxString pattern = pat; pattern.MakeUpper();
  return match(pattern, text);      
}

void xvt_str_make_upper(char* str)
{
  wxString s(str);
  s.MakeUpper();
  wxStrcpy(str, s);
}

void xvt_str_make_lower(char* str)
{
  wxString s(str);
  s.MakeLower();
  wxStrcpy(str, s);
}

double xvt_str_fuzzy_compare (const char* s1, const char* s2)
{
	return fstrcmp(s1, s2);
}

double xvt_str_fuzzy_compare_ignoring_case (const char* s1, const char* s2)
{
  wxString str1(s1); str1.MakeUpper();
  wxString str2(s2); str1.MakeUpper();
  return fstrcmp(str1, str2);
}

BOOLEAN xvt_chr_is_digit(int c)
{
	return (c <= 255) && wxIsdigit(c);
}

BOOLEAN xvt_chr_is_alpha(int c)
{
	return (c <= 255) && wxIsalpha(c);
}

BOOLEAN xvt_chr_is_alnum(int c)
{
	return (c <= 255) && wxIsalnum(c);
}

int xvt_net_get_status()
{
  int nStatus = 0;
  wxDialUpManager* dum = wxDialUpManager::Create();
  if (dum != NULL)
  {
    if (dum->IsOk() && dum->IsOnline())
    {
      nStatus = 0x1;      // 1 = Online
      
      if (dum->IsAlwaysOnline())
        nStatus |= 0x2;   // 2 = Always Online

      wxArrayString isp;
      if (dum->GetISPNames(isp) > 0)
        nStatus |= 0x4;   // 4 = Internet enabled
    }
    delete dum;
  }
  return nStatus;
}

///////////////////////////////////////////////////////////
// XVT system calls (added by Guy)
///////////////////////////////////////////////////////////

void xvt_sys_beep(int severity)
{
#ifdef WIN32
	OsWin32_Beep(severity);
#else
	wxBell();
#endif
}

BOOLEAN xvt_sys_get_host_name(char* name, int maxlen)
{
	wxString str = wxGetHostName();
	wxStrncpy(name, str, maxlen);
	name[maxlen-1] = '\0';
	return *name > '\0';
}

BOOLEAN xvt_sys_get_user_name(char* name, int maxlen)
{
	wxString str = wxGetUserId();
	wxStrncpy(name, str, maxlen);
	name[maxlen-1] = '\0';
	return *name > '\0';
}

///////////////////////////////////////////////////////////
// Process processing 
///////////////////////////////////////////////////////////
static bool __bChildRunning = false;

class TIconizeTaskThread : public wxThread
{
protected:
  virtual ExitCode Entry();
public:
  TIconizeTaskThread();
};

wxThread::ExitCode TIconizeTaskThread::Entry()
{
  ::wxMilliSleep(500);
  if (__bChildRunning) // Il programma e' ancora attivo
    _task_win->Iconize();
  return 0;
}

TIconizeTaskThread::TIconizeTaskThread()
{
  Create();
  SetPriority(WXTHREAD_MIN_PRIORITY);
  Run();
}

long xvt_sys_execute(const char* cmdline, BOOLEAN sync, BOOLEAN iconizetask)
{
  long exitcode = 0;
  wxString cmd(cmdline);
  
#ifdef LINUX
	if (isalpha(cmd[0u]))
		cmd = "./" + cmd;
#endif

  if (sync)
  {
    if (iconizetask)
    {
      wxEnableTopLevelWindows(FALSE);
   
      TIconizeTaskThread* it = new TIconizeTaskThread(); // No need to delete
        __bChildRunning = true;
      exitcode = wxExecute(cmd, wxEXEC_SYNC);
      __bChildRunning = false;
      
      if (_task_win->IsIconized())
        _task_win->Restore();
      wxEnableTopLevelWindows(TRUE);
    }
    else
      exitcode = wxExecute(cmd, wxEXEC_SYNC); // Valutare wxEXEC_NODISABLE
    _task_win->Raise();
  }
  else
    exitcode = wxExecute(cmd, wxEXEC_ASYNC);

  return exitcode;
}

long xvt_sys_execute_in_window(const char* cmdline, WINDOW win)
{
  const long inst = xvt_sys_execute(cmdline, FALSE, FALSE);
  if (inst > 0 && win != NULL_WIN)
  {
    CAST_WIN(win, w);
#ifdef WIN32
    OsWin32_PlaceProcessInWindow(inst, "", (unsigned int)w.GetHandle());
#else
    OsLinux_PlaceProcessInWindow(inst, "", w.GetHandle());
#endif
  }
  return inst;
}

long xvt_sys_close_children(WINDOW win)
{
  long c = 0;
#ifdef WIN32
  CAST_WIN(win, w);
  c = OsWin32_CloseChildren((unsigned int)w.GetHandle());
#endif
  return c;
}

long xvt_sys_close_siblings(WINDOW win)
{
 long c = 0; // Non sto a perder tempo a contarli :-)
#ifdef WIN32
  CAST_WIN(win, w);
  OsWin32_CloseSiblings((unsigned int)w.GetHandle());
#endif
  return c; 
}

BOOLEAN xvt_sys_goto_url(const char* url, const char* action)
{
#ifdef WIN32
  return OsWin32_GotoUrl(url, action);
#else
  SORRY_BOX(); // TBI
  return FALSE;
#endif
}

BOOLEAN xvt_sys_dongle_server_is_running()
{
  wxSingleInstanceChecker sic("Authorization");
  BOOLEAN ok = sic.IsAnotherRunning();

#ifdef WIN32
  if (!ok) // Testo anche il buon vecchio Frontend!
    ok = ::GlobalFindAtom("DONGLE_SERVER_ATOM") != 0;
#endif

  return ok;
}

int xvt_sys_get_profile_string(const char* file, const char* paragraph, const char* name,
                               const char* defval, char* value, int maxsize)
{
  if (file == NULL || *file == '\0')
    file = xvt_fsys_get_campo_ini();

  if (paragraph == NULL || *paragraph == '\0')
    paragraph = "Main";

#ifdef WIN32
  int len = ::GetPrivateProfileString(paragraph, name, defval, value, maxsize, file);
#else
	wxFileConfig ini("", "", file, "", wxCONFIG_USE_LOCAL_FILE | wxCONFIG_USE_RELATIVE_PATH);

  wxString path;
	path << "/" << paragraph;
	ini.SetPath(path);
	
  int len = 0;
	wxString val;
	if (!ini.Read(name, &val))
    val = defval;

  len = val.Length();
  if (value)
  {
    wxStrncpy(value, val, maxsize);
    value[maxsize-1] = '\0';
  }
#endif

  return len;
}

BOOLEAN xvt_sys_set_profile_string(const char* file, const char* paragraph, const char* name,
                                   const char* value)
{
  if (file == NULL || *file == '\0')
    file = xvt_fsys_get_campo_ini();

  if (paragraph == NULL || *paragraph == '\0')
    paragraph = "Main";

#ifdef WIN32
  return ::WritePrivateProfileString(paragraph, name, value, file);
#else
	wxFileConfig ini("", "", file, "", wxCONFIG_USE_LOCAL_FILE | wxCONFIG_USE_RELATIVE_PATH);
	ini.SetUmask(0x0);

  wxString path;
	path << "/" << paragraph;
	ini.SetPath(path);

	return ini.Write(name, value);
#endif
}

BOOLEAN xvt_sys_find_editor(const char* file, char* editor)
{
  BOOLEAN ok = FALSE;

#ifdef WIN32
  const wxString e = OsWin32_File2App(file);
#else
  const wxString e = OsLinux_File2App(file);
#endif
  ok = !e.IsEmpty();
  if (ok && editor != NULL)
    wxStrcpy(editor, e);

  return ok;
}

unsigned int xvt_sys_load_icon(const char* file)
{
  unsigned int id = 0;
  wxIcon* icon = NULL;

  wxString str = file;
  str.MakeLower();
  if (str.EndsWith(".ico"))
		icon = new wxIcon(file, wxBITMAP_TYPE_ICO);
  else
  {
#ifdef WIN32
    WXHICON hicon = (WXHICON)OsWin32_LoadIcon(file);
    if (hicon)
    {
      icon = new wxIcon;
      icon->SetHICON(hicon);
    }
#else
    icon = new wxIcon;
#endif
  }

  if (icon != NULL)
  {
    for (id = 60001; ; id++)
    {
      wxIcon* ico = wxDynamicCast(_nice_icons.Get(id), wxIcon);
      if (ico == NULL)
      {
	  	  _nice_icons.Put(id, icon);
        break;
      }
      else
      {
#ifdef WIN32
        if (ico->GetHICON() == icon->GetHICON())  // C'e' gia'
#else
        if (ico == icon)  // C'e' gia'
#endif
        {
          delete icon;
          break;
        }
      }
    }
  }

  return id;
}

int xvt_sys_get_session_id()
{
#ifdef WIN32
	return OsWin32_GetSessionId();
#else
	return OsLinux_GetSessionId();
#endif
}
                                   
unsigned long xvt_sys_get_free_memory()
{
  unsigned long mem = 0;

  if (::wxGetFreeMemory().GetHi())
    mem = (unsigned long)-1;
  else
    mem = ::wxGetFreeMemory().GetLo();

  return mem;
}

unsigned long xvt_sys_get_free_memory_kb()
{
  unsigned long mem = xvt_sys_get_free_memory();
  return mem / 1024;  // Arrotondo per difetto
}

int xvt_sys_get_os_version()
{
  int os = 0;
  int major, minor;
  switch (::wxGetOsVersion(&major, &minor))
  {
#ifdef WIN32
  case wxWIN95:
    os = minor == 0 ? XVT_WS_WIN_95 : XVT_WS_WIN_98; break;
  case wxWINDOWS_NT:
    os = XVT_WS_WIN_NT; 
    if (OsWin32_IsWindowsServer())
      os = XVT_WS_WIN_SERVER;
    break;
#else
  case wxGTK:
    os = XVT_WS_LINUX; break;
#endif
  default:
    break;
  }
  return os;
}

int xvt_sys_get_version(char* os_version, char* ptk_version, int maxsize)
{
  wxStrncpy(os_version, wxGetOsDescription(), maxsize);
  wxStrncpy(ptk_version, wxVERSION_STRING, maxsize);
  return xvt_sys_get_os_version();
}

void xvt_sys_sleep(unsigned long msec)
{
  ::wxMilliSleep(msec);
}

///////////////////////////////////////////////////////////
// XVT system calls (added by Alex)
///////////////////////////////////////////////////////////

XVTDLL BOOLEAN xvt_sys_get_env(const char* varname, char* value, int max_size)
{
  const wxString strName(varname);
  wxString strValue;
  const BOOLEAN ok = wxGetEnv(strName, &strValue);
  if (ok)
    wxStrncpy(value, strValue, max_size);
  return ok;
}

void xvt_sys_searchenv(const char * filename, const char * varname, char * pathname)
{
  DEPRECATED_BOX();
  xvt_sys_search_env(filename, varname, pathname);
}

void xvt_sys_search_env(const char * filename, const char * varname, char * pathname)
{
#ifdef WIN32
  _searchenv(filename, varname, pathname);
#else
	const char * value = wxGetEnv(varname);
	if (value)
	{
	  char path_list[4096];
    strcpy(path_list, value);
    for (const char* s = path_list; *s; )
    {
      char* s1 = strchr(s, ';');
      if (s1 != NULL)
        *s1 = '\0';
      xvt_fsys_build_pathname(pathname, NULL, s, filename, NULL, NULL);
      if (xvt_fsys_file_exists(pathname))
        break;
      if (s1 != NULL)
        s = s1 + 1;
      else
        break;
    }
	}
	else
		*pathname = '\0';
#endif
}

BOOLEAN xvt_sys_set_env(const char* varname, const char* value)
{
  const wxString strName(varname);
  return value != NULL ? wxSetEnv(strName, value) : wxUnsetEnv(strName);
}

// BOOLEAN o int? Adso!
int xvt_fsys_access(const char *pathname, int mode)
{
  return wxAccess(pathname, mode) == -1 ? errno : 0;
}

BOOLEAN xvt_fsys_file_exists(const char *pathname)
{
  return xvt_fsys_file_attr(pathname, XVT_FILE_ATTR_EXIST);
}

BOOLEAN xvt_fsys_mkdir(const char *pathname)
{
  if (wxDirExists(pathname))
    return TRUE;
  return wxMkdir(pathname);
}

BOOLEAN xvt_fsys_rmdir(const char *pathname)
{
  if (!wxDirExists(pathname))
    return TRUE;
  return wxRmdir(pathname);
}

BOOLEAN xvt_fsys_remove_file(const char *pathname)
{
  return wxRemoveFile(pathname);
}

BOOLEAN xvt_fsys_removefile(const char *pathname)
{
  DEPRECATED_BOX();
  return xvt_fsys_remove_file(pathname);
}


///////////////////////////////////////////////////////////
// Timers
///////////////////////////////////////////////////////////

struct tm* xvt_time_now()
{
  return wxDateTime::GetTmNow();
}

long xvt_timer_create(WINDOW win, long interval)
{
	CAST_TWIN(win, w);
	if (w._timer == NULL)
	  w._timer = new wxTimer(&w, TIMER_ID);
  w._timer->Start(interval);
	return win;
}

void xvt_timer_destroy(long id)
{
  if (id > 0L)
  {
    CAST_TWIN(id, w);
	  wxTimer*& t = w._timer;
	  if (t != NULL)
	  {
      t->Stop();
		  delete t;
      t = NULL;
	  }
  }
}

///////////////////////////////////////////////////////////
// Visual objects
///////////////////////////////////////////////////////////

static wxWindow* SafeCastWin(WINDOW win)
{
  wxWindow* w = wxDynamicCast(_nice_windows.Get(win), wxWindow);
  if (w != NULL)
  {
    wxASSERT(win == (WINDOW)w); 
    const TwxWindow* tw = wxDynamicCast(w, TwxWindow);
    if (tw != NULL && tw->InDestroy())
      w = NULL;
  }
  return w;
}

void xvt_vobj_destroy(WINDOW win)
{
  wxWindow* w = SafeCastWin(win);
  if (w != NULL)
  {
    xvt_win_set_caret_visible(win, FALSE);
    w->Destroy();              // same as delete w
    _nice_windows.Delete(win); // Elimina "di nuovo" dalla lista delle finestre attive
  }
}

long xvt_vobj_get_attr(WINDOW win, long data)
{
	long ret = 0L;
	switch(data)
	{
	case ATTR_APP_CTL_COLORS:
		{
			XVT_COLOR_COMPONENT* xcc = (XVT_COLOR_COMPONENT*)xvt_mem_zalloc(sizeof(XVT_COLOR_COMPONENT)*16);
      
      // XVT components
			xcc[0].type = XVT_COLOR_FOREGROUND;
			xcc[0].color = MAKE_XVT_COLOR(wxSystemSettings::GetColour(wxSYS_COLOUR_BTNTEXT));
			xcc[1].type = XVT_COLOR_BACKGROUND;
			xcc[1].color = MAKE_XVT_COLOR(wxSystemSettings::GetColour(wxSYS_COLOUR_BTNFACE));
			xcc[2].type = XVT_COLOR_BLEND;
			xcc[2].color = MAKE_XVT_COLOR(wxSystemSettings::GetColour(wxSYS_COLOUR_BTNHIGHLIGHT));
			xcc[3].type = XVT_COLOR_BORDER;
			xcc[3].color = MAKE_XVT_COLOR(wxSystemSettings::GetColour(wxSYS_COLOUR_BTNSHADOW));
			xcc[4].type = XVT_COLOR_SELECT;
			xcc[4].color = MAKE_XVT_COLOR(wxSystemSettings::GetColour(wxSYS_COLOUR_HIGHLIGHT));
			xcc[5].type = XVT_COLOR_HIGHLIGHT;
			xcc[5].color = MAKE_XVT_COLOR(wxSystemSettings::GetColour(wxSYS_COLOUR_HIGHLIGHTTEXT));
			xcc[6].type = XVT_COLOR_TROUGH;
			xcc[6].color = MAKE_XVT_COLOR(wxSystemSettings::GetColour(wxSYS_COLOUR_WINDOW));

      // AGA components
			xcc[7].type = XVT_COLOR_CAPTIONLT;
			xcc[7].color = MAKE_XVT_COLOR(wxSystemSettings::GetColour(wxSYS_COLOUR_ACTIVECAPTION));
			xcc[8].type = XVT_COLOR_CAPTIONDK;
			xcc[8].color = MAKE_XVT_COLOR(wxSystemSettings::GetColour(wxSYS_COLOUR_INACTIVECAPTION));
			xcc[9].type = XVT_COLOR_CAPTIONTEXT;
			xcc[9].color = MAKE_XVT_COLOR(wxSystemSettings::GetColour(wxSYS_COLOUR_CAPTIONTEXT));
      
      // Last (NULL) component
			xcc[10].type = XVT_COLOR_NULL;
			xcc[10].color = 0;

      ret = (long)xcc;
		}
		break;
  case ATTR_FRAME_WIDTH:
#ifdef LINUX
    ret = 8; //verificare not impl
#else  
    ret = wxSystemSettings::GetMetric(wxSYS_FRAMESIZE_X);
#endif
    break;
  case ATTR_FRAME_HEIGHT:
#ifdef LINUX
    ret = 8; //verificare not impl
#else  
    ret = wxSystemSettings::GetMetric(wxSYS_FRAMESIZE_Y);
#endif
    break;
  case ATTR_MENU_HEIGHT:
    ret = wxSystemSettings::GetMetric(wxSYS_MENU_Y);
    break;
  case ATTR_TITLE_HEIGHT:
#ifdef LINUX
		ret = 32; //verificare not impl
#else  
		ret = wxSystemSettings::GetMetric(wxSYS_CAPTION_Y);
#endif
		break;
	case ATTR_CTL_VERT_SBAR_WIDTH:
		ret = wxSystemSettings::GetMetric(wxSYS_VSCROLL_X);
		break;
	case ATTR_CTL_HORZ_SBAR_HEIGHT:
		ret = wxSystemSettings::GetMetric(wxSYS_HSCROLL_Y);
		break;
	case ATTR_DISPLAY_TYPE:
		switch (::wxDisplayDepth()) // Test ormai ridicolo?
		{
		case  1: ret = XVT_DISPLAY_MONO; break;     // Ridicolissimo :-)
		case  4: ret = XVT_DISPLAY_COLOR_16; break;
    case  8: ret = XVT_DISPLAY_COLOR_256; break;
    default: ret = XVT_DISPLAY_DIRECT_COLOR; break;
    }
		break;
	case ATTR_ERRMSG_HANDLER:
		ret = (long)_error_handler;
		break;
	case ATTR_NATIVE_GRAPHIC_CONTEXT:
    SORRY_BOX(); // Obsoleto e non piu' usato
		break;
	case ATTR_NATIVE_WINDOW:
    {
      const wxWindow* w = SafeCastWin(win);
      if (w != NULL)
        ret = (long)w->GetHandle();
		}
		break;
	case ATTR_SCREEN_HEIGHT:
		ret = wxSystemSettings::GetMetric(wxSYS_SCREEN_Y);
		break;
	case ATTR_SCREEN_WIDTH:
		ret = wxSystemSettings::GetMetric(wxSYS_SCREEN_X);
		break;
	case ATTR_SCREEN_WINDOW:
		ret = 882L;	// Scelta arbitraria ma accettabile
    break;
  case ATTR_SPEECH_MODE:
		ret = m_nSpeechMode;
		break;
  case ATTR_TASK_WINDOW:
		ret = long(_task_win);
		break;
  case ATTR_PRINTER_WINDOW:
		ret = 883L; // Scelta arbitraria ma accettabile
		break;
  case ATTR_WIN_INSTANCE:
    ret = 0;
    break;
  case ATTR_WIN_OPENFILENAME_HOOK:
    ret = 0;
    break;
	case ATTR_WIN_PM_DRAWABLE_TWIN:
		ret = TRUE;
		break;
  case ATTR_WIN_PM_TWIN_STARTUP_STYLE:
    ret = _startup_style;
    break;
  case ATTR_ICON_WIDTH:
    ret = wxSystemSettings::GetMetric(wxSYS_ICON_X);
    break;
  case ATTR_ICON_HEIGHT:
    ret = wxSystemSettings::GetMetric(wxSYS_ICON_Y);
    break;
	default: 
    SORRY_BOX(); 
    break;
	}
	return ret;
}

RCT* xvt_vobj_get_client_rect(WINDOW win, RCT *rctp)
{
	XVT_ASSERT(rctp != NULL);
	int l, h;
	if (win != NULL_WIN)
	{
    if (win == PRINTER_WIN)
    {
      l = h = 6000; // circa A4 height
    } else
    if (win == SCREEN_WIN)
    {
  		l = wxSystemSettings::GetMetric(wxSYS_SCREEN_X);
	  	h = wxSystemSettings::GetMetric(wxSYS_SCREEN_Y) - 32; // Puerile tentativo di escludere la task bar
    } else
    {
  	  CAST_WIN(win, w);
	    w.GetClientSize(&l, &h);
    }
	}
	else // NULL_WIN = schermo intero
	{
		l = wxSystemSettings::GetMetric(wxSYS_SCREEN_X);
		h = wxSystemSettings::GetMetric(wxSYS_SCREEN_Y);
	}

	rctp->left = rctp->top = 0;
	rctp->right = l; rctp->bottom = h;
	return rctp;
}

long xvt_vobj_get_data(WINDOW win)
{
  const TwxWindow* w = wxDynamicCast(SafeCastWin(win), TwxWindow);
  return w != NULL ? w->_app_data : 0L;
}

RCT* xvt_vobj_get_outer_rect(WINDOW win, RCT *rctp)
{
	XVT_ASSERT(rctp != NULL);
	CAST_WIN(win, w);
	const wxRect rct = w.GetRect();
	rctp->left   = rct.x;	
  rctp->top    = rct.y;
  rctp->right  = rct.GetRight();
  rctp->bottom = rct.GetBottom();
	return rctp;
}

XVT_PALETTE xvt_vobj_get_palet(WINDOW WXUNUSED(win))
{ return NULL; }

WINDOW xvt_vobj_get_parent(WINDOW win)
{
	if (win == NULL_WIN || win == TASK_WIN)
		return NULL_WIN;
	CAST_WIN(win, w);
	return (WINDOW)w.GetParent();
}

char* xvt_vobj_get_title(WINDOW win, char *title, int sz_title)
{
	CAST_WIN(win, w);
	wxStrncpy(title, w.GetLabel(), sz_title);
	title[sz_title-1] = '\0';
	return title;
}

WIN_TYPE xvt_vobj_get_type(WINDOW win)
{
  if (win == NULL_WIN)
    return W_NONE;
  if (win == TASK_WIN)
    return W_TASK;
  if (win == SCREEN_WIN)
    return W_SCREEN;
  if (win == PRINTER_WIN)
    return W_PRINT;
  
  TwxWindow* w = wxDynamicCast((wxObject*)win, TwxWindow);
  if (w != NULL)
    return w->_type;
  
  return WO_TE; // Unknown custom control
}
        
BOOLEAN xvt_vobj_is_focusable(WINDOW win)
{
	BOOLEAN ok = win != NULL_WIN && win != PRINTER_WIN && xvt_vobj_is_valid(win);
  if (ok)
  {
    CAST_WIN(win, w);
    ok = w.IsEnabled() && w.IsShownOnScreen();
  }
  return ok;
}

BOOLEAN xvt_vobj_is_valid(WINDOW win)
{
  return win != NULL_WIN && SafeCastWin(win) != NULL;
}

void xvt_vobj_maximize(WINDOW win)
{
  XVT_ASSERT(win != NULL_WIN && _task_win != NULL);
  if (win == TASK_WIN)
    _task_win->Maximize();
  else
  {
    CAST_WIN(win, w);
    int width, height;
    _task_win->GetClientSize(&width, &height);
    w.SetSize(0, 0, width, height);
  }
}

void xvt_vobj_minimize(WINDOW win)
{
  wxFrame* pMain = wxDynamicCast((wxObject*)win, wxFrame);
  if (pMain != NULL)
    pMain->Iconize();
  else
    SORRY_BOX();
}

void xvt_vobj_move(WINDOW win, const RCT* rctp)
{
	CAST_WIN(win, w);
	const wxRect rct = NormalizeRCT(rctp);
  w.Move(rct.x, rct.y);
	w.SetClientSize(rct.width, rct.height);
}

void xvt_vobj_raise(WINDOW win)
{
	CAST_WIN(win, w);
	w.Raise();
}

static void SetArtistColor(WINDOW win, int id, long rgb)
{
  CAST_WIN(win, w);
  const wxAuiManager* pMgr = wxAuiManager::GetManager(&w);
  wxAuiDockArt* pArt = (pMgr != NULL) ? pMgr->GetArtProvider() : NULL;
  if (pArt != NULL)
  {
    CAST_COLOR(rgb, col);
    pArt->SetColour(id, col);
    if (id == wxAUI_DOCKART_BACKGROUND_COLOUR)
    {
    }
  }
}

void xvt_vobj_set_attr(WINDOW win, long data, long value)
{
	switch (data)
	{
  case ATTR_BACK_COLOR: SetArtistColor(win, wxAUI_DOCKART_BACKGROUND_COLOUR, value); break;
	case ATTR_ERRMSG_HANDLER: _error_handler = (XVT_ERRMSG_HANDLER)value; break;
  case ATTR_EVENT_HOOK: SORRY_BOX(); break;   // TBI?: Native events hook!
	case ATTR_WIN_PM_DRAWABLE_TWIN: break;      // Ignored: Always TRUE
  case ATTR_WIN_PM_TWIN_STARTUP_RCT: _startup_rect = *(RCT*)value; break;
  case ATTR_WIN_PM_TWIN_STARTUP_STYLE: _startup_style = value; break;
  case ATTR_SPEECH_MODE: xvt_dm_enable_speech(value); break;
	default: SORRY_BOX(); break;
	}
}	

void xvt_vobj_set_data(WINDOW win, long app_data)
{
	CAST_TWIN(win, w);
	w._app_data = app_data;
}

void xvt_vobj_set_enabled(WINDOW win, BOOLEAN enabled)
{
	CAST_WIN(win, w);
	w.Enable(enabled != 0);
}

void xvt_vobj_set_palet(WINDOW win, XVT_PALETTE palet)
{
	// Do not implement!
}

void xvt_vobj_set_title(WINDOW win, const char* title)
{
	CAST_WIN(win, w);
	w.SetLabel(title);
}

void xvt_vobj_set_visible(WINDOW win, BOOLEAN show)
{
	CAST_WIN(win, w);
	w.Show(show != 0);
}

void xvt_vobj_translate_points(WINDOW from_win, WINDOW to_win, PNT *pntp, int npnts)
{
	XVT_ASSERT(from_win != NULL_WIN && to_win != NULL_WIN);
	XVT_ASSERT(pntp != NULL && npnts > 0);
	CAST_WIN(from_win, w1);
	CAST_WIN(to_win, w2);
	for (int i = 0; i < npnts; i++)
	{
		int x = pntp[i].h;
		int y = pntp[i].v;
		w1.ClientToScreen(&x, &y);
		w2.ScreenToClient(&x, &y);
    pntp[i].h = x;
		pntp[i].v = y;
	}
}

///////////////////////////////////////////////////////////
// Real windows
///////////////////////////////////////////////////////////

WINDOW xvt_win_create(WIN_TYPE wtype, const RCT* rct_p, const char* title, int menu_rid, WINDOW parent, long win_flags, EVENT_MASK mask, EVENT_HANDLER eh, long app_data)
{
  const wxRect rct = NormalizeRCT(rct_p);
	const wxString caption = title;

  long style = wxCLIP_SIBLINGS | wxCLIP_CHILDREN | wxWANTS_CHARS;
	if (win_flags & WSF_VSCROLL)
		style |= wxVSCROLL;
	if (win_flags & WSF_HSCROLL)
		style |= wxHSCROLL;

	TwxWindow* w = NULL;
  switch (wtype)
	{
	case W_DOC:
		style |= wxSYSTEM_MENU; // Questo flag in realta' viene interpretato come wxCAPTION
    if (win_flags & WSF_CLOSE)
      style |= wxCLOSE_BOX;
		break;
	case W_PLAIN:
		// style |= wxBORDER;  // Non attivare MAI il bordo!
    if (win_flags & WSF_TRANSPARENT)
      style |= wxTRANSPARENT_WINDOW;
		break;
	default:
		SORRY_BOX(); break;
	}
  if (parent == SCREEN_WIN)
    parent = NULL;
  w = new TwxWindow((wxWindow*)parent, -1, caption, rct.GetPosition(), rct.GetSize(), style);

	w->_type = wtype;
	w->_app_data = app_data;
  w->SetBackgroundStyle(wxBG_STYLE_CUSTOM); // Lo sfondo viene disegnato nella OnPaint

#ifdef WIN32
  OsWin32_SetCaptionStyle(w->GetHWND(), style);
#else
  OsLinux_SetCaptionStyle(w, style);
#endif

  if (menu_rid > 0 && menu_rid != 8000)     // 8000 = NULL_MENU_RID
	{
		MENU_ITEM* mi = xvt_res_get_menu(menu_rid);
		if (mi)
		{
      w->SetMenuTree(mi);
		  xvt_res_free_menu_tree(mi);
		}
	}

	if (style & wxHSCROLL)
	  w->SetScrollbar(wxHORIZONTAL, 0, 1, 100);
	if (style & wxVSCROLL)
	  w->SetScrollbar(wxVERTICAL, 0, 1, 100);

  if (win_flags & WSF_DISABLED)
		w->Disable();
	else
		w->Enable();

  if (win_flags & WSF_INVISIBLE)
		w->Hide();
	else
		w->Show(); // Non dovrebbe mai succedere nel nostro caso

  // Accetta messaggi solo da ora!
  w->_eh = eh;

	EVENT e; memset(&e, 0, sizeof(e));
  e.type = E_CREATE; // Serve a poco, ma fa' lo stesso
	eh((WINDOW)w, &e);
  
  xvt_vobj_move((WINDOW)w, rct_p); // Forza la giusta dimensione della client area

	return (WINDOW)w;
}

long xvt_win_dispatch_event(WINDOW win, EVENT* event_p)
{
	XVT_ASSERT(win != NULL_WIN && event_p != NULL);

  if (win == (WINDOW)_task_win)
    return _task_win_handler(win, event_p);
	
	CAST_TWIN(win, w);
	return w._eh(win, event_p);
}

BOOLEAN xvt_win_enum_wins(WINDOW parent_win, XVT_ENUM_CHILDREN func, long data, unsigned long /*reserved*/)
{
  CAST_WIN(parent_win, w)
  wxWindowList& list = w.GetChildren();
  const BOOLEAN ok = list.GetCount() > 0;
  if (ok && func != NULL)
  {
    for (wxWindowList::iterator i = list.begin(); i != list.end(); ++i)
    {
      wxWindow* tw = wxDynamicCast(*i, wxWindow);
      if (tw != NULL)
      {
        if (!func((WINDOW)tw, data))
          break;
      }
    }
  }
  return ok;
}

long xvt_win_get_children_count(WINDOW parent_win)
{
  long nCount = 0;
  if (parent_win != NULL_WIN)
  {
    CAST_WIN(parent_win, w)
#ifdef WIN32
    nCount = OsWin32_GetChildrenCount((unsigned int)w.GetHandle());
#else
    nCount = w.GetChildren().GetCount();
#endif
  }
  return nCount;
 }

void xvt_win_post_event(WINDOW win, EVENT* event_p)
{
  // Per ora e' garantito che funzioni solo con la task window
  CAST_WIN(win, w);
  switch (event_p->type)
  {
  case E_COMMAND:
    {
      wxCommandEvent e(wxEVT_COMMAND_MENU_SELECTED, event_p->v.cmd.tag);
      e.SetEventObject(&w);
      wxPostEvent(&w, e);
    }
    break;
  default:
    SORRY_BOX();
    break;
  }
}

void xvt_win_release_pointer(void)
{
	if (_mouse_trapper != NULL)
	{
		// cap SHOULD be equal to _mouse_trapper :-)
    wxWindow* cap = wxWindow::GetCapture();
		if (cap != NULL)
      cap->ReleaseMouse();
    _mouse_trapper = NULL;
	}
}

void xvt_win_set_cursor(WINDOW win, CURSOR cursor)
{
	CAST_WIN(win, w);
  const	wxCursor* cur = wxSTANDARD_CURSOR;  // Dummy initilization
	switch (cursor)
	{
	case CURSOR_ARROW: cur = wxSTANDARD_CURSOR; break;
	case CURSOR_CROCE: cur = wxCROSS_CURSOR; break;
	case CURSOR_WAIT : cur = wxHOURGLASS_CURSOR; break;
	default: cur = GetCursorResource(cursor); break; // Always succeeds
	}
	w.SetCursor(*cur);
}

void xvt_win_set_handler(WINDOW win, EVENT_HANDLER eh)
{
	if (win == (WINDOW)_task_win)
	{
		_task_win_handler = eh;
	}
	else
	{
	  CAST_TWIN(win, w);
	  w._eh = eh;
	}
}

void xvt_win_trap_pointer(WINDOW win)
{
	CAST_WIN(win, w);
	xvt_win_release_pointer();
  w.CaptureMouse();
	_mouse_trapper = &w;
}

///////////////////////////////////////////////////////////
// Status bar
///////////////////////////////////////////////////////////

static wxStatusBar* WIN2StatBar(WINDOW win)
{
  wxStatusBar* pStatusBar = NULL;
	if (win == NULL_WIN || win == TASK_WIN)
    pStatusBar = _task_win->GetStatusBar();
  else
    pStatusBar = wxDynamicCast((wxObject*)win, wxStatusBar);
  return pStatusBar;
}

const char* statbar_set_title(WINDOW win, const char* text)
{
  wxStatusBar* pStatusBar = WIN2StatBar(win);
  if (pStatusBar != NULL)
  {
    if (text == NULL)
	    text = _strDefaultStatbarText;
    wxStringTokenizer tok(text, "\t", wxTOKEN_RET_EMPTY);
    for (int t = 0; tok.HasMoreTokens(); t++)
      pStatusBar->SetStatusText(tok.GetNextToken(), t);
  }
  return text;
}

const char* statbar_set_default_title(WINDOW win, const char *text)
{
	_strDefaultStatbarText = text;
	return statbar_set_title(win, text);
}

XVT_FNTID statbar_set_fontid(WINDOW win, XVT_FNTID font_id)
{
  wxStatusBar* pStatBar = WIN2StatBar(win);
  if (pStatBar != NULL && font_id != NULL)
  {
    CAST_FONT(font_id, font);
    pStatBar->SetFont(font.Font(NULL, win));
  }
	return font_id;
}

XVT_FNTID statbar_get_fontid(WINDOW win, XVT_FNTID font_id)
{
  wxStatusBar* pStatBar = WIN2StatBar(win);
  if (pStatBar != NULL && font_id != NULL)
  {
    CAST_FONT(font_id, font);
  	font.Copy(pStatBar->GetFont());
  }
	return font_id;
}

WINDOW statbar_create(int cid, int left, int top, int right, int bottom,
		 int prop_count, char **prop_list, WINDOW parent_win,
		 int parent_rid, long parent_flags, char *parent_class)
{
  wxStatusBar* pStatusBar = NULL;
  wxFrame* w = wxDynamicCast(SafeCastWin(parent_win), wxFrame);
  if (w != NULL)
  {
    const int nStyle = 0; // not wxST_SIZEGRIP
	  pStatusBar = w->CreateStatusBar(3, nStyle);
    if (pStatusBar != NULL)
    {
      const int widths[4] = { -4, -5, -2, 0 };
	    pStatusBar->SetStatusWidths(3, widths);
    }
  }
	return (WINDOW)pStatusBar;
}

BOOLEAN statbar_destroy(WINDOW win)
{
  wxStatusBar* pStatusBar = WIN2StatBar(win);
  if (pStatusBar != NULL)
  {
    if (_task_win->GetStatusBar() == pStatusBar)
      _task_win->SetStatusBar(NULL);
    pStatusBar->Destroy();
  }
  return pStatusBar != NULL;
}