#include "wx/wxprec.h"


#ifdef __BORLANDC__
    #pragma hdrstop
#endif

#ifndef WX_PRECOMP
    #include "wx/wx.h"
#endif

#include "wx/colordlg.h"
#include "wx/filedlg.h"
#include "wx/splitter.h"
#include "wx/treectrl.h"
#include "wx/grid.h"
#include "wx/tokenzr.h"
#include "wx/fontdlg.h"
 
#include "api.h"

#define MAX_HEVT		500

enum { Event_Command = 1, Event_key, Tree_Activated, Event_Timer };

enum { WINDOW_TYPE='WX', TOPWIN_TYPE, SIZER_TYPE, SPLITTER_TYPE, GRID_TYPE, TREE_TYPE, NOTEBOOK_TYPE };

#pragma warning(disable : 4100)


// Set one event handle for an widget to call Z-Script to handle events

class myEvtHandler : public wxEvtHandler
{
public:
	void OnCommand(wxCommandEvent& event);

	void OnKey(wxKeyEvent& event);

	void OnMouse(wxMouseEvent& event);

	void OnTree(wxTreeEvent& event);
};


static int g_nEvt = 0;
static myEvtHandler* g_hEvt[MAX_HEVT];

// main frame

class myFrame : public wxFrame
{
public:
	myFrame() : wxFrame(NULL, wxID_ANY, "Z-Script") { timer.SetOwner(this, wxID_ANY); }

	virtual ~myFrame() { }

	void OnSize(wxSizeEvent& event);

	void OnTimer(wxTimerEvent& event);

	void OnPaint(wxPaintEvent& event);

//	void OnDropFile(wxDropFilesEvent& event);

	wxTimer timer;

private:
    DECLARE_EVENT_TABLE()
};

BEGIN_EVENT_TABLE(myFrame, wxFrame)
	EVT_SIZE(myFrame::OnSize)
	EVT_TIMER(wxID_ANY, myFrame::OnTimer)
	EVT_PAINT(myFrame::OnPaint)
//	EVT_DROP_FILES(myFrame::OnDropFile)
END_EVENT_TABLE()



// Application startup

class myApp : public wxApp
{
	void *_module;
public:
	myApp() : _module(0) { }
	~myApp() { api_delete_module(_module); }

	virtual bool OnInit()
	{
		myFrame *frame = new myFrame;
		SetTopWindow(frame);
		// call Z-Script to create widgets
		char *s = argv[0];
		int i, n = strlen(s), k1 = -1, k2 = n;
		for (i = 0; i < n; i++) {					// wxString find('.', true) does not work!
			if (s[i] == '\\') k1 = i;
			if (s[i] == '.')  k2 = i;
		}
		wxString fname(wxApp::argv[0]);
		fname = fname.SubString(k1+1, k2-1);
		char err[256];
		err[0] = 0;
		api_add_path("prog\\");
		api_add_path("cls\\");
		api_add_path("lib\\");
		_module = api_parse_file(fname.c_str(), err);
		if (!_module || !api_exec_module(_module, err)) {
			wxMessageBox(_T(err), "Z-Script", wxOK | wxICON_ERROR);
			delete frame;
			return false;
		}
		frame->Show(true);
		return true;
	}

	virtual int OnExit()
	{
		for (int i = 0; i < g_nEvt; i++) { delete g_hEvt[i]; }
		return 0;
	}
};

IMPLEMENT_APP(myApp)


class myTreeCtrl : public wxTreeCtrl
{
public:
	myTreeCtrl(wxWindow* parent) : wxTreeCtrl(parent, wxID_ANY) { }

	virtual ~myTreeCtrl() { }
	
    void OnActivated(wxTreeEvent& event);

private:
    DECLARE_EVENT_TABLE()
};

BEGIN_EVENT_TABLE(myTreeCtrl, wxTreeCtrl)
	EVT_TREE_ITEM_ACTIVATED(Tree_Activated, myTreeCtrl::OnActivated) 
END_EVENT_TABLE()


//////// Z-Script ///////////////////////////////////////////////////

class zsRegPrimitive
{
public:
	zsRegPrimitive(const char* name, int type, void* func) { api_add_primitive(name, type, func); }
};

// utility functions

void input_error(void *caller) { api_runtime_error(caller, "bad input for calling function"); }

// none-type functions

void* wx_message(void *caller, int nargs, void** args)
{
	if (nargs < 1) input_error(caller);
	wxMessageBox(_T(api_get_string(caller, args[0])), "Z-Script", wxOK);
	return 0;
}
static zsRegPrimitive wx0a("wxmsg", 0, wx_message);


void* wx_frame(void *caller, int nargs, void** args)
{
	myApp& app = wxGetApp();
	myFrame *frame = (myFrame*)app.GetTopWindow();
	if (nargs > 0) {
		if (api_is_string(args[0])) {
			void *func = api_get_func(caller, api_get_string(caller, args[0]));
			frame->SetClientData(func);
		}
		else {
			int ms = api_get_integer(caller, args[0]);
			if (ms <= 0)
				frame->timer.Stop();
			else
				frame->timer.Start(ms);
		}
	}
	return api_create_user(caller, frame, 0, 0, TOPWIN_TYPE);
}
static zsRegPrimitive wx0b("wxframe", 0, wx_frame);


void* wx_busy(void *caller, int nargs, void** args)
{
	if (nargs < 1) input_error(caller);
	if (api_get_integer(caller, args[0]) != 0) wxBeginBusyCursor();
	else                                       wxEndBusyCursor();
	return 0;
}
static zsRegPrimitive wx0c("wxbusy", 0, wx_busy);


void* wx_cast(void *caller, int nargs, void** args)
{
	if (nargs < 1) input_error(caller);
	return api_create_user(caller, api_get_ptr(caller, args[0]), 0, 0, WINDOW_TYPE);
}
static zsRegPrimitive wx0e("wxcast", 0, wx_cast);


// window function

void* win_id(void *caller, int nargs, void** args)
{
	if (nargs < 1) input_error(caller);
	wxWindow *w = (wxWindow*)api_get_user(caller, args[0], WINDOW_TYPE);
	return api_create_integer(caller, w->GetId());
}
static zsRegPrimitive wx1a("id", WINDOW_TYPE, win_id);


void* wx_close(void *caller, int nargs, void** args)
{
	if (nargs < 1) input_error(caller);
	wxWindow *w = (wxWindow*)api_get_user(caller, args[0], WINDOW_TYPE);
	w->Close(true);
	return 0;
}
static zsRegPrimitive wx1a1("close", WINDOW_TYPE, wx_close);


void* wx_hwnd(void *caller, int nargs, void** args)
{
	if (nargs < 1) input_error(caller);
	wxWindow *w = (wxWindow*)api_get_user(caller, args[0], WINDOW_TYPE);
	return api_create_user(caller, w->GetHandle(), 0, 0, 0);
}
static zsRegPrimitive wx1a2("hwnd", WINDOW_TYPE, wx_hwnd);


void* win_size(void *caller, int nargs, void** args)
{
	if (nargs < 1) input_error(caller);
	wxWindow *win = (wxWindow*)api_get_user(caller, args[0], WINDOW_TYPE);
	if (nargs == 1) {
		void *arr = api_create_array(caller, 3);
		int w, h;
		win->GetClientSize(&w, &h);
		api_set_array_object(caller, arr, "0", api_create_integer(caller, w));
		api_set_array_object(caller, arr, "1", api_create_integer(caller, h));
		return arr;
	}
	else {
		if (nargs < 3) input_error(caller);
		win->SetClientSize(api_get_integer(caller, args[1]), api_get_integer(caller, args[2]));
	}
	return 0;
}
static zsRegPrimitive wx1b("size", WINDOW_TYPE, win_size);


void* win_dialog(void *caller, int nargs, void** args)
{
	if (nargs < 1) input_error(caller);
	wxWindow *parent = (wxWindow*)api_get_user(caller, args[0], WINDOW_TYPE);
	long style = wxDEFAULT_DIALOG_STYLE;
	if (nargs > 1) {
		style = 0;
		const char *s = api_get_string(caller, args[1]);
		int k1 = 0, k2, n = strlen(s);
		char buf[64];
		for (k2 = 1; k2 <= n; k2++) {
			if (s[k2] == '|' || k2 == n) {
				strncpy(buf, s+k1, k2-k1);
				buf[k2-k1] = 0;
				if      (strcmp(buf, "caption") == 0)  style |= wxCAPTION; 
				else if (strcmp(buf, "resize") == 0)   style |= wxRESIZE_BORDER;
				else if (strcmp(buf, "close") == 0)    style |= wxCLOSE_BOX;
				else if (strcmp(buf, "minimize") == 0) style |= wxMINIMIZE_BOX;
				else if (strcmp(buf, "maximize") == 0) style |= wxMAXIMIZE_BOX;
				else if (strcmp(buf, "thick") == 0)    style |= wxTHICK_FRAME;
				else if (strcmp(buf, "top") == 0)      style |= wxSTAY_ON_TOP;
				else if (strcmp(buf, "no3d") == 0)     style |= wxNO_3D;
				k2++;
				k1 = k2;
			}
		}
	}
	wxDialog *dlg = new wxDialog(parent, wxID_ANY, "Z-Script", wxDefaultPosition, wxDefaultSize, style);
	return api_create_user(caller, dlg, 0, 0, TOPWIN_TYPE);
}
static zsRegPrimitive wx1c("dialog", WINDOW_TYPE, win_dialog);


void* win_colordialog(void *caller, int nargs, void** args)
{
	if (nargs < 1) input_error(caller);
	wxWindow *parent = (wxWindow*)api_get_user(caller, args[0], WINDOW_TYPE);
	wxColourDialog dialog(parent, NULL);
	if (dialog.ShowModal() == wxID_OK) {
		parent->Refresh();
		wxColour color = dialog.GetColourData().GetColour();
		void *arr = api_create_array(caller, 3);
		api_set_array_object(caller, arr, "0", api_create_integer(caller, color.Red()));
		api_set_array_object(caller, arr, "1", api_create_integer(caller, color.Green()));
		api_set_array_object(caller, arr, "2", api_create_integer(caller, color.Blue()));
		return arr;
	}
	return 0;
}
static zsRegPrimitive wx1c1("colordialog", WINDOW_TYPE, win_colordialog);


void* win_fontdialog(void *caller, int nargs, void** args)
{
	if (nargs < 1) input_error(caller);
	wxWindow *parent = (wxWindow*)api_get_user(caller, args[0], WINDOW_TYPE);
	wxFontDialog dialog(parent);
	if (dialog.ShowModal() == wxID_OK) {
		parent->Refresh();
		wxFont font = dialog.GetFontData().GetChosenFont(); 
		void *arr = api_create_array(caller, 7);
		api_set_array_object(caller, arr, "encoding", api_create_integer(caller, font.GetDefaultEncoding()));
		api_set_array_object(caller, arr, "family", api_create_integer(caller, font.GetFamily()));
		api_set_array_object(caller, arr, "face", api_create_string(caller, font.GetFaceName().c_str()));
		api_set_array_object(caller, arr, "size", api_create_integer(caller, font.GetPointSize()));
		api_set_array_object(caller, arr, "style", api_create_integer(caller, font.GetStyle()));
		api_set_array_object(caller, arr, "underlined", api_create_integer(caller, font.GetUnderlined()));
		api_set_array_object(caller, arr, "weight", api_create_integer(caller, font.GetWeight()));
		return arr;
	}
	return 0;
}
static zsRegPrimitive wx1c2("fontdialog", WINDOW_TYPE, win_fontdialog);


void* win_dirdialog(void *caller, int nargs, void** args)
{
	if (nargs < 1) input_error(caller);
	wxWindow *parent = (wxWindow*)api_get_user(caller, args[0], WINDOW_TYPE);
	wxDirDialog dialog(parent);
	if (dialog.ShowModal() == wxID_OK) {
		wxString s = dialog.GetPath();
		return api_create_string(caller, s.c_str());
	}
	return 0;
}
static zsRegPrimitive wx1c3("dirdialog", WINDOW_TYPE, win_dirdialog);


void* win_filedialog(void *caller, int nargs, void** args)
{
	if (nargs < 1) input_error(caller);
	wxWindow *parent = (wxWindow*)api_get_user(caller, args[0], WINDOW_TYPE);
	if (nargs > 1 && api_get_integer(caller, args[1]) != 0) {
		wxFileDialog dialog(parent, "Choose a file",  "", "", "*.*", wxSAVE | wxOVERWRITE_PROMPT);
		if (dialog.ShowModal() == wxID_OK) {
			wxString s = dialog.GetPath();
			return api_create_string(caller, s.c_str());
		}
	}
	else {
		wxFileDialog dialog(parent, "Choose a file",  "", "", "*.*", wxOPEN | wxMULTIPLE);
		if (dialog.ShowModal() == wxID_OK) {
			wxArrayString ss;
			dialog.GetPaths(ss);
			void *arr = api_create_array(caller, ss.Count());
			char key[64];
			for (unsigned i = 0; i < ss.Count(); i++) {
				sprintf(key, "%d", i);
				wxString s = ss.Item(i);
				api_set_array_object(caller, arr, key, api_create_string(caller, s.c_str()));
			}
			return arr;
		}
	}
	return 0;
}
static zsRegPrimitive wx1c4("filedialog", WINDOW_TYPE, win_filedialog);


void* win_color(void *caller, int nargs, void** args)
{
	if (nargs < 2) input_error(caller);
	wxWindow *w = (wxWindow*)api_get_user(caller, args[0], WINDOW_TYPE);
	int flag = api_get_integer(caller, args[1]);
	int r = api_get_integer(caller, args[2]);
	int g = api_get_integer(caller, args[3]);
	int b = api_get_integer(caller, args[4]);
	wxColour color(r, g, b);
	if (flag) w->SetBackgroundColour(color);
	else      w->SetForegroundColour(color);
	return 0;
}
static zsRegPrimitive wx1c5("color", WINDOW_TYPE, win_color);


void* win_font(void *caller, int nargs, void** args)
{
	if (nargs < 2) input_error(caller);
	wxWindow *w = (wxWindow*)api_get_user(caller, args[0], WINDOW_TYPE);
	wxFont font;
	void *o = api_get_array_object(caller, args[1], "encoding");
	font.SetDefaultEncoding((wxFontEncoding)api_get_integer(caller, o));
	o = api_get_array_object(caller, args[1], "family");
	font.SetFamily(api_get_integer(caller, o));
	o = api_get_array_object(caller, args[1], "face");
	font.SetFaceName(api_get_string(caller, o));
	o = api_get_array_object(caller, args[1], "size");
	font.SetPointSize(api_get_integer(caller, o));
	o = api_get_array_object(caller, args[1], "style");
	font.SetStyle(api_get_integer(caller, o));
	o = api_get_array_object(caller, args[1], "underlined");
	font.SetUnderlined(api_get_integer(caller, o) != 0);
	o = api_get_array_object(caller, args[1], "weight");
	font.SetWeight(api_get_integer(caller, o));
	w->SetFont(font);
	return 0;
}
static zsRegPrimitive wx1c6("color", WINDOW_TYPE, win_color);


void* win_panel(void *caller, int nargs, void** args)
{
	if (nargs < 1) input_error(caller);
	wxWindow *w = (wxWindow*)api_get_user(caller, args[0], WINDOW_TYPE);
	wxPanel *p = new wxPanel(w);
	return api_create_user(caller, p, 0, 0, WINDOW_TYPE);
}
static zsRegPrimitive wx1d("panel", WINDOW_TYPE, win_panel);


void* win_sizer(void *caller, int nargs, void** args)
{
	if (nargs < 2) input_error(caller);
	wxWindow *w = (wxWindow*)api_get_user(caller, args[0], WINDOW_TYPE);
	if (nargs == 2) {
		wxBoxSizer* sizer;
		const char *s = api_get_string(caller, args[1]);
		if (s[0] == 'H' || s[0] == 'h') {
			sizer = new wxBoxSizer(wxHORIZONTAL);
		}
		else {
			sizer = new wxBoxSizer(wxVERTICAL);
		}
		w->SetSizer(sizer);
		sizer->SetSizeHints(w);   
		return api_create_user(caller, sizer, 0, 0, SIZER_TYPE);
	}
	if (nargs == 3) {
		wxStaticBoxSizer* sizer;
		const char *s1 = api_get_string(caller, args[1]);
		const char *s2 = api_get_string(caller, args[2]);
		if (s1[0] == 'H' || s1[0] == 'h') {
			sizer = new wxStaticBoxSizer(wxHORIZONTAL, w, s2);
		}
		else {
			sizer = new wxStaticBoxSizer(wxVERTICAL, w, s2);
		}
		w->SetSizer(sizer);
		sizer->SetSizeHints(w);   
		return api_create_user(caller, sizer, 0, 0, SIZER_TYPE);
	}
	if (nargs == 5) {
		int rows = api_get_integer(caller, args[1]);
		int vgap = api_get_integer(caller, args[2]);
		int cols = api_get_integer(caller, args[3]);
		int hgap = api_get_integer(caller, args[4]);
		wxFlexGridSizer* sizer = new wxFlexGridSizer(rows, cols, vgap, hgap);
		w->SetSizer(sizer);
		sizer->SetSizeHints(w);   
		return api_create_user(caller, sizer, 0, 0, SIZER_TYPE);
	}
	return 0;
}
static zsRegPrimitive wx1e("sizer", WINDOW_TYPE, win_sizer);


void* win_style(void *caller, int nargs, void** args)
{
	if (nargs < 2) input_error(caller);
	wxWindow *w = (wxWindow*)api_get_user(caller, args[0], WINDOW_TYPE);
	long style = 0;
	const char *s = api_get_string(caller, args[1]);
	int k1 = 0, k2, n = strlen(s);
	char buf[64];
	for (k2 = 1; k2 <= n; k2++) {
		if (s[k2] == '|' || k2 == n) {
			strncpy(buf, s+k1, k2-k1);
			buf[k2-k1] = 0;
			if      (strcmp(buf, "simple") == 0)      style |= wxSIMPLE_BORDER;
			else if (strcmp(buf, "double") == 0)      style |= wxDOUBLE_BORDER;
			else if (strcmp(buf, "sunken") == 0)      style |= wxSUNKEN_BORDER;
			else if (strcmp(buf, "raised") == 0)      style |= wxRAISED_BORDER;
			else if (strcmp(buf, "static") == 0)      style |= wxSTATIC_BORDER;
			else if (strcmp(buf, "none") == 0)        style |= wxNO_BORDER;
			else if (strcmp(buf, "vscroll") == 0)     style |= wxVSCROLL;
			else if (strcmp(buf, "hscroll") == 0)     style |= wxHSCROLL;
			else if (strcmp(buf, "clip") == 0)        style |= wxCLIP_CHILDREN;
			else if (strcmp(buf, "transparent") == 0) style |= wxTRANSPARENT_WINDOW;
			k2++;
			k1 = k2;
		}
	}
	w->SetWindowStyle(style);
	return 0;
}
static zsRegPrimitive wx1f("style", WINDOW_TYPE, win_style);


void* win_button(void *caller, int nargs, void** args)
{
	if (nargs < 2) input_error(caller);
	wxWindow *w = (wxWindow*)api_get_user(caller, args[0], WINDOW_TYPE);
	const char *s = api_get_string(caller, args[1]);
	wxButton *p = new wxButton(w, wxID_ANY, _T(s));
	return api_create_user(caller, p, 0, 0, WINDOW_TYPE);
}
static zsRegPrimitive wx1g1("button", WINDOW_TYPE, win_button);


void* win_checkbox(void *caller, int nargs, void** args)
{
	if (nargs < 3) input_error(caller);
	wxWindow *w = (wxWindow*)api_get_user(caller, args[0], WINDOW_TYPE);
	const char *s = api_get_string(caller, args[1]);
	int flag = api_get_integer(caller, args[2]);
	wxCheckBox *p = new wxCheckBox(w, wxID_ANY, _T(s));
	if (flag != 0) p->SetValue(true);
	else           p->SetValue(false);
	return api_create_user(caller, p, 0, 0, WINDOW_TYPE);
}
static zsRegPrimitive wx1g2("checkbox", WINDOW_TYPE, win_checkbox);


void* win_combobox(void *caller, int nargs, void** args)
{
	if (nargs < 3) input_error(caller);
	wxWindow *parent = (wxWindow*)api_get_user(caller, args[0], WINDOW_TYPE);
	wxComboBox *p = new wxComboBox(parent, wxID_ANY);
	for (int i = 1; i < nargs; i++) p->Append(wxString(_T(api_get_string(caller, args[i]))));
	p->Select(0);
	return api_create_user(caller, p, 0, 0, WINDOW_TYPE);
}
static zsRegPrimitive wx1g3("combobox", WINDOW_TYPE, win_combobox);


void* win_radiobox(void *caller, int nargs, void** args)
{
	if (nargs < 5) input_error(caller);
	wxWindow *parent = (wxWindow*)api_get_user(caller, args[0], WINDOW_TYPE);
	const char *title = api_get_string(caller, args[1]);
	long style = wxRA_SPECIFY_COLS;
	const char *flag = api_get_string(caller, args[2]);
	if (flag[0] == 'r' || flag[0] == 'R') style = wxRA_SPECIFY_ROWS;
	wxArrayString choices;
	for (int i = 3; i < nargs; i++) choices.Add(_T(api_get_string(caller, args[i])));
	wxRadioBox *p = new wxRadioBox(parent, wxID_ANY, _T(title), wxDefaultPosition, wxDefaultSize, choices, 0, style);
	return api_create_user(caller, p, 0, 0, WINDOW_TYPE);
}
static zsRegPrimitive wx1g4("radiobox", WINDOW_TYPE, win_radiobox);


void* win_slider(void *caller, int nargs, void** args)
{
	if (nargs < 5) input_error(caller);
	wxWindow *parent = (wxWindow*)api_get_user(caller, args[0], WINDOW_TYPE);
	const char *s = api_get_string(caller, args[1]);
	long style = wxSL_HORIZONTAL|wxSL_LABELS|wxSL_AUTOTICKS;
	if (s[0] == 'v' || s[0] == 'V') style = wxSL_VERTICAL|wxSL_LABELS|wxSL_AUTOTICKS;
	int value = api_get_integer(caller, args[2]);
	int vmin  = api_get_integer(caller, args[3]);
	int vmax  = api_get_integer(caller, args[4]);
	wxSlider *p = new wxSlider(parent, wxID_ANY, value, vmin, vmax, wxDefaultPosition, wxDefaultSize, style);
	p->SetTickFreq((vmax-vmin) / 10, 0);
	return api_create_user(caller, p, 0, 0, WINDOW_TYPE);
}
static zsRegPrimitive wx1g5("slider", WINDOW_TYPE, win_slider);


void* win_statictext(void *caller, int nargs, void** args)
{
	if (nargs < 2) input_error(caller);
	wxWindow *parent = (wxWindow*)api_get_user(caller, args[0], WINDOW_TYPE);
	const char *s = api_get_string(caller, args[1]);
	long style = wxALIGN_LEFT;
	if (nargs > 2) {
		int flag = api_get_integer(caller, args[2]);
		if (flag > 0) style = wxALIGN_RIGHT;
		if (flag == 0) style = wxALIGN_CENTRE;
	}
	wxStaticText *p = new wxStaticText(parent, wxID_ANY, _T(s), wxDefaultPosition, wxDefaultSize, style);
	return api_create_user(caller, p, 0, 0, WINDOW_TYPE);
}
static zsRegPrimitive wx1g6("statictext", WINDOW_TYPE, win_statictext);


void* win_textbox(void *caller, int nargs, void** args)
{
	if (nargs < 2) input_error(caller);
	wxWindow *parent = (wxWindow*)api_get_user(caller, args[0], WINDOW_TYPE);
	wxString value(_T(api_get_string(caller, args[1])));
	long style = 0;
	if (nargs > 2) {
		const char *s = api_get_string(caller, args[2]);
		int k1 = 0, k2, n = strlen(s);
		char buf[64];
		for (k2 = 1; k2 <= n; k2++) {
			if (s[k2] == '|' || k2 == n) {
				strncpy(buf, s+k1, k2-k1);
				buf[k2-k1] = 0;
				if      (strcmp(buf, "multiline") == 0) style |= wxTE_MULTILINE;
				else if (strcmp(buf, "password") == 0)  style |= wxTE_PASSWORD;
				else if (strcmp(buf, "readonly") == 0)  style |= wxTE_READONLY;
				else if (strcmp(buf, "left") == 0)      style |= wxTE_LEFT;
				else if (strcmp(buf, "center") == 0)    style |= wxTE_CENTRE;
				else if (strcmp(buf, "right") == 0)     style |= wxTE_RIGHT;
				k2++;
				k1 = k2;
			}
		}
	}
	wxTextCtrl *p = new wxTextCtrl(parent, wxID_ANY, value, wxDefaultPosition, wxDefaultSize, style);
	return api_create_user(caller, p, 0, 0, WINDOW_TYPE);
}
static zsRegPrimitive wx1g7("textbox", WINDOW_TYPE, win_textbox);


void* win_splitter(void *caller, int nargs, void** args)
{
	if (nargs < 1) input_error(caller);
	wxWindow *parent = (wxWindow*)api_get_user(caller, args[0], WINDOW_TYPE);
	wxSplitterWindow *p = new wxSplitterWindow(parent, wxID_ANY);
	wxPanel *panel = new wxPanel(p, wxID_ANY);
	panel = new wxPanel(p, wxID_ANY);
	return api_create_user(caller, p, 0, 0, SPLITTER_TYPE);
}
static zsRegPrimitive wx1g8("splitter", WINDOW_TYPE, win_splitter);


void* win_grid(void *caller, int nargs, void** args)
{
	if (nargs < 3) input_error(caller);
	wxWindow *parent = (wxWindow*)api_get_user(caller, args[0], WINDOW_TYPE);
	wxGrid *p = new wxGrid(parent, wxID_ANY);
	p->CreateGrid(api_get_integer(caller, args[1]), api_get_integer(caller, args[2]));
	return api_create_user(caller, p, 0, 0, GRID_TYPE);
}
static zsRegPrimitive wx1g9("grid", WINDOW_TYPE, win_grid);


void* win_tree(void *caller, int nargs, void** args)
{
	if (nargs < 1) input_error(caller);
	wxWindow *parent = (wxWindow*)api_get_user(caller, args[0], WINDOW_TYPE);
	myTreeCtrl *p = new myTreeCtrl(parent);
	if (nargs > 1) {
		void *func = api_get_func(caller, api_get_string(caller, args[1]));
		p->SetClientData(func);
	}
	return api_create_user(caller, p, 0, 0, TREE_TYPE);
}
static zsRegPrimitive wx1g10("tree", WINDOW_TYPE, win_tree);


void* win_notebook(void *caller, int nargs, void** args)
{
	if (nargs < 2) input_error(caller);
	wxWindow *parent = (wxWindow*)api_get_user(caller, args[0], WINDOW_TYPE);
	long style = 0;
	const char *s = api_get_string(caller, args[1]);
	if      (strcmp(s, "top") == 0)    style = wxNB_TOP;
	else if (strcmp(s, "left") == 0)   style = wxNB_LEFT;
	else if (strcmp(s, "rigth") == 0)  style = wxNB_RIGHT;
	else if (strcmp(s, "bottom") == 0) style = wxNB_BOTTOM;
	wxNotebook *p = new wxNotebook(parent, wxID_ANY, wxDefaultPosition, wxDefaultSize, style);
	return api_create_user(caller, p, 0, 0, NOTEBOOK_TYPE);
}
static zsRegPrimitive wx1g11("notebook", WINDOW_TYPE, win_notebook);


// frame/dialog functions

void* topwin_title(void *caller, int nargs, void** args)
{
	if (nargs < 2) input_error(caller);
	wxTopLevelWindow *frame = (wxTopLevelWindow*)api_get_user(caller, args[0], TOPWIN_TYPE);
	frame->SetTitle(_T(api_get_string(caller, args[1])));
	return 0;
}
static zsRegPrimitive wx2a("title", TOPWIN_TYPE, topwin_title);


void* topwin_show(void *caller, int nargs, void** args)
{
	if (nargs < 2) input_error(caller);
	wxTopLevelWindow *top = (wxDialog*)api_get_user(caller, args[0], TOPWIN_TYPE);
	wxDialog dialog;
	if (!top->IsKindOf(dialog.GetClassInfo())) api_runtime_error(caller, "not a diaolog window object");
	wxDialog *w = (wxDialog*)top;
	if (api_get_integer(caller, args[1]) != 0) w->ShowModal();
	else                                       w->Show();
	return 0;
}
static zsRegPrimitive wx2a1("show", TOPWIN_TYPE, topwin_show);


void* topwin_icon(void *caller, int nargs, void** args)
{
	if (nargs < 2) input_error(caller);
	wxTopLevelWindow *frame = (wxTopLevelWindow*)api_get_user(caller, args[0], TOPWIN_TYPE);
	wxString fname(_T(api_get_string(caller, args[1])));
	wxString ext = fname.Right(4);
	ext = ext.Upper();
	wxIcon ico;
	bool ok = false;
	if (ext.Cmp(".ICO") == 0) {
		ok = ico.LoadFile(fname, wxBITMAP_TYPE_ICO);
	}
	else if (ext.Cmp(".GIF") == 0) {
		ok = ico.LoadFile(fname, wxBITMAP_TYPE_GIF);
	}
	else if (ext.Cmp(".XPM") == 0) {
		ok = ico.LoadFile(fname, wxBITMAP_TYPE_XPM);
	}
	else if (ext.Cmp(".XBM") == 0) {
		ok = ico.LoadFile(fname, wxBITMAP_TYPE_XBM);
	}
	if (ok) frame->SetIcon(ico);
	return 0;
}
static zsRegPrimitive wx2b("icon", TOPWIN_TYPE, topwin_icon);


void* topwin_fullscreen(void *caller, int nargs, void** args)
{
	if (nargs < 2) input_error(caller);
	wxTopLevelWindow *w = (wxTopLevelWindow*)api_get_user(caller, args[0], TOPWIN_TYPE);
	if (api_get_integer(caller, args[1]) != 0)
		w->ShowFullScreen(true);
	else
		w->ShowFullScreen(false);
	return 0;
}
static zsRegPrimitive wx2c("fullscreen", TOPWIN_TYPE, topwin_fullscreen);


void* topwin_menubar(void *caller, int nargs, void** args)
{
	if (nargs < 1) input_error(caller);
	wxFrame *frame = (wxFrame*)api_get_user(caller, args[0], TOPWIN_TYPE);
	if (nargs == 1) {
		wxMenuBar *menuBar = new wxMenuBar();
		frame->SetMenuBar(menuBar);
		return 0;
	}
	wxMenuBar *menuBar = frame->GetMenuBar();
	if (!menuBar) {
		menuBar = new wxMenuBar();
		frame->SetMenuBar(menuBar);
	}
	wxMenu *menu = new wxMenu;
	menuBar->Append(menu, _T(api_get_string(caller, args[1])));
	void *ret = api_create_array(caller, nargs-2);
	wxMenu *subm = 0;
	for (int i = 2, j = 0; i < nargs; i++) {
		const char* s = api_get_string(caller, args[i]);
		if (s[0] == '>') {
			if (i == nargs-1 || subm) input_error(caller);
			subm = new wxMenu;
			menu->Append(wxID_ANY, _T(api_get_string(caller, args[i+1])), subm);
			i++;
			continue;
		}
		if (s[0] == '<') {
			if (!subm) input_error(caller);
			subm = 0;
			continue;
		}
		if (s[0] == '_') {
			if (subm)
				subm->AppendSeparator();
			else
				menu->AppendSeparator();
			continue;
		}
		long id = wxNewId();
		api_set_array_object2(caller, ret, j, api_create_integer(caller, id));
		j++;
		wxRegisterId(id);
		if (subm)
			subm->Append(id, _T(s));
		else
			menu->Append(id, _T(s));
	}
	return ret;
}
static zsRegPrimitive wx2d("menubar", TOPWIN_TYPE, topwin_menubar);


void* topwin_toolbar(void *caller, int nargs, void** args)
{
	if (nargs < 3) input_error(caller);
	wxFrame *frame = (wxFrame*)api_get_user(caller, args[0], TOPWIN_TYPE);
    frame->SetToolBar(NULL);
	wxToolBarBase *toolBar = frame->CreateToolBar();
	void *arr = api_create_array(caller, nargs/2);
	for (int i = 2, j = 0; i < nargs; i += 2) {
		wxString fname   (_T(api_get_string(caller, args[i-1])));
		const char* tip = api_get_string(caller, args[i  ]);
		if (fname.Cmp("|") == 0) {
			toolBar->AddSeparator();
			continue;
		}
		wxString ext = fname.Right(4);
		ext = ext.Upper();
		wxBitmap bmp;
		bool ok = false;
		if (ext.Cmp(".BMP") == 0) {
			ok = bmp.LoadFile(fname, wxBITMAP_TYPE_BMP);
		}
		else if (ext.Cmp(".GIF") == 0) {
			ok = bmp.LoadFile(fname, wxBITMAP_TYPE_GIF);
		}
		else if (ext.Cmp(".XPM") == 0) {
			ok = bmp.LoadFile(fname, wxBITMAP_TYPE_XPM);
		}
		else if (ext.Cmp(".XBM") == 0) {
			ok = bmp.LoadFile(fname, wxBITMAP_TYPE_XBM);
		}
		else {
			api_runtime_error(caller, "unsupported image type for toolbar");
			return 0;
		}
		if (!ok) {
			api_runtime_error(caller, "failed to load image");
			return 0;
		}
		long id = wxNewId();
		api_set_array_object2(caller, arr, j, api_create_integer(caller, id));
		j++;
		wxRegisterId(id);
		toolBar->AddTool(id, "",  bmp, tip);
	}
    toolBar->Realize();
	return arr;
}
static zsRegPrimitive wx2e("toolbar", TOPWIN_TYPE, topwin_toolbar);


void* topwin_statusbar(void *caller, int nargs, void** args)
{
	if (nargs < 2) input_error(caller);
	wxFrame *frame = (wxFrame*)api_get_user(caller, args[0], TOPWIN_TYPE);
	int n = api_get_integer(caller, args[1]);
	if (nargs == 2) {
		frame->SetStatusBar(NULL);
		frame->CreateStatusBar(n);
	}
	else {
		frame->SetStatusText(_T(api_get_string(caller, args[2])), n);
	}
	return 0;
}
static zsRegPrimitive wx2f("statusbar", TOPWIN_TYPE, topwin_statusbar);


// splitter

void* splitter_split(void *caller, int nargs, void** args)
{
	if (nargs < 1) input_error(caller);
	wxSplitterWindow *s = (wxSplitterWindow*)api_get_user(caller, args[0], SPLITTER_TYPE);
	int pos = 0;
	if (nargs > 1) pos = api_get_integer(caller, args[1]);
	const char* flag = "v";
	if (nargs > 2) flag = api_get_string(caller, args[2]);
	if (flag[0] == 'h' || flag[0] == 'H') s->SplitHorizontally(s->GetWindow1(), s->GetWindow2(), pos);
	else                                  s->SplitVertically  (s->GetWindow1(), s->GetWindow2(), pos);
	return 0;
}
static zsRegPrimitive wx3a("split", SPLITTER_TYPE, splitter_split);


void* splitter_replace(void *caller, int nargs, void** args)
{
	if (nargs < 3) input_error(caller);
	wxSplitterWindow *s = (wxSplitterWindow*)api_get_user(caller, args[0], SPLITTER_TYPE);
	int k = api_get_integer(caller, args[1]);
	wxWindow *w = (wxWindow*)api_get_user(caller, args[2], WINDOW_TYPE);
	if (k == 1) s->ReplaceWindow(s->GetWindow1(), w);
	else        s->ReplaceWindow(s->GetWindow2(), w);
	return 0;
}
static zsRegPrimitive wx3b("replace", SPLITTER_TYPE, splitter_replace);


void* splitter_min(void *caller, int nargs, void** args)
{
	if (nargs < 2) input_error(caller);
	wxSplitterWindow *s = (wxSplitterWindow*)api_get_user(caller, args[0], SPLITTER_TYPE);
	int size = api_get_integer(caller, args[1]);
	s->SetMinimumPaneSize(size);
	return 0;
}
static zsRegPrimitive wx3c("min", SPLITTER_TYPE, splitter_min);

// grid control

void* grid_get(void *caller, int nargs, void** args)
{
	if (nargs < 3) input_error(caller);
	wxGrid *w = (wxGrid*)api_get_user(caller, args[0], GRID_TYPE);
	wxString s = w->GetCellValue(api_get_integer(caller, args[1]), api_get_integer(caller, args[2]));
	return api_create_string(caller, s.c_str());
}
static zsRegPrimitive wx4a("get", GRID_TYPE, grid_get);


void* grid_set(void *caller, int nargs, void** args)
{
	if (nargs < 4) input_error(caller);
	wxGrid *w = (wxGrid*)api_get_user(caller, args[0], GRID_TYPE);
	w->SetCellValue(api_get_integer(caller, args[1]), api_get_integer(caller, args[2]), api_get_string(caller, args[3]));
	return 0;
}
static zsRegPrimitive wx4b("set", GRID_TYPE, grid_set);


// tree control

void* tree_root(void *caller, int nargs, void** args)
{
	if (nargs < 2) input_error(caller);
	myTreeCtrl *w = (myTreeCtrl*)api_get_user(caller, args[0], TREE_TYPE);
	w->AddRoot(api_get_string(caller, args[1]));
	return 0;
}
static zsRegPrimitive wx5a("root", TREE_TYPE, tree_root);


void* tree_append(void *caller, int nargs, void** args)
{
	if (nargs < 3) input_error(caller);
	myTreeCtrl *w = (myTreeCtrl*)api_get_user(caller, args[0], TREE_TYPE);
	wxStringTokenizer tkz(_T(api_get_string(caller, args[1])), _T("/"));
	wxTreeItemId id = w->GetRootItem();
	while ( tkz.HasMoreTokens()) {
		wxString token = tkz.GetNextToken();
		if (token.IsEmpty()) {
			id = w->GetRootItem();
		}
		else {
			bool flag = false;
			wxTreeItemIdValue cookie;
			wxTreeItemId id2 = w->GetFirstChild(id, cookie);
			while (id2.IsOk()) {
				wxString s = w->GetItemText(id2);
				if (s.Cmp(token) == 0) { flag = true; break; }
				id2 = w->GetNextChild(id, cookie);
			}
			if (!flag) {
				wxMessageBox(_T("failed to find tree item"), "Z-Script", wxOK | wxICON_ERROR);
				return 0;
			}
			id = id2;
		}
	}
	w->AppendItem(id, _T(api_get_string(caller, args[2])));
	return 0;
}
static zsRegPrimitive wx5b("append", TREE_TYPE, tree_append);


void* tree_get(void *caller, int nargs, void** args)
{
	if (nargs < 1) input_error(caller);
	myTreeCtrl *w = (myTreeCtrl*)api_get_user(caller, args[0], TREE_TYPE);
	wxTreeItemId id = w->GetSelection();
	if (id.IsOk()) api_create_string(caller, w->GetItemText(id).c_str());
	return 0;
}
static zsRegPrimitive wx5c("get", TREE_TYPE, tree_get);

// notebook control

void* notebook_add(void *caller, int nargs, void** args)
{
	if (nargs < 3) input_error(caller);
	wxNotebook *book = (wxNotebook*)api_get_user(caller, args[0], NOTEBOOK_TYPE);
	book->InsertPage(0, (wxWindow*)api_get_ptr(caller, args[1]), _T(api_get_string(caller, args[2])), true);
	return 0;
}
static zsRegPrimitive wx6a("root", NOTEBOOK_TYPE, notebook_add);


// sizer

void* sizer_add(void *caller, int nargs, void** args)
{
	if (nargs < 2) input_error(caller);
	wxSizer* sizer = (wxSizer*)api_get_user(caller, args[0], SIZER_TYPE);
	int flag = 0;
	int prop = 0;
	if (nargs > 2) {
		const char *s = api_get_string(caller, args[2]);
		int k1 = 0, k2, n = strlen(s);
		char buf[64];
		for (k2 = 1; k2 <= n; k2++) {
			if (s[k2] == '|' || k2 == n) {
				strncpy(buf, s+k1, k2-k1);
				buf[k2-k1] = 0;
				if      (strcmp(buf, "top") == 0)             flag |= wxTOP;
				else if (strcmp(buf, "bottom") == 0)          flag |= wxBOTTOM;
				else if (strcmp(buf, "left") == 0)            flag |= wxLEFT;
				else if (strcmp(buf, "right") == 0)           flag |= wxRIGHT;
				else if (strcmp(buf, "all") == 0)             flag |= wxALL;
				else if (strcmp(buf, "expand") == 0)          flag |= wxEXPAND;
				else if (strcmp(buf, "shaped") == 0)          flag |= wxSHAPED;
				else if (strcmp(buf, "minsize") == 0)         flag |= wxFIXED_MINSIZE;
				else if (strcmp(buf, "aligncenter") == 0)     flag |= wxALIGN_CENTER;
				else if (strcmp(buf, "alignvertical") == 0)   flag |= wxALIGN_CENTER_VERTICAL;
				else if (strcmp(buf, "alignhorizontal") == 0) flag |= wxALIGN_CENTER_HORIZONTAL;
				else if (strcmp(buf, "alignleft") == 0)       flag |= wxALIGN_LEFT;
				else if (strcmp(buf, "alignright") == 0)      flag |= wxALIGN_RIGHT;
				else if (strcmp(buf, "aligntop") == 0)        flag |= wxALIGN_TOP;
				else if (strcmp(buf, "alignbottom") == 0)     flag |= wxALIGN_BOTTOM;
				k2++;
				k1 = k2;
			}
		}
		if (nargs > 3) prop = api_get_integer(caller, args[3]);
	}
	if (api_get_type(args[1]) == SIZER_TYPE) {
		wxSizer *w = (wxSizer*)api_get_ptr(caller, args[1]);
		sizer->Add(w, prop, flag);
		sizer->Layout();
	}
	else if (api_get_type(args[1]) == WINDOW_TYPE) {
		wxWindow *w = (wxWindow*)api_get_ptr(caller, args[1]);
		sizer->Add(w, prop, flag);
		sizer->Layout();
	}
	else {
		input_error(caller);
	}
	return 0;
}
static zsRegPrimitive wx7a("add", SIZER_TYPE, sizer_add);


void* sizer_rowsize(void *caller, int nargs, void** args)
{
	if (nargs < 3) input_error(caller);
	wxSizer* sizer = (wxSizer*)api_get_user(caller, args[0], SIZER_TYPE);
	wxFlexGridSizer tmp(0);
	if (!sizer->IsKindOf(tmp.GetClassInfo())) input_error(caller);
	wxFlexGridSizer *grid = (wxFlexGridSizer*)sizer;
	grid->AddGrowableRow(api_get_integer(caller, args[1]), api_get_integer(caller, args[2]));
	return 0;
}
static zsRegPrimitive wx7b("rowpsize", SIZER_TYPE, sizer_rowsize);


void* sizer_colsize(void *caller, int nargs, void** args)
{
	if (nargs < 3) input_error(caller);
	wxSizer* sizer = (wxSizer*)api_get_user(caller, args[0], SIZER_TYPE);
	wxFlexGridSizer tmp(0);
	if (!sizer->IsKindOf(tmp.GetClassInfo())) input_error(caller);
	wxFlexGridSizer *grid = (wxFlexGridSizer*)sizer;
	grid->AddGrowableCol(api_get_integer(caller, args[1]), api_get_integer(caller, args[2]));
	return 0;
}
static zsRegPrimitive wx7c("colsize", SIZER_TYPE, sizer_colsize);


// the master event handler

void* wx_push(void *caller, int nargs, void** args)
{
	if (nargs < 4) input_error(caller);
	wxWindow *w = (wxWindow*)api_get_user(caller, args[0], WINDOW_TYPE);
	void *func = api_get_func(caller, api_get_string(caller, args[1]));
	myEvtHandler* h = new myEvtHandler;
	g_hEvt[g_nEvt++] = h;
	h->SetClientData(func);
	w->PushEventHandler(h);
	const char* ev = api_get_string(caller, args[2]);
	int i, id[200], count=0;
	if (api_is_integer(args[3])) {
		id[count++] = api_get_integer(caller, args[3]);
	}
	else {
		int size = api_get_array_size(caller, args[3]);
		if (size > 200) size = 200;
		for (i = 0; i < size; i++) {
			void *value = api_get_array_object2(caller, args[3], i);
			id[count++] = api_get_integer(caller, value);
		}
	}
	if (strcmp(ev, "key") == 0) {
		for (i = 0; i < count; i++) {
			w->Connect(id[i], wxEVT_KEY_UP,   (wxObjectEventFunction)(&myEvtHandler::OnKey), NULL, h);
			w->Connect(id[i], wxEVT_KEY_DOWN, (wxObjectEventFunction)(&myEvtHandler::OnKey), NULL, h);
			w->Connect(id[i], wxEVT_CHAR,     (wxObjectEventFunction)(&myEvtHandler::OnKey), NULL, h);
		}
		return 0;
	}
	if (strcmp(ev, "mouse") == 0) {
		for (i = 0; i < count; i++) {
			w->Connect(id[i], wxEVT_LEFT_UP,       (wxObjectEventFunction)(&myEvtHandler::OnMouse), NULL, h);
			w->Connect(id[i], wxEVT_LEFT_DOWN,     (wxObjectEventFunction)(&myEvtHandler::OnMouse), NULL, h);
			w->Connect(id[i], wxEVT_LEFT_DCLICK,   (wxObjectEventFunction)(&myEvtHandler::OnMouse), NULL, h);
			w->Connect(id[i], wxEVT_RIGHT_UP,      (wxObjectEventFunction)(&myEvtHandler::OnMouse), NULL, h);
			w->Connect(id[i], wxEVT_RIGHT_DOWN,    (wxObjectEventFunction)(&myEvtHandler::OnMouse), NULL, h);
			w->Connect(id[i], wxEVT_RIGHT_DCLICK,  (wxObjectEventFunction)(&myEvtHandler::OnMouse), NULL, h);
			w->Connect(id[i], wxEVT_MIDDLE_UP,     (wxObjectEventFunction)(&myEvtHandler::OnMouse), NULL, h);
			w->Connect(id[i], wxEVT_MIDDLE_DOWN,   (wxObjectEventFunction)(&myEvtHandler::OnMouse), NULL, h);
			w->Connect(id[i], wxEVT_MIDDLE_DCLICK, (wxObjectEventFunction)(&myEvtHandler::OnMouse), NULL, h);
			w->Connect(id[i], wxEVT_MOTION,        (wxObjectEventFunction)(&myEvtHandler::OnMouse), NULL, h);
			w->Connect(id[i], wxEVT_ENTER_WINDOW,  (wxObjectEventFunction)(&myEvtHandler::OnMouse), NULL, h);
			w->Connect(id[i], wxEVT_LEAVE_WINDOW,  (wxObjectEventFunction)(&myEvtHandler::OnMouse), NULL, h);
			w->Connect(id[i], wxEVT_MOUSEWHEEL,    (wxObjectEventFunction)(&myEvtHandler::OnMouse), NULL, h);
		}
		return 0;
	}
	if (strcmp(ev, "menu") == 0) {
		for (i = 0; i < count; i++) {
			w->Connect(id[i], wxEVT_COMMAND_MENU_SELECTED, (wxObjectEventFunction)(&myEvtHandler::OnCommand), NULL, h);
		}
		return 0;
	}
	if (strcmp(ev, "tool") == 0) {
		for (i = 0; i < count; i++) {
			w->Connect(id[i], wxEVT_COMMAND_TOOL_CLICKED, (wxObjectEventFunction)(&myEvtHandler::OnCommand), NULL, h);
		}
		return 0;
	}
	if (strcmp(ev, "control") == 0) {
		for (i = 0; i < count; i++) {
			w->Connect(id[i], wxEVT_COMMAND_BUTTON_CLICKED,        (wxObjectEventFunction)(&myEvtHandler::OnCommand), NULL, h);
			w->Connect(id[i], wxEVT_COMMAND_CHECKBOX_CLICKED,      (wxObjectEventFunction)(&myEvtHandler::OnCommand), NULL, h);
			w->Connect(id[i], wxEVT_COMMAND_CHOICE_SELECTED,       (wxObjectEventFunction)(&myEvtHandler::OnCommand), NULL, h);
			w->Connect(id[i], wxEVT_COMMAND_COMBOBOX_SELECTED,     (wxObjectEventFunction)(&myEvtHandler::OnCommand), NULL, h);
			w->Connect(id[i], wxEVT_COMMAND_LISTBOX_SELECTED,      (wxObjectEventFunction)(&myEvtHandler::OnCommand), NULL, h);
			w->Connect(id[i], wxEVT_COMMAND_LISTBOX_DOUBLECLICKED, (wxObjectEventFunction)(&myEvtHandler::OnCommand), NULL, h);
			w->Connect(id[i], wxEVT_COMMAND_RADIOBUTTON_SELECTED,  (wxObjectEventFunction)(&myEvtHandler::OnCommand), NULL, h);
			w->Connect(id[i], wxEVT_COMMAND_SCROLLBAR_UPDATED,     (wxObjectEventFunction)(&myEvtHandler::OnCommand), NULL, h);
			w->Connect(id[i], wxEVT_COMMAND_SLIDER_UPDATED,        (wxObjectEventFunction)(&myEvtHandler::OnCommand), NULL, h);
		}
		return 0;
	}
/*
	if (strcmp(ev, "grid") == 0) {
		for (i = 0; i < count; i++) {
			w->Connect(id[i], wxEVT_GRID_CELL_CHANGE,  (wxObjectEventFunction)(myEvtHandler::OnCommand), NULL, h);
			w->Connect(id[i], wxEVT_GRID_RANGE_SELECT, (wxObjectEventFunction)(myEvtHandler::OnCommand), NULL, h);
		}
		return 0;
	}
	if (strcmp(ev, "joystick") == 0) {
		for (i = 0; i < count; i++) {
			w->Connect(id[i], wxEVT_JOY_BUTTON_DOWN, (wxObjectEventFunction)(myEvtHandler::OnCommand), NULL, h);
			w->Connect(id[i], wxEVT_JOY_BUTTON_UP,   (wxObjectEventFunction)(myEvtHandler::OnCommand), NULL, h);
			w->Connect(id[i], wxEVT_JOY_MOVE,        (wxObjectEventFunction)(myEvtHandler::OnCommand), NULL, h);
			w->Connect(id[i], wxEVT_JOY_ZMOVE,       (wxObjectEventFunction)(myEvtHandler::OnCommand), NULL, h);
		}
		return 0;
	}
*/
	return 0;
}
static zsRegPrimitive wx1z("push", WINDOW_TYPE, wx_push);

// event functions

void myEvtHandler::OnCommand(wxCommandEvent& event)
{
	void *func = GetClientData();
	if (func) {
		void *p[1];
		p[0] = api_create_integer(func, event.GetId());
		api_call_func(func, 1, p);
	}
	event.Skip();
}

void myEvtHandler::OnKey(wxKeyEvent& event)
{
	void *func = GetClientData();
	if (func) {
		void *p[5];
		WXTYPE type = event.GetEventType();
		if      (type == wxEVT_KEY_DOWN) p[0] = api_create_integer(func, 1);
		else if (type == wxEVT_KEY_UP)   p[0] = api_create_integer(func, 2);
		else                             p[0] = api_create_integer(func, 0);
		p[1] = api_create_integer(func, event.GetKeyCode());
		p[2] = api_create_integer(func, event.ControlDown());
		p[3] = api_create_integer(func, event.AltDown());
		p[4] = api_create_integer(func, event.ShiftDown());
		api_call_func(func, 5, p);
	}
	event.Skip();
}

void myEvtHandler::OnMouse(wxMouseEvent& event)
{
	void *func = GetClientData();
	if (func) {
		void *p[6];
		WXTYPE type = event.GetEventType();
		if      (type == wxEVT_LEFT_DOWN)     p[0] = api_create_integer(func, 1);
		else if (type == wxEVT_LEFT_UP)       p[0] = api_create_integer(func, 2);
		else if (type == wxEVT_LEFT_DCLICK)   p[0] = api_create_integer(func, 3);
		else if (type == wxEVT_MIDDLE_DOWN)   p[0] = api_create_integer(func, 4);
		else if (type == wxEVT_MIDDLE_UP)     p[0] = api_create_integer(func, 5);
		else if (type == wxEVT_MIDDLE_DCLICK) p[0] = api_create_integer(func, 6);
		else if (type == wxEVT_RIGHT_DOWN)    p[0] = api_create_integer(func, 7);
		else if (type == wxEVT_RIGHT_UP)      p[0] = api_create_integer(func, 8);
		else if (type == wxEVT_RIGHT_DCLICK)  p[0] = api_create_integer(func, 9);
		else if (type == wxEVT_MOTION)        p[0] = api_create_integer(func, 10);
		else                                  p[0] = api_create_integer(func, 0);
		p[1] = api_create_integer(func, event.GetX());
		p[2] = api_create_integer(func, event.GetY());
		p[3] = api_create_integer(func, event.ControlDown());
		p[4] = api_create_integer(func, event.AltDown());
		p[5] = api_create_integer(func, event.ShiftDown());
		api_call_func(func, 6, p);
	}
	event.Skip();
}


void myTreeCtrl::OnActivated(wxTreeEvent& event)
{
	void *func = GetClientData();
	if (func) {
		wxTreeItemId id = event.GetItem();
		wxString s = GetItemText(id);
		id = GetItemParent(id);
		while (id.IsOk()) {
			s = GetItemText(id) + "/" + s;
			id = GetItemParent(id);
		}
		void *p[1];
		p[0] = api_create_string(func, s.c_str());
		api_call_func(func, 1, p);
	}
	event.Skip();
}


void myFrame::OnSize(wxSizeEvent& event)
{
	void *func = GetClientData();
	if (func) {
		int w, h;
		GetSize(&w, &h);
		void *p[3] = {  api_create_string(func, "size"),
						api_create_integer(func, w),
						api_create_integer(func, h) };
		api_call_func(func, 3, p);
	}
	event.Skip();
}


void myFrame::OnTimer(wxTimerEvent& event)
{
	void *func = GetClientData();
	if (func) {
		void *p[3] = {  api_create_string(func, "timer"),
						api_create_integer(func, timer.GetInterval()),
						api_create_integer(func, timer.IsRunning()) };
		api_call_func(func, 3, p);
	}
	event.Skip();
}

/*
void myFrame::OnDropFile(wxDropFilesEvent& event)
{
	void *func = GetClientData();
	if (func) {
		void *p[3];
		p[0] =  api_create_string("dropfile");
		p[1] =  api_create_string(event.GetFiles()->c_str());
		p[2] =  api_create_integer(event.GetNumberOfFiles());
		api_call_func(func, 3, p);
	}
	event.Skip();
}
*/

void myFrame::OnPaint(wxPaintEvent& event)
{
	void *func = GetClientData();
	if (func) {
		wxPaintDC dc(this);
		void *p[3];
		p[0] =  api_create_string(func, "paint");
		p[1] =  api_create_user(func, GetHandle(), 0, 0, 0);
		p[2] =  api_create_null(func);
		api_call_func(func, 3, p);
	}
	event.Skip();
}