#include "wxinc.h"

#include "wx/clipbrd.h"
#include "wx/confbase.h"
#include "wx/fileconf.h"
#include "wx/fontdlg.h"
#include "wx/image.h"
#include "wx/print.h"
#include "wx/printdlg.h"

#include "wx/fs_zip.h" 
#include "wx/html/helpctrl.h"

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

#include "xvintern.h"
#include "agasys.h"

// Funzione di utilita'
MENU_ITEM* xvt_menu_duplicate_tree(const MENU_ITEM* m);

#ifdef WIN32
#include "oswin32.h"
#endif

XVT_CONFIG* _config_ = NULL;
wxWindow*   _task_win = NULL;
wxWindow*   _mouse_trapper = NULL;
RCT*        _startup_rect = NULL;
wxString    _startup_dir;

static EVENT_HANDLER _task_win_handler = NULL;

static XVT_ERRMSG_HANDLER _error_handler = NULL;

void XVT_ASSERT(bool test, XVT_ERRSEV sev = SEV_FATAL)
{
	if (!test)
	{
		bool display = (_error_handler == NULL) || (_error_handler(sev, NULL) == FALSE);
    if (display)
		{
    	const wxString strMessage = "We're very sorry, but you passed some invalid parameters...";
	    const wxString strCaption = "Emulated XVT Error";
      ::wxMessageBox(strMessage, strCaption, wxOK|wxICON_ERROR);
		}
	}
}

#define SORRY_BOX() sorry_box(__LINE__)

void sorry_box(int line)
{
  static wxHashTable sorry;
	if (sorry.Get(line) == NULL)
	{
		sorry.Put(line, &sorry); // Dummy
		const wxString strMessage =	wxString::Format("Function at line %d not implemented", line);
		::wxMessageBox(strMessage);
	}
}

#define CAST_WIN(win,w) XVT_ASSERT(win != NULL_WIN); wxWindow& w = *(wxWindow*)win

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;
}

wxRect NormalizeRCT(const RCT* prct)
{
	XVT_ASSERT(prct != NULL);
	wxRect rct;
	rct.x = min(prct->left, prct->right);
	rct.y = min(prct->top, prct->bottom);
	rct.width = abs(prct->right - prct->left);
	rct.height = abs(prct->bottom - prct->top);
	return rct;
}

wxString GetResourceName(const char* type, int rid)
{
	wxString strName;
  strName = _startup_dir;
  strName += "/res/resource.ini";
	wxFileConfig ini("", "", strName);
	
	strName = "/"; strName += type; strName += "s";
	ini.SetPath(strName);
	
	wxString val;
	if (ini.Read(wxString::Format("%d", rid), &val))
	{
		strName = _startup_dir;
		strName += "/res/";
		strName += val;
	}
	else
		strName.Empty();
	return strName;
}

wxIcon* GetIconResource(int rid)
{
	static wxHashTable icons;
  wxIcon* icon = (wxIcon*)icons.Get(rid);
  if (icon == NULL)
	{
		wxString strName = ::GetResourceName("Icon", rid);
		if (::wxFileExists(strName))
		{
			icon = new wxIcon(strName, wxBITMAP_TYPE_ICO);
			icons.Put(rid, icon);
		}
	}
	XVT_ASSERT(icon != NULL);
	return icon;
}

wxCursor* GetCursorResource(int rid)
{
	static wxHashTable cursors;
  wxCursor* cursor = (wxCursor*)cursors.Get(rid);
  if (cursor == NULL)
	{
		switch (rid)
		{
		case CURSOR_IBEAM:
			cursor = new wxCursor(wxCURSOR_IBEAM);
    	break;
		default:
			{
				wxString strName = ::GetResourceName("Cursor", rid);
				if (::wxFileExists(strName))
				{
					cursor = new wxCursor(strName, wxBITMAP_TYPE_CUR);
					if (!cursor->Ok())
					{
						delete cursor;
						cursor = NULL;
					}
				}
			}
			break;
		}
		if (cursor == NULL)
		{
    	XVT_ASSERT(false);
			cursor = wxSTANDARD_CURSOR;
		}
		cursors.Put(rid, cursor);
	}
	return cursor;
}

///////////////////////////////////////////////////////////
// Caret emulation
///////////////////////////////////////////////////////////

class TwxCaret : private wxTimer
{
	WINDOW _owner;
  PNT _pos;
	wxSize _size;
  bool _visible;
	bool _drawn;

protected:
	void Toggle();
  virtual void Notify() { Toggle(); }

public:
	void SetPos(int x, int y) { _pos.h = x; _pos.v = y; }
	void SetSize(int x, int y) { _size.x = x; _size.y = y; }
	void Show(WINDOW w, bool on = true);
	void Hide() { Show(false); }
	bool IsVisible() const { return _visible; }
	WINDOW Owner() const { return _owner; }
	void Kill();

	TwxCaret() : _visible(false), _owner(NULL_WIN) { }
	virtual ~TwxCaret() { Kill(); }
} _TheCaret;

void TwxCaret::Kill() 
{ 
	_owner = NULL_WIN;
//	if (IsRunning())
//		Stop();
} 

void TwxCaret::Show(WINDOW w, bool on)
{
  if (_visible && _drawn)
		Toggle();  // Lo cancella

	_visible = on;
	if (on)
	{
		_owner = w;
		Toggle();
		wxTimer::Start(500); // Lampeggia ogni mezzo secondo
	}
	else
	{
    if (w == _owner)
			Kill();
	}
}

void TwxCaret::Toggle()
{
	if (!_visible || _owner == NULL_WIN)
		return;
		
	_drawn = !_drawn;

	DRAW_CTOOLS dct;
	xvt_dwin_get_draw_ctools(_owner, &dct);

	CPEN pen;
	pen.width = _size.x;
	pen.pat = PAT_SOLID;
	pen.style = P_SOLID;
	pen.color = _drawn ? dct.fore_color : dct.back_color;
	xvt_dwin_set_cpen(_owner, &pen);
	xvt_dwin_set_draw_mode(_owner, M_COPY);
	xvt_dwin_draw_set_pos(_owner, _pos);
	PNT p = _pos;	p.v -= _size.y-1;

	xvt_dwin_set_clip(_owner, NULL);  // Non si mai!
	xvt_dwin_draw_line(_owner, p);
	xvt_dwin_set_draw_ctools(_owner, &dct);
}

///////////////////////////////////////////////////////////
// Dummy application
///////////////////////////////////////////////////////////

class TMainApp : public wxApp
{
	virtual bool OnInit();
	virtual int OnExit();

  DECLARE_DYNAMIC_CLASS(TMainApp);
};

IMPLEMENT_DYNAMIC_CLASS(TMainApp, wxApp)

DECLARE_APP(TMainApp)

// IMPLEMENT_APP_NO_MAIN(TMainApp)
IMPLEMENT_APP(TMainApp)

bool TMainApp::OnInit()
{
	::wxInitAllImageHandlers();

	xvt_main(argc, argv);
	return FALSE;  // Prevents entering the Main Loop
}

int TMainApp::OnExit()
{
	return wxApp::OnExit();
}

///////////////////////////////////////////////////////////
// Generic Display context
///////////////////////////////////////////////////////////

#define CAST_COLOR(xc, wc) wxColour wc((xc>>16)&0xFF, (xc>>8)&0xFF, xc&0xFF)
#define MAKE_XVT_COLOR(wc) MAKE_COLOR(wc.Red(), wc.Green(), wc.Blue())

TDC::TDC(wxWindow* owner) : _dc(NULL)
{
  _owner = owner;

	memset(&_dct, 0, sizeof(_dct));
	_dct.pen.width = 0; 
	_dct.pen.pat = PAT_SOLID; 
  _dct.pen.style = P_SOLID; 
  _dct.pen.color = COLOR_BLACK; 
	_dct.brush.pat = PAT_HOLLOW;
  _dct.brush.color = COLOR_WHITE;
	_dct.mode = M_COPY;
	_dct.fore_color = COLOR_BLACK;
	_dct.back_color = COLOR_WHITE; 
	_dct.opaque_text = FALSE; 

  _font.SetPointSize(9);  // Default font

	SetClippingBox(NULL);

	_dirty = -1;  // Absolutely force setting
}

TDC::~TDC() 
{ 
	KillDC(); 
}

static int PatternToStyle(PAT_STYLE pat)
{
	int style;
	switch (pat)
	{
  case PAT_NONE:
  case PAT_HOLLOW:    style = wxTRANSPARENT; break;
  case PAT_SOLID:	    style = wxSOLID; break;
  case PAT_HORZ:      style = wxHORIZONTAL_HATCH; break;
  case PAT_VERT:      style = wxVERTICAL_HATCH; break;
  case PAT_FDIAG:	    style = wxFDIAGONAL_HATCH; break;
  case PAT_BDIAG:     style = wxBDIAGONAL_HATCH; break;
  case PAT_CROSS:     style = wxCROSS_HATCH; break;
  case PAT_DIAGCROSS: style = wxCROSSDIAG_HATCH; break;
  case PAT_RUBBER:	
  case PAT_SPECIAL:		style = wxSOLID; SORRY_BOX(); break;
	}
	return style;
}

static int PenStyleToStyle(PEN_STYLE s, PAT_STYLE p)
{
	int style;
	if (p != PAT_HOLLOW)
	{
		switch (s)
		{
		case P_DOT: style = wxDOT; break;
		case P_DASH: style = wxSHORT_DASH; break;
		case P_SOLID:
		default: style = wxSOLID; break;
		}
	}
	else
		style = wxTRANSPARENT;

	return style;
}


bool TDC::PenChanged() const
{
	const int diff = memcmp(&_dct.pen, &_real_dct.pen, sizeof(_dct.pen));
  return diff != 0;
}

bool TDC::BrushChanged() const
{
	const int diff = memcmp(&_dct.brush, &_real_dct.brush, sizeof(_dct.brush));
  return diff != 0;
}

bool TDC::FontChanged() const
{
  return _font != _real_font;
}

wxDC& TDC::GetDC(bool bPaint)
{
  if (bPaint)
	{
		KillDC();
	  _dc = new wxPaintDC(_owner);
  	_dirty = -1;
	}
	else
	{
		if (_dc == NULL)
		{
		  _dc = new wxClientDC(_owner);
    	_dirty = -1;
		}
	}

	if (_dirty)
	{
		if (_dirty < 0 || PenChanged())
		{
		  CAST_COLOR(_dct.pen.color, pen_color);
  		wxPen* pen = wxThePenList->FindOrCreatePen(pen_color, _dct.pen.width, PenStyleToStyle(_dct.pen.style, _dct.pen.pat));
	  	_dc->SetPen(*pen);
			_real_dct.pen = _dct.pen;
		}

		if (_dirty < 0 || BrushChanged())
		{
 		  CAST_COLOR(_dct.brush.color, brush_color);
		  wxBrush* brush = wxTheBrushList->FindOrCreateBrush(brush_color, PatternToStyle(_dct.brush.pat));
		  _dc->SetBrush(*brush);
			_real_dct.brush = _dct.brush;
		}

		if (_dirty < 0 || _dct.mode != _real_dct.mode)
		{
			switch(_dct.mode)
			{
			case M_COPY:     _dc->SetLogicalFunction(wxCOPY); break;
			case M_OR:       _dc->SetLogicalFunction(wxOR); break;
			case M_XOR:      _dc->SetLogicalFunction(wxXOR); break;
			case M_CLEAR:    _dc->SetLogicalFunction(wxCLEAR); break;
			case M_NOT_COPY: _dc->SetLogicalFunction(wxSRC_INVERT); break;
			case M_NOT_OR:   _dc->SetLogicalFunction(wxNOR); break;
			case M_NOT_XOR:
			case M_NOT_CLEAR:
			default: SORRY_BOX();
			}
			_real_dct.mode = _dct.mode;
		}

		if (_dirty < 0 || _dct.fore_color != _real_dct.fore_color)
		{
 		  CAST_COLOR(_dct.fore_color, fore_color);
		  _dc->SetTextForeground(fore_color);
			_real_dct.fore_color = _dct.fore_color;
		}

		if (_dirty < 0 || _dct.back_color != _real_dct.back_color)
		{
 		  CAST_COLOR(_dct.back_color, back_color);
		  _dc->SetTextBackground(back_color);
			_real_dct.back_color = _dct.back_color;
		}

		if (_dirty < 0 || _dct.opaque_text != _real_dct.opaque_text)
		{
		  _dc->SetBackgroundMode(_dct.opaque_text ? wxSOLID : wxTRANSPARENT);
			_real_dct.opaque_text = _dct.opaque_text;
		}

		if (_dirty < 0 || FontChanged())
		{
 		  _dc->SetFont(_font.Font());
			_real_font = _font;
		}
		
		_dirty = false;
	}
	return *_dc;
}

void TDC::KillDC()
{
	if (_dc != NULL)
	{
  	SetClippingBox(NULL);
		delete _dc;
  	_dc = NULL;
	}
}

void TDC::SetClippingBox(const RCT* pRct)
{
	if (pRct)
	{
#if !wxCHECK_VERSION(2,3,2)
		if (_dc != NULL)  
	  	_dc->DestroyClippingRegion();
#endif
		wxRect rct = NormalizeRCT(pRct);
		// rct.width++; rct.height++;
		GetDC().SetClippingRegion(rct);
  	_clip = *pRct;
	}
	else
	{
		if (_dc != NULL)  // Inutile resettare il nulla!
	  	_dc->DestroyClippingRegion();
  	xvt_rect_set_empty(&_clip);
	}
}

bool TDC::GetClippingBox(RCT* pRct) const
{
	*pRct = _clip;
	return _clip.right > _clip.left;
}

class TDCMapper : public wxHashTable
{
  wxWindow* _pLastOwner;
  TDC* _pLastTDC;

public:
	TDC& GetTDC(wxWindow* owner);
	wxDC& GetDC(wxWindow* owner, bool bPaint = false) { return GetTDC(owner).GetDC(bPaint); }
	void DestroyTDC(wxWindow* owner);
  bool HasValidDC(WINDOW owner) const;

	TDCMapper() : _pLastOwner(NULL), _pLastTDC(NULL) { }
} _dc_map;

void TDCMapper::DestroyTDC(wxWindow* owner)
{
	if (owner)
	{
	  wxObject* pDC = Delete((long)owner);
	  if (pDC)
		  delete pDC;
	}
	else
	{
		BeginFind();
		for (wxNode* node = Next(); node; node = Next())
		{
  	  wxObject* pDC = node->GetData();
			delete pDC;
		}
		Clear();
	}
	_pLastOwner = NULL;
}

TDC& TDCMapper::GetTDC(wxWindow* owner)
{
	if (owner == _pLastOwner)
		return *_pLastTDC;
	
	TDC* pDC = (TDC*)Get((long)owner);
	if (pDC == NULL)
	{
		if (owner == (wxWindow*)_print_win)
			pDC = new TPrintDC(owner);
		else
		  pDC = new TDC(owner);
		Put((long)owner, pDC);
	}
	_pLastOwner = owner;
	_pLastTDC = pDC;
	return *pDC;
}

bool TDCMapper::HasValidDC(WINDOW owner) const
{
  if (owner == NULL_WIN)
		return false;

	if (owner == (WINDOW)_pLastOwner)
		return true;
	
	wxObject* pDC = Get(owner);
	return pDC != NULL;
}

///////////////////////////////////////////////////////////
// Generic window class
///////////////////////////////////////////////////////////

#define TIMER_ID 1

class TwxWindowBase : public wxWindow
{
public:
	TwxWindowBase() { }
	TwxWindowBase(wxWindow* parent, int id, const wxString& title, 
	  	          wxPoint pos, wxSize size, long style);

  DECLARE_DYNAMIC_CLASS(TwxWindowBase)
};

IMPLEMENT_DYNAMIC_CLASS(TwxWindowBase, wxWindow)

TwxWindowBase::TwxWindowBase(wxWindow* parent, int id, const wxString& title, 
													 wxPoint pos, wxSize size, long style)
: wxWindow(parent, id, pos, size, style)
{
	SetTitle(title);
}

class TwxWindow : public TwxWindowBase
{
  MENU_ITEM* m_menu;

	void DoXvtEvent(EVENT& e);

protected:
  virtual void OnChar(wxKeyEvent& e);
  virtual void OnKillFocus(wxFocusEvent& e);
  virtual void OnMenu(wxCommandEvent& event);
  virtual void OnMouseDouble(wxMouseEvent& e);
  virtual void OnMouseDown(wxMouseEvent& e);
  virtual void OnMouseMove(wxMouseEvent& e);
  virtual void OnMouseUp(wxMouseEvent& e);
  virtual void OnScroll(wxScrollEvent& e);
  virtual void OnScrollWin(wxScrollWinEvent& e);
  virtual void OnSetFocus(wxFocusEvent& e);
  virtual void OnSize(wxSizeEvent& e);
  virtual void OnTimer(wxTimerEvent& e);

public:
	virtual void OnPaint(wxPaintEvent& event);

public:
	WIN_TYPE _type;
	EVENT_HANDLER _eh;
	long _app_data;
	wxTimer* _timer;

	void SetMenuTree(const MENU_ITEM* menu);
	MENU_ITEM* GetMenuTree() const { return m_menu; }
  
	TwxWindow() : _timer(NULL), _eh(NULL) { }
  TwxWindow(wxWindow *parent, wxWindowID id, const wxString& title,
		      const wxPoint& pos = wxDefaultPosition,
          const wxSize& size = wxDefaultSize, long style = 0);
	virtual ~TwxWindow();
 
  DECLARE_DYNAMIC_CLASS(TwxWindow);
	DECLARE_EVENT_TABLE();
};

class TTaskWin : public wxFrame
{
  MENU_ITEM* m_menu;
	
	wxMenuBar* m_pOldBar;
	wxWindow* m_MenuOwner;

protected:
  virtual void OnClose(wxCloseEvent& event);
  virtual void OnMenu(wxCommandEvent& event);
  virtual void OnSize(wxSizeEvent& event);
	
public:
  virtual void OnPaint();

public:
  void SetMenuTree(const MENU_ITEM* tree);
  const MENU_ITEM* GetMenuTree() const { return m_menu; }
  void PushMenuTree(const MENU_ITEM* tree, wxWindow* owner);
	void PopMenuTree();

	TTaskWin() : wxFrame(), m_menu(NULL), m_pOldBar(NULL) { }
  TTaskWin(wxWindow *parent, wxWindowID id, const wxString& title,
           const wxPoint& pos = wxDefaultPosition, const wxSize& size = wxDefaultSize,
           long style = wxDEFAULT_FRAME_STYLE);
	~TTaskWin();

  DECLARE_DYNAMIC_CLASS(TTaskWin);
	DECLARE_EVENT_TABLE();
};

IMPLEMENT_DYNAMIC_CLASS(TwxWindow, TwxWindowBase)

BEGIN_EVENT_TABLE(TwxWindow, TwxWindowBase)
  EVT_CHAR(TwxWindow::OnChar)
	EVT_KILL_FOCUS(TwxWindow::OnKillFocus)
  EVT_LEFT_DCLICK(TwxWindow::OnMouseDouble)
  EVT_LEFT_DOWN(TwxWindow::OnMouseDown)
  EVT_LEFT_UP(TwxWindow::OnMouseUp)
  EVT_MENU_RANGE(1000, 32766, TwxWindow::OnMenu)
	EVT_MOTION(TwxWindow::OnMouseMove)
  EVT_PAINT(TwxWindow::OnPaint)
  EVT_RIGHT_DOWN(TwxWindow::OnMouseDown)
  EVT_RIGHT_UP(TwxWindow::OnMouseUp)
	EVT_SCROLL(TwxWindow::OnScroll)
	EVT_SCROLLWIN(TwxWindow::OnScrollWin)
	EVT_SET_FOCUS(TwxWindow::OnSetFocus)
	EVT_SIZE(TwxWindow::OnSize)
	EVT_TIMER(TIMER_ID, TwxWindow::OnTimer)
END_EVENT_TABLE()

void TwxWindow::DoXvtEvent(EVENT& e)
{
	if (this != NULL && _eh != NULL)
  	_eh((WINDOW)this, &e);
}

void TwxWindow::OnChar(wxKeyEvent& event)
{
  static bool bSkipNextDotKey = FALSE;

  EVENT e; memset(&e, 0, sizeof(EVENT));
	e.type = E_CHAR;
	int k = event.GetKeyCode();

	if (bSkipNextDotKey)
	{
    bSkipNextDotKey = FALSE;
		if (k == '.')
		{
		  event.Skip();
		  return;
		}
	}

	switch (k)
	{
	case WXK_ALT:
	case WXK_MENU: 
  case WXK_NUMPAD0:
  case WXK_NUMPAD1:
  case WXK_NUMPAD2:
  case WXK_NUMPAD3:
  case WXK_NUMPAD4:
  case WXK_NUMPAD5:
  case WXK_NUMPAD6:
  case WXK_NUMPAD7:
  case WXK_NUMPAD8:
  case WXK_NUMPAD9:
		event.Skip();
		return;
  case WXK_NUMPAD_DECIMAL:   // ??? Non arriva mai
	case WXK_DECIMAL:          // ??? Arriva sia '.' sia WXK_DECIMAL=340 
		k = ',';
		bSkipNextDotKey = TRUE;
		break;
	case WXK_DOWN : k = K_DOWN; break;
	case WXK_LEFT : k = K_LEFT; break;
	case WXK_NEXT : k = K_NEXT; break;
	case WXK_PRIOR: k = K_PREV; break;
	case WXK_RIGHT: k = K_RIGHT; break;
	case WXK_UP   : k = K_UP;	break;
	case WXK_TAB:
    if (event.ShiftDown())
			k = K_BTAB;
		break;
	default:
	  if (k >= WXK_F1 && k <= WXK_F24)
		  k = K_F1 + k - WXK_F1;
		break;
	}
	
	e.v.chr.shift = event.ShiftDown();
	e.v.chr.control = event.ControlDown();
	if (event.AltDown())
	{
		e.v.chr.control = TRUE;
		if (k >= 'a' && k <= 'z')
			k = toupper(k);
		else
		{
			event.Skip();
			return;
		}
	}
	e.v.chr.ch = k;
	
	DoXvtEvent(e);
}

void TwxWindow::OnKillFocus(wxFocusEvent& event)
{
  if (_TheCaret.Owner() == (WINDOW)this)
    _TheCaret.Hide();

  EVENT e; memset(&e, 0, sizeof(EVENT));
	e.type = E_FOCUS;
	e.v.active = 0;
	DoXvtEvent(e);
}

void TwxWindow::OnMenu(wxCommandEvent& event)
{
	EVENT e; memset(&e, 0, sizeof(EVENT));
	e.type = E_COMMAND;
	e.v.cmd.control = 0; e.v.cmd.shift = 0;
	e.v.cmd.tag = event.GetId();
	DoXvtEvent(e);
}

void TwxWindow::OnMouseDouble(wxMouseEvent& event)
{
  EVENT e; memset(&e, 0, sizeof(EVENT));
	e.type = E_MOUSE_DBL;
	e.v.mouse.button = 0;
	e.v.mouse.control = event.ControlDown();
	e.v.mouse.shift = event.ShiftDown();
	int x, y;	event.GetPosition(&x, &y);
	e.v.mouse.where.h = x;
	e.v.mouse.where.v = y;
	DoXvtEvent(e);
}

void TwxWindow::OnMouseDown(wxMouseEvent& event)
{
  EVENT e; memset(&e, 0, sizeof(EVENT));
	e.type = E_MOUSE_DOWN;
	e.v.mouse.button = event.RightDown() ? 1 : 0;
	e.v.mouse.control = event.ControlDown();
	e.v.mouse.shift = event.ShiftDown();

	int x, y;	event.GetPosition(&x, &y);
	e.v.mouse.where.h = x;
	e.v.mouse.where.v = y;
	DoXvtEvent(e);
}

void TwxWindow::OnMouseMove(wxMouseEvent& event)
{
  EVENT e; memset(&e, 0, sizeof(EVENT));
	e.type = E_MOUSE_MOVE;
	int x, y;	event.GetPosition(&x, &y);
	e.v.mouse.where.h = x;
	e.v.mouse.where.v = y;
	DoXvtEvent(e);
}

void TwxWindow::OnMouseUp(wxMouseEvent& event)
{
  EVENT e; memset(&e, 0, sizeof(EVENT));
	e.type = E_MOUSE_UP;
	e.v.mouse.button = event.RightUp() ? 1 : 0;
	e.v.mouse.control = event.ControlDown();
	e.v.mouse.shift = event.ShiftDown();
	int x, y;	event.GetPosition(&x, &y);
	e.v.mouse.where.h = x;
	e.v.mouse.where.v = y;
	DoXvtEvent(e);
}

void TwxWindow::OnPaint(wxPaintEvent& event)
{
  EVENT e; memset(&e, 0, sizeof(EVENT));
	e.type = E_UPDATE;

	RCT& rct = e.v.update.rct;

  wxRect rctDamaged = GetUpdateRegion().GetBox();
  rct.left = rctDamaged.x;
	rct.top = rctDamaged.y;
	rct.right = rctDamaged.GetRight()+1; 
	rct.bottom = rctDamaged.GetBottom()+1;

	TDC& tdc = _dc_map.GetTDC(this); 
	tdc.GetDC(true); // Forza la creazione di un wxPaintDC
	DoXvtEvent(e);
	tdc.KillDC();    // Distrugge il wxPaintDC
	_dc_map.DestroyTDC(NULL); // Distrugge tutti i wxClientDC residui (risolve molte "porcate" del video)
}

static SCROLL_CONTROL ConvertScrollToXVT(wxEventType et)
{
  if (et == wxEVT_SCROLL_TOP)
		return SC_THUMB; // Meglio di niente 
  if (et == wxEVT_SCROLL_BOTTOM)
		return SC_THUMB; // Meglio di niente 
  if (et == wxEVT_SCROLL_LINEUP)
		return SC_LINE_UP;
  if (et == wxEVT_SCROLL_LINEDOWN)
		return SC_LINE_DOWN;
  if (et == wxEVT_SCROLL_PAGEUP)
		return SC_PAGE_UP;
  if (et == wxEVT_SCROLL_PAGEDOWN)
		return SC_PAGE_DOWN;
  if (et == wxEVT_SCROLL_THUMBTRACK)
		return SC_THUMBTRACK;
  if (et == wxEVT_SCROLL_THUMBRELEASE)
		return SC_THUMB;
	return SC_NONE;
}

void TwxWindow::OnScroll(wxScrollEvent& event)
{
  EVENT e; memset(&e, 0, sizeof(EVENT));

  const wxScrollBar* sb = (wxScrollBar*)event.GetEventObject();
	const wxSize sz = sb->GetSize();

  e.type = E_CONTROL;
	e.v.ctl.id = event.GetId();
	e.v.ctl.ci.type = sz.x > sz.y ? WC_HSCROLL : WC_VSCROLL;
	e.v.ctl.ci.win = (WINDOW)sb;
	e.v.ctl.ci.v.scroll.pos = event.GetPosition();
  e.v.ctl.ci.v.scroll.what = ConvertScrollToXVT(event.GetEventType());
	DoXvtEvent(e);
}

void TwxWindow::OnScrollWin(wxScrollWinEvent& event)
{
  EVENT e; memset(&e, 0, sizeof(EVENT));
  e.type = event.GetOrientation() == wxHORIZONTAL ? E_HSCROLL : E_VSCROLL;
	e.v.scroll.pos = event.GetPosition();
	
	wxEventType et = event.GetEventType();
  et -= (wxEVT_SCROLLWIN_TOP - wxEVT_SCROLL_TOP);
	e.v.scroll.what = ConvertScrollToXVT(et);

	DoXvtEvent(e);
}

void TwxWindow::OnSetFocus(wxFocusEvent& event)
{
  EVENT e; memset(&e, 0, sizeof(EVENT));
	e.type = E_FOCUS;
	e.v.active = 1;
	DoXvtEvent(e);
}

void TwxWindow::OnSize(wxSizeEvent& event)
{
  EVENT e; memset(&e, 0, sizeof(EVENT));
	e.type = E_SIZE;
	e.v.size.height = event.GetSize().x;
	e.v.size.width = event.GetSize().y;
	DoXvtEvent(e);
}

void TwxWindow::OnTimer(wxTimerEvent& event)
{
  EVENT e; memset(&e, 0, sizeof(EVENT));
	e.type = E_TIMER;
	e.v.timer.id = (WINDOW)this;
	DoXvtEvent(e);
}

void TwxWindow::SetMenuTree(const MENU_ITEM* tree)
{
	XVT_ASSERT(tree != NULL);
	if (tree != NULL)
	{
		if (m_menu)
			xvt_res_free_menu_tree(m_menu);
		m_menu = xvt_menu_duplicate_tree(tree);
		((TTaskWin*)_task_win)->PushMenuTree(tree, this);
	}
}

TwxWindow::TwxWindow(wxWindow *parent, wxWindowID id, const wxString& title,
										 const wxPoint& pos, const wxSize& size, long style)
  			 : TwxWindowBase(parent, id, title, pos, size, style), 
				   _timer(NULL), m_menu(NULL), _eh(NULL)
{ }

TwxWindow::~TwxWindow()
{
  if (_timer) 
		delete _timer; 
	if (m_menu)
	{
		xvt_res_free_menu_tree(m_menu);
		((TTaskWin*)_task_win)->PopMenuTree();
	}
}

#define CAST_TWIN(win,w) XVT_ASSERT(win != NULL_WIN); TwxWindow& w = *(TwxWindow*)win; XVT_ASSERT(_task_win != &w);
#define CAST_TDC(win,dc) XVT_ASSERT(win != NULL_WIN); TDC& dc = _dc_map.GetTDC((TwxWindow*)win);
#define CAST_DC(win,dc) XVT_ASSERT(win != NULL_WIN); wxDC& dc = _dc_map.GetDC((TwxWindow*)win);

///////////////////////////////////////////////////////////
// Main application = TASK_WIN functions
///////////////////////////////////////////////////////////

IMPLEMENT_DYNAMIC_CLASS(TTaskWin, wxFrame)

BEGIN_EVENT_TABLE(TTaskWin, wxFrame)
  EVT_CLOSE(TTaskWin::OnClose)
  EVT_MENU_RANGE(1000, 32766, TTaskWin::OnMenu)
	EVT_PAINT(TTaskWin::OnPaint)
	EVT_SIZE(TTaskWin::OnSize)
END_EVENT_TABLE()

void TTaskWin::OnClose(wxCloseEvent& event)
{
	if (event.CanVeto())
	{
	  EVENT e; memset(&e, 0, sizeof(EVENT));
	  e.type = E_CLOSE;
	  int veto = _task_win_handler((WINDOW)this, &e);
		event.Veto(veto != 0);
	}
	else
		event.Skip();
}

void TTaskWin::OnMenu(wxCommandEvent& event)
{
	EVENT e; memset(&e, 0, sizeof(EVENT));
	e.type = E_COMMAND;
	e.v.cmd.control = 0; e.v.cmd.shift = 0;
	e.v.cmd.tag = event.GetId();

	if (m_MenuOwner == NULL || m_MenuOwner == this)
  	_task_win_handler((WINDOW)this, &e);
	else
		((TwxWindow*)m_MenuOwner)->_eh((WINDOW)m_MenuOwner, &e);
}

void TTaskWin::OnPaint()
{
  EVENT e; memset(&e, 0, sizeof(EVENT));
	e.type = E_UPDATE;
	RCT& rct = e.v.update.rct;

  wxRect rctDamaged = GetUpdateRegion().GetBox();
  rct.left = rctDamaged.x;
	rct.top = rctDamaged.y;
	rct.right = rctDamaged.GetRight()+1; 
	rct.bottom = rctDamaged.GetBottom()+1;

	TDC& dc = _dc_map.GetTDC(this); 
	dc.GetDC(true); // Forza la creazione di un wxPaintDC
	_task_win_handler((WINDOW)this, &e);
	dc.KillDC(); 
}

void TTaskWin::OnSize(wxSizeEvent& event)
{
  EVENT e; memset(&e, 0, sizeof(EVENT));
	e.type = E_SIZE;
	e.v.size.height = event.GetSize().x;
	e.v.size.width = event.GetSize().y;
	_task_win_handler((WINDOW)this, &e);
}

void TTaskWin::SetMenuTree(const MENU_ITEM* tree)
{
	if (m_menu)
		xvt_res_free_menu_tree(m_menu);
	m_menu = xvt_menu_duplicate_tree(tree);

	wxMenuBar* bar = GetMenuBar();
	for ( ; tree != NULL && tree->tag != 0; tree++)
	{
		wxMenu* pMenu = new wxMenu;
		for (MENU_ITEM* mi = tree->child; mi != NULL && mi->tag != 0; mi++)
		{
			wxMenuItem* item = NULL;
			if (mi->separator)
				item = new wxMenuItem(pMenu, wxID_SEPARATOR);
			else
				item = new wxMenuItem(pMenu, mi->tag, mi->text, wxEmptyString, mi->checkable);
			pMenu->DoAppend(item);
		}
		const int nLast = bar->GetMenuCount()-1;
		for (int m = 2; m < nLast; m++)
		{
			wxMenu* pMenu = bar->GetMenu(m);
			if (pMenu->FindItem(tree->child->tag))
			{
				bar->Remove(m);
				delete pMenu;
				break;
			}
		}
		bar->Insert(m, pMenu, tree->text);
	}
}

void TTaskWin::PushMenuTree(const MENU_ITEM* tree, wxWindow* owner)
{
	if(m_pOldBar != NULL)
    PopMenuTree();
  m_pOldBar = GetMenuBar();

	wxMenuBar* pBar = new wxMenuBar;
	for (; tree && tree->tag != 0; tree++)
	{
		wxMenu* pMenu = new wxMenu;
		for (MENU_ITEM* mi = tree->child; mi != NULL && mi->tag != 0; mi++)
		{
			wxMenuItem* item = NULL;
			if (mi->separator)
				item = new wxMenuItem(pMenu, wxID_SEPARATOR);
			else
				item = new wxMenuItem(pMenu, mi->tag, mi->text, wxEmptyString, mi->checkable);
			pMenu->DoAppend(item);
		}
		pBar->Append(pMenu, tree->text);
	}
	SetMenuBar(pBar);
	m_MenuOwner = owner;
}

void TTaskWin::PopMenuTree()
{
	XVT_ASSERT(m_pOldBar != NULL);
  wxMenuBar* pBar = GetMenuBar();
	SetMenuBar(m_pOldBar);
	delete pBar;
	m_pOldBar = NULL;
	m_MenuOwner = NULL;  // = this;
}

TTaskWin::TTaskWin(wxWindow *parent, wxWindowID id,
           const wxString& title, const wxPoint& pos,
           const wxSize& size, long style)
				: wxFrame(parent, id, title, pos, size, style), m_menu(NULL), m_pOldBar(NULL), m_MenuOwner(NULL)
{
	wxIcon* ico = ::GetIconResource(ICON_RSRC);
	if (ico)
		SetIcon(*ico);
}

TTaskWin::~TTaskWin()
{
	if (m_menu)
	{
		xvt_res_free_menu_tree(m_menu);
		m_menu = NULL;
	}
}

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

void xvt_app_allow_quit(void)
{ 
	wxGetApp().ExitMainLoop();  // Già lo fa la destroy
}

void xvt_app_create(int argc, char **argv, unsigned long flags, 
										EVENT_HANDLER eh, XVT_CONFIG *config)
{
	_task_win_handler = eh;
	_config_ = config;

	wxString title = config->taskwin_title;

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

	if (_startup_rect != NULL)
	{
		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
		style |= wxMAXIMIZE;

	_startup_dir = ::wxGetCwd();

  _task_win = new TTaskWin(NULL, ICON_RSRC, title, pos, size, style);

	wxMenu* Menus[3];
	wxString Title[3];
	Title[0] = "&File";
  Menus[0] = new wxMenu;
	Menus[0]->Append(M_FILE_NEW, "Scelta &Ditta...");
	Menus[0]->Append(M_FILE_REVERT, "Impostazione &Parametri...");
	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\tDel");
	Title[2] = "&Help";
  Menus[2] = new wxMenu;
  Menus[2]->Append(M_HELP_CONTENTS, "&Sommario");
  Menus[2]->Append(M_HELP_SEARCH, "&Cerca argomento");
  Menus[2]->Append(M_HELP_HELPONHELP, "&Uso della guida");
  Menus[2]->AppendSeparator();
  Menus[2]->Append(M_FILE_ABOUT+1, "&Informazioni");
	wxMenuBar* pMenubar = new wxMenuBar(3, Menus, Title);
	((wxFrame*)_task_win)->SetMenuBar(pMenubar);

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

	EVENT e; memset(&e, 0, sizeof(e));
  e.type = E_CREATE;
	long ret = _task_win_handler((WINDOW)_task_win, &e);
	if (ret != 0)
	{
	  wxApp& app = wxGetApp();
    app.MainLoop();
	}
	wxGetApp().ExitMainLoop(); // Non entrare nel main loop di xwWindows
}

void xvt_app_destroy(void)
{ 
	wxGetApp().ExitMainLoop();
} 

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& app = wxGetApp();
  while (app.Pending())
    app.Dispatch();
}

///////////////////////////////////////////////////////////
// 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();
	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();
    
		xvt_cb_alloc_data(*sizep);
    memcpy(ptrClipboardData, data.GetText(), *sizep);
		return ptrClipboardData;
	}
	sizep = 0;
	return NULL; 
}

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

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

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

///////////////////////////////////////////////////////////
// Controls functions (NOT used)
///////////////////////////////////////////////////////////

void xvt_ctl_check_radio_button(WINDOW Win, WINDOW* Wins, int NbrWindows) 
{ SORRY_BOX(); } // Ignored

WINDOW xvt_ctl_create_def(WIN_DEF *win_def_p, WINDOW parent_win, long app_data) 
{ 
	WINDOW win = NULL_WIN;
  switch (win_def_p->wtype)
	{
  case WC_HSCROLL:	/* horizontal scrollbar control */ 
  case WC_VSCROLL:	/* vertical scrollbar control */ 
		{
			const wxRect rct = NormalizeRCT(&win_def_p->rct);
			long style = win_def_p->wtype == WC_HSCROLL ? wxSB_HORIZONTAL : wxSB_VERTICAL;
		  wxScrollBar* sb = new wxScrollBar((wxWindow*)parent_win, 
				                                win_def_p->v.ctl.ctrl_id, 
			                                  rct.GetPosition(), rct.GetSize(), style);
			win = (WINDOW)sb;
		}
		break;
	default: 
		SORRY_BOX(); break;
	}
	return win;
}

void xvt_ctl_set_checked(WINDOW Win, BOOLEAN Check) 
{ SORRY_BOX(); } // Ignored

///////////////////////////////////////////////////////////
// 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
}

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

ASK_RESPONSE xvt_dm_post_ask(const char* Btn1, const char*Btn2, const char* Btn3, const char* xin_buffer) 
{ 
	SORRY_BOX();
	return RESP_DEFAULT; 
}

void xvt_dm_post_error(char *fmt) 
{ wxLogError(fmt); }

void xvt_dm_post_fatal_exit(char *fmt) 
{ wxLogFatalError(fmt); }

FL_STATUS xvt_dm_post_file_open(FILE_SPEC *fsp, const char *msg) 
{ 
	const int flags = wxOPEN | wxHIDE_READONLY | wxFILE_MUST_EXIST;
	wxString path = fsp->dir.path;
	wxString name = fsp->name;
	wxString extension = fsp->type;
  wxString selectedname = wxFileSelector(msg, path, name, extension , "*.*", flags);
  if (selectedname.IsEmpty())
  	return FL_CANCEL; 

	wxSplitPath(selectedname, &path, &name, &extension);
  strcpy(fsp->dir.path, path);
	strcpy(fsp->name, name);
	strcpy(fsp->type, extension);
  return FL_OK;
}

FL_STATUS xvt_dm_post_file_save(FILE_SPEC *fsp, const char *msg) 
{ 
	const int flags = wxSAVE | wxHIDE_READONLY;
	wxString path = fsp->dir.path;
	wxString name = fsp->name;
	wxString extension = fsp->type;
  wxString selectedname = wxFileSelector(msg, path, name, extension , "*.*", flags);
  if (selectedname.IsEmpty())
  	return FL_CANCEL; 

	wxSplitPath(selectedname, &path, &name, &extension);
  strcpy(fsp->dir.path, path);
	strcpy(fsp->name, name);
	strcpy(fsp->type, extension);
  return FL_OK;
} 

BOOLEAN xvt_dm_post_font_sel(WINDOW win, XVT_FNTID font_id, PRINT_RCD *precp, unsigned long reserved) 
{ 
	TFontId& font = *(TFontId*)font_id;
	wxFontData data; 
	data.SetInitialFont(font.Font());
	data.EnableEffects(FALSE);
  wxFontDialog dlg(_task_win, &data);
	BOOLEAN ok = dlg.ShowModal() == wxID_OK;
  if (ok)
	{
    font.Copy(dlg.GetFontData().GetChosenFont());

    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_note(char *fmt) 
{ wxLogMessage(fmt); }

char* xvt_dm_post_string_prompt(const char* message, char* response, int response_len) 
{ 
	XVT_ASSERT(message && response && response_len > 0);
	SORRY_BOX();
	*response = '\0';
	return NULL; 
}

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

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

XVT_HELP_INFO xvt_help_open_helpfile(FILE_SPEC *fs, unsigned long flags)
{
  if (!help_info.m_strFilename.IsEmpty())
		xvt_help_close_helpfile((XVT_HELP_INFO)&help_info);

	const char* ext[] = { ".zip", ".htb", ".hlp", NULL };
	for (int j = 0; j < 2; j++)
	{
		wxString base = fs->name;
		if (j == 1)
			base.Replace("campo", "prassi", true);
		for (int i = 0; ext[i]; i++)
		{
			wxString strName;
			if (i < 2)
				strName = "help/";
			strName << base;
			strName << ext[i];
			if (::wxFileExists(strName))
			{
				help_info.m_strFilename = strName;
				help_info.m_hlp = i == 2;
				if (!help_info.m_hlp)
				{
				  wxFileSystem::AddHandler(new wxZipFSHandler); 
          help_info.m_hc.AddBook(strName, true);
				}
				return (XVT_HELP_INFO)&help_info;
			} 
		}
	}
	return NULL_HELP_INFO;
}

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

	XVAGA_HELP_INFO* ahi = (XVAGA_HELP_INFO*)hi;
  if (!ahi->m_strFilename.IsEmpty())
	{
#ifdef WIN32
		if (ahi->m_hlp)
		{
		  unsigned int hwnd = (unsigned int)xvt_vobj_get_attr(TASK_WIN, ATTR_NATIVE_WINDOW);
		  OsWin32_Help(hwnd, ahi->m_strFilename, 0, NULL); // HELP_QUIT
		}
#endif
		if (!ahi->m_hlp)
      ahi->m_hc.Quit();
		ahi->m_strFilename.Empty();
	}
}

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

  if (hi == NULL_HELP_INFO)
		return bProcessed;

	XVAGA_HELP_INFO* ahi = (XVAGA_HELP_INFO*)hi;
	if (ahi->m_strFilename.IsEmpty())
		return bProcessed;

#ifdef WIN32
	if (ahi->m_hlp)
	{
		unsigned int hwnd = (unsigned int)xvt_vobj_get_attr(win, ATTR_NATIVE_WINDOW);
		switch (ev->type)
		{
		case E_COMMAND:
			bProcessed = OsWin32_Help(hwnd, ahi->m_strFilename, ev->v.cmd.tag, NULL);
			break;
		case E_HELP:
			bProcessed = OsWin32_Help(hwnd, ahi->m_strFilename, M_HELP_ONCONTEXT, (const char*)ev->v.help.tid);
			break;
    default:
			break;
		}
		return bProcessed;
	}
#endif

	switch (ev->type)
	{
	case E_COMMAND:	
		switch (ev->v.cmd.tag)
		{
		case M_HELP_CONTENTS:
      ahi->m_hc.DisplayContents();
			bProcessed = TRUE;
			break;
		case M_HELP_SEARCH:
      ahi->m_hc.DisplayIndex();
			bProcessed = TRUE;
			break;
		default:
			break;
		}
		break;
	case E_HELP:		
    ahi->m_hc.Display((const char*)ev->v.help.tid);
  	bProcessed = TRUE;
		break;
	default:
		break;
	}

	return bProcessed;
}

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

class TXVT_IMAGE
{
	wxImage m_image;
	wxBitmap m_bitmap;
	bool m_bDirty;

public:
	const wxImage& Image() const { return m_image; }
	wxImage& Image() { m_bDirty = TRUE; return m_image; }
	const wxBitmap& Bitmap();
	TXVT_IMAGE() : m_bDirty(FALSE) { }
};

const wxBitmap& TXVT_IMAGE::Bitmap()
{
	if (m_bDirty)
	{
		m_bitmap = m_image.ConvertToBitmap();
//		m_image.Destroy();  // Sarebbe bello poterlo fare
		m_bDirty = FALSE;
	}
	return m_bitmap;
}

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

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 wxROMAN; 
}

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

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

wxFont& TFontId::Font() const
{
	int nSize = PointSize();
	if (m_win == _print_win)
	{
		long ph, pw, pvr, phr;
    xvt_app_escape(XVT_ESC_GET_PRINTER_INFO, NULL, &ph, &pw, &pvr, &phr);
		nSize = pvr*nSize/120;
	}
	const int nWeight = (m_wMask & XVT_FS_BOLD) ? wxBOLD : wxNORMAL;
	wxFont* font = wxTheFontList->FindOrCreateFont(
  			nSize, Family(), Style(), nWeight, Underline(), FaceName());
  return *font;
}

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() >= 700)
    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) 
{ 
	CAST_DC(win, dc);
	CAST_COLOR(col, brush_color);
	wxBrush brush(brush_color, wxSOLID);
	dc.SetBackground(brush);
	dc.Clear();
}

void xvt_dwin_draw_arc(WINDOW Win, RCT* r, int sx, int sy, int ex, int ey) 
{ SORRY_BOX(); }

void xvt_dwin_draw_icon(WINDOW win, int x, int y, int rid) 
{ 
	wxIcon* ico = ::GetIconResource(rid);
	XVT_ASSERT(ico != NULL);
	if (ico)
	{
  	CAST_DC(win, dc);
	  dc.DrawIcon(*ico, x, y);
	}
}

void xvt_dwin_draw_image(WINDOW win, XVT_IMAGE image, RCT* dest, RCT* source) 
{ 
	XVT_ASSERT(image != NULL);

	if (image)
	{
		CAST_DC(win, dc);
		const wxRect src = NormalizeRCT(source);
		const wxRect dst = NormalizeRCT(dest);
 		const wxBitmap& bmp = ((TXVT_IMAGE*)image)->Bitmap();
		if (src.GetPosition() == wxPoint(0,0) && src.GetSize() == dst.GetSize())
		{
			dc.DrawBitmap(bmp, dst.GetPosition());
		}
		else
		{
#ifdef WIN32			
 			OsWin32_DrawBitmap(bmp.GetHBITMAP(), dc.GetHDC(), 
				                 dst.x, dst.y, dst.width, dst.height,
  											 src.x, src.y, src.width, src.height);
#else
			SORRY_BOX();
#endif
		}
	}
}

void xvt_dwin_draw_oval(WINDOW Win, RCT* r) { SORRY_BOX(); }
void xvt_dwin_draw_pie(WINDOW win, RCT *rctp, int start_x, int start_y, int stop_x, int stop_y) { SORRY_BOX(); }
void xvt_dwin_draw_polygon(WINDOW win, PNT *lpnts, int npnts) { SORRY_BOX(); }

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_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_DC(win, dc);
		wxString str(s);
		if (len >= 0)
			str.Truncate(len);

		int height, desc, lead; 	
		dc.GetTextExtent(str, NULL, &height, &desc, &lead);
		y -= height-desc; // Triste necessita'!

		dc.DrawText(str, x, y);
	}
}

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) 
{ 
	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, height;
 
	if (s && *s && len != 0)
	{
		CAST_DC(win, dc);
		wxString str = s;
		if (len >= 0) 
			str.Truncate(len);
		if (str.StartsWith("ABCDEFGH") || str.StartsWith("MMMMMMMM"))
		{
			const wxString emme('m', str.Length());
			str = emme;
		}
		dc.GetTextExtent(str, &width, &height);
	}	

	return width; 
} 

void xvt_dwin_invalidate_rect(WINDOW win, RCT* rctp) 
{ 
	CAST_WIN(win, w);
	CAST_TDC(win, dc);
	if (rctp)
	{
		const wxRect rct = NormalizeRCT(rctp);
		if (rct.x == 0 && rct.y == 0)
      rct.x; 
		w.Refresh(FALSE, &rct);
	}
	else
	{
		w.Refresh(FALSE);
	}
}

BOOLEAN xvt_dwin_is_update_needed(WINDOW win, RCT* rctp) 
{ 
	if (rctp)
	{
    CAST_WIN(win, w); 
    const wxRect rect1 = NormalizeRCT(rctp);
		const wxRect rect2 = w.GetUpdateRegion().GetBox();
    return RectIntersect(rect1, rect2);
	}
	return FALSE; 
}

void xvt_dwin_scroll_rect(WINDOW win, RCT *rctp, int dh, int dv) 
{ 
	if (dh || dv)
	{
		CAST_WIN(win, w);
		if (rctp)
		{
  		wxRect rct = NormalizeRCT(rctp);
			if (dh > 0) rct.width -= dh;
			if (dh < 0) { rct.x -= dh; rct.width += dh; }
			if (dv > 0) rct.height -= dv;
			if (dv < 0) { rct.y -= dv; rct.height += dv; }
			if (rct.width > 0 && rct.height > 0)
			  w.ScrollWindow(dh, dv, &rct);
			xvt_dwin_invalidate_rect(win, rctp);
		}
		else
			w.ScrollWindow(dh, dv);
    xvt_dwin_update(win);
	}
}

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

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

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

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

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

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

void xvt_dwin_set_font(WINDOW win, XVT_FNTID font_id) 
{ 
	XVT_ASSERT(font_id != NULL);
	CAST_TDC(win, dc);
	const TFontId& font = *(const TFontId*)font_id;
	if (dc._font != font)
	{
	  dc._font = font;
	  dc._dirty = true;
	}
}

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

void xvt_dwin_set_std_cpen(WINDOW win, long flag) 
{ 
	CAST_TDC(win, dc);
	CPEN pen; memset(&pen, 0, sizeof(CPEN));
	pen.style = P_SOLID;
	
	switch(flag)
	{
	case TL_PEN_BLACK: pen.color = COLOR_BLACK; pen.pat = PAT_SOLID; break;
	case TL_PEN_HOLLOW: pen.pat = PAT_HOLLOW; break;
	case TL_PEN_WHITE: pen.color = COLOR_WHITE; pen.pat = PAT_SOLID; 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, dc);
	const wxPoint to(pnt.h, pnt.v);
	if (dc._pnt != to)
	  dc.GetDC().DrawLine(dc._pnt, to);
  dc.GetDC().DrawPoint(to);
	dc._pnt = to;
}

void xvt_dwin_update(WINDOW win) 
{ 
	// "sembra" che non serva ad un fico secco, ma serve!
#ifdef WIN32
 	CAST_TWIN(win, w);
  OsWin32_UpdateWindow(w.GetHWND());  
#endif
}

///////////////////////////////////////////////////////////
// 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);
	TFontId* dst = (TFontId*)dest_font_id;
	TFontId* src = (TFontId*)src_font_id;
	*dst = *src;
}

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

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

	TFontId& font = *(TFontId*)font_id;
	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
	for (int 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) 
{ 
	delete (TFontId*)font_id;
}

BOOLEAN xvt_font_get_family(XVT_FNTID font_id, char* buf, long max_buf) 
{ 
  const TFontId& font = *(TFontId*)font_id;
	strncpy(buf, font.FaceName(), max_buf); 
	buf[max_buf-1] = '\0';
	return TRUE; 
}

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) 
{ 
  const TFontId& font = *(TFontId*)font_id;
	WINDOW win = font.Win();
	if (win == NULL_WIN)
		win = TASK_WIN;
	CAST_DC(win, dc);
  const wxString str = "Mq";
	int height, desc, lead;
  dc.GetTextExtent(str, NULL, &height, &desc, &lead, &font.Font());
	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) 
{ 
	*buf = '\0'; 	// Ignored
	return TRUE; 
}

long xvt_font_get_size(XVT_FNTID font_id) 
{ 
	return ((TFontId*)font_id)->PointSize();
}

XVT_FONT_STYLE_MASK xvt_font_get_style(XVT_FNTID font_id) 
{ 
	return ((TFontId*)font_id)->Mask();
}

WINDOW xvt_font_get_win(XVT_FNTID font_id) 
{ 
	return ((TFontId*)font_id)->Win();
}

BOOLEAN xvt_font_is_mapped(XVT_FNTID font_id) 
{ 
	bool yes = ((TFontId*)font_id)->Win() != NULL_WIN;
	return yes;
}

void xvt_font_map(XVT_FNTID font_id, WINDOW win) 
{ 
	TFontId* pFont = (TFontId*)font_id;
	pFont->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, char* family) 
{ 
	TFontId& font = *(TFontId*)font_id;
  font.SetFaceName(family);
}

void xvt_font_set_size(XVT_FNTID font_id, long size) 
{ 
	TFontId& font = *(TFontId*)font_id;
	font.SetPointSize(size);
}

void xvt_font_set_style(XVT_FNTID font_id, XVT_FONT_STYLE_MASK mask) 
{ 
	TFontId& font = *(TFontId*)font_id;
	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

	TFontId& font = *(TFontId*)font_id;
  const char* name = font.FaceName();
	const int size = font.PointSize();
	const int italic = (font.Mask() & XVT_FS_ITALIC) != 0;
	const int weight = 400; // Normal size

  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);

  strncpy(buf, str, max_buf);
	buf[max_buf-1] = '\0';
	return strlen(buf); 
}

void xvt_font_unmap(XVT_FNTID font_id) 
{ 
	TFontId& font = *(TFontId*)font_id;
	font.SetWin(NULL_WIN);
}

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

BOOLEAN xvt_fsys_convert_dir_to_str(DIRECTORY *dirp, char *path, int sz_path) 
{ 
	strncpy(path, dirp->path, sz_path);
	path[sz_path-1] = '\0';
	return TRUE;
}

BOOLEAN xvt_fsys_convert_str_to_dir(const char *path, DIRECTORY *dirp) 
{ 
	strcpy(dirp->path, path);
	return TRUE;
}

void xvt_fsys_get_default_dir(DIRECTORY *dirp)
{
	xvt_fsys_convert_str_to_dir(_startup_dir, dirp);
}

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

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

SLIST xvt_fsys_list_files(char *type, 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())
	{
		xvt_slist_add_at_elt(list, NULL, f, 0L);
		f = ::wxFindNextFile();
	}

	return list; 
}

static wxString _strSavedir;

void xvt_fsys_restore_dir() 
{ 
	::wxSetWorkingDirectory(_strSavedir);
}

void xvt_fsys_save_dir() 
{ 
	_strSavedir = ::wxGetCwd();
}

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

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

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 image) 
{ 
	delete (TXVT_IMAGE*)image;
}

COLOR xvt_image_get_clut(XVT_IMAGE image, short index) 
{ 
	XVT_ASSERT(image != NULL);
#if wxCHECK_VERSION(2,3,2)
	if (image)
	{
		const wxImage& bmp = ((const TXVT_IMAGE*)image)->Image();
		if (bmp.HasPalette())
		{
			const wxPalette& pal = bmp.GetPalette();
			unsigned char r, g, b;
			pal.GetRGB(index, &r, &g, &b);
			return MAKE_COLOR(r, g, b);
		}
	}
#endif
	return COLOR_BLACK; 
}

void xvt_image_get_dimensions(XVT_IMAGE image, short *width, short *height) 
{ 
	const wxImage& img = ((const TXVT_IMAGE*)image)->Image();
	if (img.Ok())
	{
	  *width = img.GetWidth();
	  *height = img.GetHeight();
	}
	else
	{
		const wxBitmap& bmp = ((TXVT_IMAGE*)image)->Bitmap();
	  *width = bmp.GetWidth();
	  *height = bmp.GetHeight();
	}
}

XVT_IMAGE_FORMAT xvt_image_get_format(XVT_IMAGE image) 
{ 
#if wxCHECK_VERSION(2,3,2)
	const wxImage& img = ((const TXVT_IMAGE*)image)->Image();
	return img.HasPalette() ? XVT_IMAGE_CL8 : XVT_IMAGE_RGB; 
#else
	return XVT_IMAGE_RGB;
#endif
}

short xvt_image_get_ncolors(XVT_IMAGE image) 
{ 
#if wxCHECK_VERSION(2,3,2)
	int n = 0;
	if (image)
	{
		const wxImage& bmp = ((const TXVT_IMAGE*)image)->Image();
		if (bmp.HasPalette())
		{
			const wxPalette& pal = bmp.GetPalette();
			unsigned char r, g, b;
			for (n = 16; n < 255; n++)
			{
				if (!pal.GetRGB(n, &r, &g, &b))
					break;
			}
		}
	}
	return n; 
#else	
	int n = 0;
	if (image)
	{
    wxImage& bmp = ((TXVT_IMAGE*)image)->Image();
	  n = bmp.CountColours(257);
	}
	return n > 256 ? 0 : n; 
#endif
}

COLOR xvt_image_get_pixel(XVT_IMAGE image, short x, short y) 
{ 
	const wxImage& bmp = ((const TXVT_IMAGE*)image)->Image();
	int r = bmp.GetRed(x, y);
	int g = bmp.GetGreen(x, y);
	int b = bmp.GetBlue(x, y);
	return MAKE_COLOR(r, g, b);
}

XVT_IMAGE xvt_image_read(const char* filenamep) 
{ 
	TXVT_IMAGE* i = NULL;
	const wxString name = filenamep;
	if (::wxFileExists(name))
	{
		i = new TXVT_IMAGE;
		i->Image().LoadFile(name);
		if (!i->Image().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) 
{ 
	wxImage& bmp = ((TXVT_IMAGE*)image)->Image();
#if wxCHECK_VERSION(2,3,2)
	if (bmp.HasPalette())
	{
		const wxPalette& pal = bmp.GetPalette();

   	CAST_COLOR (color, c);
		unsigned char ri, gi, bi;
		pal.GetRGB(index, &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++)
		{
      unsigned char r = bmp.GetRed(x, y);
			if (r != ri) continue;
      unsigned char g = bmp.GetGreen(x, y);
			if (g != gi) continue;
      unsigned char b = bmp.GetBlue(x, y);
			if (b != bi) continue;
			bmp.SetRGB(x, y, c.Red(), c.Green(), c.Blue());
		}
	}
#endif
}

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) 
{ 
	wxImage& bmp = ((TXVT_IMAGE*)image)->Image();
	CAST_COLOR (color, c);
	bmp.SetRGB(x, y, c.Red(), c.Green(), c.Blue());
}

void xvt_image_transfer(XVT_IMAGE dstimage, XVT_IMAGE srcimage, RCT *dstrctp, RCT *srcrctp) 
{
  wxImage& dst = ((TXVT_IMAGE*)dstimage)->Image();
  const wxImage& src = ((const TXVT_IMAGE*)srcimage)->Image();
	const wxRect rctDst = NormalizeRCT(dstrctp);
	const wxRect rctSrc = NormalizeRCT(srcrctp);

  wxImage sub = src.GetSubImage(NormalizeRCT(srcrctp));
	sub.Rescale(rctDst.width, rctDst.height);
	if (rctDst.x == 0 && rctDst.y == 0)
		dst = sub;
	else
		SORRY_BOX();
}

///////////////////////////////////////////////////////////
// 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
///////////////////////////////////////////////////////////

int xvt_menu_count(const MENU_ITEM* m)
{
 	for (int 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;
}

static 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)
	{
		TTaskWin& w = *(TTaskWin*)win;
		wxMenuBar* pMenuBar = w.GetMenuBar();
  	if (pMenuBar != NULL)
		{
		  for (int m = pMenuBar->GetMenuCount()-1; m >= 0; m--)
			{
        const char* 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)
{
	wxMenuBar* bar = ((TTaskWin*)_task_win)->GetMenuBar();
	wxMenuItem* item = bar ? bar->FindItem(tag) : NULL;
	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, 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 = *(TTaskWin*)win;
		w.SetMenuTree(tree);
	}
	else
	{
		CAST_TWIN(win, w);
		w.SetMenuTree(tree);
	}
}

void xvt_menu_update(WINDOW win) 
{ 
	wxMenuBar* bar = ((TTaskWin*)_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(RCT *rctp)
{
	return rctp->bottom - rctp->top;
}

int	xvt_rect_get_width(RCT *rctp)
{
	return rctp->right - rctp->left;
}

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

BOOLEAN xvt_rect_intersect(RCT *drctp, RCT *rctp1, RCT *rctp2) 
{
	const wxRect rect1 = NormalizeRCT(rctp1);
	const wxRect rect2 = NormalizeRCT(rctp2);
	BOOLEAN yes = RectIntersect(rect1, rect2);
	if (yes && drctp)
	{
		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;
	}
	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;
}

///////////////////////////////////////////////////////////
// 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_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 = 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 size_t 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) 
{ 
	wxString strName;
  strName = _startup_dir;
  strName += "/res/resource.ini";
	wxFileConfig ini("", "", strName);

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

	if (rid >= 10000 && rid < 10100)
	{
		wxSplitPath(wxGetApp().argv[0], NULL, &strName, NULL);
		strName.MakeUpper();
		strName = wxString::Format("/Menu_%s-%X", 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);
	strncpy(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;

int  xvt_sbar_get_pos(WINDOW win, SCROLL_TYPE t) 
{ 
	if (t == HSCROLL || t == VSCROLL)
	{
  	CAST_WIN(win, w);
		CAST_SCROLL_TYPE(t, dir);
		return w.GetScrollPos(dir);
	}
	CAST_SCROLL(win, sb);
	return sb.GetThumbPosition(); 
} 

int  xvt_sbar_get_proportion(WINDOW win, SCROLL_TYPE t) 
{ 
	if (t == HSCROLL || t == VSCROLL)
	{
  	CAST_WIN(win, w);
		CAST_SCROLL_TYPE(t, dir);
		return w.GetScrollThumb(dir);
	}
	CAST_SCROLL(win, sb);
	return sb.GetThumbSize(); 
} 

void xvt_sbar_get_range(WINDOW win, SCROLL_TYPE t, int *minp, int *maxp) 
{ 
	*minp = 0;
	if (t == HSCROLL || t == VSCROLL)
	{
  	CAST_WIN(win, w);
		CAST_SCROLL_TYPE(t, dir);
		*maxp = w.GetScrollRange(dir);
	}
	else
	{
	  CAST_SCROLL(win, sb);
	  *maxp = sb.GetRange();
	}
}

void xvt_sbar_set_pos(WINDOW win, SCROLL_TYPE t, int pos) 
{ 
	if (t == HSCROLL || t == VSCROLL)
	{
  	CAST_WIN(win, w);
		CAST_SCROLL_TYPE(t, dir);
		w.SetScrollPos(dir, pos);
	}
	else
	{
		CAST_SCROLL(win, sb);
		const int range = sb.GetRange();
		const int size = sb.GetThumbSize();
		sb.SetScrollbar(pos, size, range, size);
	}
}

void xvt_sbar_set_proportion(WINDOW win, SCROLL_TYPE t, int proportion) 
{ 
	if (t == HSCROLL || t == 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);
	}
	else
	{
		CAST_SCROLL(win, sb);
		const int pos = sb.GetThumbPosition();
		const int range = sb.GetRange();
		sb.SetScrollbar(pos, proportion, range, proportion);
	}
}

void xvt_sbar_set_range(WINDOW win, SCROLL_TYPE t, int min, int max) 
{ 
	XVT_ASSERT(min == 0);
	if (t == HSCROLL || t == 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);
	}
	else
	{
		CAST_SCROLL(win, sb);
		const int pos = sb.GetThumbPosition();
		const int size = sb.GetThumbSize();
		sb.SetScrollbar(pos, size, max, size);
	}
}


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

void xvt_scr_beep(void) 
{	
#ifdef WIN32
	OsWin32_Beep(0);
#else
	wxBell(); 
#endif
}

WINDOW xvt_scr_get_focus_topwin(void) 
{ 
	WINDOW win = (WINDOW)_task_win->FindFocus(); 
	return win;
}

WINDOW xvt_scr_get_focus_vobj(void) 
{ 
	return xvt_scr_get_focus_topwin();
}

static void AddWinToList(SLIST list, WINDOW win)
{
  if (win != NULL_WIN)
	{
		CAST_WIN(win, w);
    char* title = xvt_str_duplicate(w.GetTitle());
    xvt_slist_add_at_elt(list, NULL, title, win);
	}
}

SLIST xvt_scr_list_wins() 
{ 
	SLIST list = xvt_slist_create();
	AddWinToList(list, TASK_WIN);
	AddWinToList(list, xvt_scr_get_focus_topwin());
	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 = strdup(sx ? sx : "");
		item->data = data;
		item->next = NULL;

		SLIST_ELT last = NULL;
		for (SLIST_ELT i = list->head; i; i = (SLIST_ELT)i->next)
		{
			last = i;
			if (i == e) 
				break;
		}
		
		if (last == NULL)  // Empty List
			list->head = item;
		else
		{
			item->next = last->next;
			last->next = item;
		}
		list->count++;
	}
	return ok;
}

int xvt_slist_count(SLIST list) 
{ 
	XVT_ASSERT(list != NULL);
	return list ? 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) 
{ 
	XVT_ASSERT(list != NULL);
	if (list)
	{
		SLIST_ELT obj = list->head; 
		while (obj != NULL)
		{
			SLIST_ELT tokill = obj;
			if (tokill->str)
				delete tokill->str;
			obj = (SLIST_ELT)tokill->next;
			delete tokill;
		}
	  delete list;
	}
}

char* xvt_slist_get(SLIST list, SLIST_ELT e, long* datap) 
{ 
	XVT_ASSERT(list != NULL);
	if (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) 
{ 
	XVT_ASSERT(list != NULL);
	return list != NULL ? list->head : NULL; 
}

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

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

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

BOOLEAN xvt_str_match(const char *mbs, const char *pat, BOOLEAN case_sensitive)
{
 	wxString text = mbs; 
  wxString pattern = pat; 
	if (!case_sensitive)
	{
		text.MakeUpper();
		pattern.MakeUpper();
	}
	return text.Matches(pattern);
}

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

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) 
{ 
  CAST_TWIN(id, w);
	wxTimer*& t = w._timer;
	if (t != NULL)
	{
    t->Stop();
		delete t;
		t = NULL;
	}
}

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

void xvt_vobj_destroy(WINDOW win) 
{ 
	if (win != _print_win)
	{
		if (_TheCaret.Owner() == win)
      _TheCaret.Kill();

		CAST_TWIN(win, w);
		_dc_map.DestroyTDC(&w);

		w.Destroy();
	}
}

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)*6);
			xcc[0].type = XVT_COLOR_FOREGROUND;  
			xcc[0].color = MAKE_XVT_COLOR(wxSystemSettings::GetSystemColour(wxSYS_COLOUR_BTNTEXT));
			xcc[1].type = XVT_COLOR_BACKGROUND; 
			xcc[1].color = MAKE_XVT_COLOR(wxSystemSettings::GetSystemColour(wxSYS_COLOUR_BTNFACE));
			xcc[2].type = XVT_COLOR_CAPTIONLT; 
			xcc[2].color = MAKE_XVT_COLOR(wxSystemSettings::GetSystemColour(wxSYS_COLOUR_ACTIVECAPTION));
			xcc[3].type = XVT_COLOR_CAPTIONDK; 
			xcc[3].color = MAKE_XVT_COLOR(wxSystemSettings::GetSystemColour(wxSYS_COLOUR_INACTIVECAPTION));
			xcc[4].type = XVT_COLOR_CAPTIONTEXT; 
			xcc[4].color = MAKE_XVT_COLOR(wxSystemSettings::GetSystemColour(wxSYS_COLOUR_CAPTIONTEXT));
			xcc[5].type = XVT_COLOR_NULL; 
			xcc[5].color = 0;
  		ret = (long)xcc;
		}
		break;
	case ATTR_CTL_VERT_SBAR_WIDTH:
		ret = wxSystemSettings::GetSystemMetric(wxSYS_VSCROLL_X); 
		break;
	case ATTR_CTL_HORZ_SBAR_HEIGHT: 
		ret = wxSystemSettings::GetSystemMetric(wxSYS_HSCROLL_Y); 
		break;
	case ATTR_DISPLAY_TYPE:
		switch (::wxDisplayDepth())
		{
		case 1: ret = XVT_DISPLAY_MONO; break;
		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:
		{
			CAST_DC(win, dc);
			ret = dc.GetHDC();
		}
		break;
	case ATTR_NATIVE_WINDOW: 
		{ 
			CAST_WIN(win, w); 
			ret = w.GetHandle(); 
		} 
		break;
	case ATTR_SCREEN_WINDOW: 
		ret = NULL_WIN;	// Non bellissimo ma per ora...
		break;  
  case ATTR_TASK_WINDOW: 
		ret = long(_task_win); 
		break;
	case ATTR_WIN_PM_DRAWABLE_TWIN: 
		ret = TRUE; 
		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)
	{
	  CAST_WIN(win, w);
	  w.GetClientSize(&l, &h);
	}
	else
	{
		l = wxSystemSettings::GetSystemMetric(wxSYS_SCREEN_X);
		h = wxSystemSettings::GetSystemMetric(wxSYS_SCREEN_Y);
	}

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

long xvt_vobj_get_data(WINDOW win) 
{ 
	CAST_TWIN(win, w);
	return w._app_data;
}

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.x + rct.width;
  rctp->bottom = rct.y + rct.height;
	return rctp; 
}

XVT_PALETTE xvt_vobj_get_palet(WINDOW win) 
{ return NULL; }

WINDOW xvt_vobj_get_parent(WINDOW win) 
{ 
	if (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);
	strncpy(title, w.GetTitle(), sz_title);
	title[sz_title-1] = '\0';
	return title; 
}

WIN_TYPE xvt_vobj_get_type(WINDOW win) 
{ 
	CAST_TWIN(win, w); 
	return w._type; 
} 

void xvt_vobj_move(WINDOW win, RCT *rctp) 
{ 
	CAST_WIN(win, w); 
	wxRect rct = NormalizeRCT(rctp);
  w.Move(rctp->left, rctp->top);
	w.SetClientSize(rct.width, rct.height);
}

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

void xvt_vobj_set_attr(WINDOW win, long data, long value) 
{ 
	switch(data)
	{
	case ATTR_ERRMSG_HANDLER: _error_handler = (XVT_ERRMSG_HANDLER)value; break;
  case ATTR_EVENT_HOOK: 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: break; // TBI
	default: SORRY_BOX(); break;
	}
}	

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

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, char *title) 
{ 
	CAST_WIN(win, w);
	w.SetTitle(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, RCT *rct_p, char *title, int menu_rid, WINDOW parent, long win_flags, EVENT_MASK mask, EVENT_HANDLER eh, long app_data) 
{ 
	XVT_ASSERT(rct_p != NULL);
	
	const wxString caption = title;
	const	wxPoint pos(rct_p->left, rct_p->top);
	const wxSize size(rct_p->right-rct_p->left, rct_p->bottom-rct_p->top);
	long style = wxNO_3D | wxCLIP_CHILDREN | wxWANTS_CHARS /* | wxCLIP_SIBLINGS */;

	if (win_flags & WSF_VSCROLL)
		style |= wxVSCROLL;
	if (win_flags & WSF_HSCROLL)
		style |= wxHSCROLL;

	TwxWindow* w = NULL;
  switch (wtype)
	{
	case W_DOC:
		style |= wxBORDER;
		if (!caption.IsEmpty()) 
  		style |= wxCAPTION | wxSYSTEM_MENU;
		break;
	case W_PLAIN:
		// style |= wxBORDER;  // Non attivare MAI il bordo!
		break;
	default: 
		SORRY_BOX(); break;
	}
  w = new TwxWindow((wxWindow*)parent, -1, caption, pos, size, style);
	w->_type = wtype;
	w->_app_data = app_data;

  if (win_flags & WSF_INVISIBLE)
		w->Hide();
	else
		w->Show();

#ifdef WIN32
  OsWin32_SetCaptionStyle(w->GetHWND(), wtype == W_DOC);
#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();

  xvt_vobj_move((WINDOW)w, rct_p);

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

	EVENT e; memset(&e, 0, sizeof(e));
  e.type = E_CREATE;
	eh((WINDOW)w, &e);

	xvt_app_process_pending_events();

	return (WINDOW)w; 
}

long xvt_win_dispatch_event(WINDOW win, EVENT *event_p) 
{ 
	XVT_ASSERT(event_p != NULL);
	CAST_TWIN(win, w);
	return w._eh(win, event_p); 
}

void xvt_win_release_pointer(void) 
{
	if (_mouse_trapper)
	{
    _mouse_trapper->ReleaseMouse();
    _mouse_trapper = NULL;
	}
}

void xvt_win_set_caret_size(WINDOW win, int width, int height) 
{ 
	_TheCaret.SetSize(width, height);
}

void xvt_win_set_caret_pos(WINDOW win, PNT p) 
{ 
	_TheCaret.SetPos(p.h, p.v-1);
}

void xvt_win_set_caret_visible(WINDOW win, BOOLEAN on) 
{ 
	_TheCaret.Show(win, on != 0);
}

void xvt_win_set_cursor(WINDOW win, CURSOR cursor) 
{ 
	CAST_WIN(win, w);
	wxCursor* cur = wxSTANDARD_CURSOR;  // Dummy initilization
	switch (cursor)
	{
	case CURSOR_ARROW: cur = wxSTANDARD_CURSOR; break;
	case CURSOR_CROSS: 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 == 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);
	if (_mouse_trapper != NULL)
    _mouse_trapper->ReleaseMouse();
  w.CaptureMouse();
	_mouse_trapper = &w;
}

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

wxString strDefaultStatbarText;
  
const char* statbar_set_title(WINDOW win, const char* text)
{
	XVT_ASSERT(win == TASK_WIN);
  wxFrame& w = *(wxFrame*)win;

	if (text == NULL)
		text = strDefaultStatbarText;
	char* tab = strchr(text, '\t');
	if (tab)
	{
		w.SetStatusText(tab+1, 1);
		*tab = '\0';
		w.SetStatusText(text);
		*tab = '\t';
	}
	else
    w.SetStatusText(text);
  return text;
}
 
const char* statbar_set_default_title(WINDOW win, const char *text)
{
	strDefaultStatbarText = text;
	return statbar_set_title(win, strDefaultStatbarText);
}

XVT_FNTID statbar_set_fontid(WINDOW win, XVT_FNTID fontid)
{
	return fontid; // TBI???
}
  
XVT_FNTID statbar_get_fontid(WINDOW win, XVT_FNTID fontid)
{
	return fontid; // TBI???
}

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)
{
  XVT_ASSERT(parent_win == TASK_WIN);
  TTaskWin& w = *(TTaskWin*)parent_win;
	w.CreateStatusBar(2);
	w.GetStatusBar()->Show();
  wxSize sz = w.GetClientSize();
	
	int widths[2];
	widths[0] = -1;
	widths[1] = sz.x / 4;
	w.SetStatusWidths(2, widths);

	return (WINDOW)&w;
}