#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 "wx/image.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);

	void OnErase(wxEraseEvent& 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 *func = GetClientData();
		if (func) {
			void *p[3];
			p[0] =  api_create_string(func, "exit");
			p[1] =  api_create_null(func);
			p[2] =  api_create_null(func);
			api_call_func(func, 3, p);
		}
	}

	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() { if (_module) 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) {
			wxMessageBox(_T(err), "Z-Script", wxOK | wxICON_ERROR);
			return false;
		}
		if (api_exec_module(_module, err) <= 0) {
			wxMessageBox(_T(err), "Z-Script", wxOK | wxICON_ERROR);
			api_delete_module(_module);
			_module = 0;
			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); }
};

struct zsOptions
{
	const char *name;
	long code;
};

// utility functions

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

long get_options(void *caller, const char *str, struct zsOptions ops[])
{
	long flag = 0;
	int k1 = 0, k2, n = strlen(str);
	char buf[128];
	for (k2 = 1; k2 <= n; k2++) {
		if (str[k2] == '|' || k2 == n) {
			strncpy(buf, str+k1, k2-k1);
			buf[k2-k1] = 0;
			int i = 0;
			while (ops[i].name != 0) {
				if (strcmp(buf, ops[i].name) == 0) {
					flag |= ops[i].code;
					break;
				}
				i++;
			}
			if (ops[i].name == 0) api_runtime_error(caller, "incorrect option string");
			k2++;
			k1 = k2;
		}
	}
	return flag;
}

// 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, wxGetApp().GetTopWindow());
	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) {
		void *func = api_get_func(caller, api_get_string(caller, args[0]));
		frame->SetClientData(func);
	}
	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* wx_timer(void *caller, int nargs, void** args)
{
	myApp& app = wxGetApp();
	myFrame *frame = (myFrame*)app.GetTopWindow();
	int ms = api_get_integer(caller, args[0]);
	if (ms <= 0) frame->timer.Stop();
	else         frame->timer.Start(ms);
	return 0;
}
static zsRegPrimitive wx1a3("wxtimer", 0, wx_timer);


/////////////////////////////////////////////////////////////////////

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_get(void *caller, int nargs, void** args)
{
	if (nargs < 1) input_error(caller);
	wxWindow *win = (wxWindow*)api_get_user(caller, args[0], WINDOW_TYPE);
	if (win->IsKindOf(CLASSINFO(wxSlider))) {
		return api_create_integer(caller, ((wxSlider*)win)->GetValue());
	}
	if (win->IsKindOf(CLASSINFO(wxRadioButton))) {
		return api_create_integer(caller, ((wxRadioButton*)win)->GetValue());
	}
	if (win->IsKindOf(CLASSINFO(wxCheckBox))) {
		return api_create_integer(caller, ((wxCheckBox*)win)->GetValue());
	}
	if (win->IsKindOf(CLASSINFO(wxRadioBox))) {
		return api_create_string(caller, ((wxRadioBox*)win)->GetStringSelection().c_str());
	}
	return api_create_string(caller, win->GetLabel().c_str());
}
static zsRegPrimitive wx1b1("get", WINDOW_TYPE, win_get);


void* win_set(void *caller, int nargs, void** args)
{
	if (nargs < 1) input_error(caller);
	wxWindow *win = (wxWindow*)api_get_user(caller, args[0], WINDOW_TYPE);
	if (win->IsKindOf(CLASSINFO(wxSlider))) {
		((wxSlider*)win)->SetValue(api_get_integer(caller, args[1]));
		return 0;
	}
	if (win->IsKindOf(CLASSINFO(wxRadioButton))) {
		((wxRadioButton*)win)->SetValue(api_get_integer(caller, args[1]) != 0);
		return 0;
	}
	if (win->IsKindOf(CLASSINFO(wxCheckBox))) {
		((wxCheckBox*)win)->SetValue(api_get_integer(caller, args[1]) != 0);
		return 0;
	}
	win->SetLabel(api_get_string(caller, args[1]));
	return 0;
}
static zsRegPrimitive wx1b2("set", WINDOW_TYPE, win_set);


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) {
		zsOptions ops[] = { { "caption", wxCAPTION },
							{ "resize", wxRESIZE_BORDER },
							{ "close", wxCLOSE_BOX },
							{ "minimize", wxMINIMIZE_BOX },
							{ "maximize", wxMAXIMIZE_BOX },
							{ "thick", wxTHICK_FRAME },
							{ "top", wxSTAY_ON_TOP },
							{ "no3d", wxNO_3D },
							{ 0, 0 } };
		style = get_options(caller, api_get_string(caller, args[1]), ops);
	}
	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_bgcolor(void *caller, int nargs, void** args)
{
	if (nargs < 1) input_error(caller);
	wxWindow *w = (wxWindow*)api_get_user(caller, args[0], WINDOW_TYPE);
	if (nargs == 1) {
		wxColour color = w->GetBackgroundColour();
		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;
	}
	if (nargs < 4) input_error(caller);
	int r = api_get_integer(caller, args[1]);
	int g = api_get_integer(caller, args[2]);
	int b = api_get_integer(caller, args[3]);
	wxColour color(r, g, b);
	w->SetBackgroundColour(color);
	return 0;
}
static zsRegPrimitive wx1c5a("bgcolor", WINDOW_TYPE, win_bgcolor);


void* win_fgcolor(void *caller, int nargs, void** args)
{
	if (nargs < 1) input_error(caller);
	wxWindow *w = (wxWindow*)api_get_user(caller, args[0], WINDOW_TYPE);
	if (nargs == 1) {
		wxColour color = w->GetForegroundColour();
		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;
	}
	if (nargs < 4) input_error(caller);
	int r = api_get_integer(caller, args[1]);
	int g = api_get_integer(caller, args[2]);
	int b = api_get_integer(caller, args[3]);
	wxColour color(r, g, b);
	w->SetForegroundColour(color);
	return 0;
}
static zsRegPrimitive wx1c5b("fgcolor", WINDOW_TYPE, win_fgcolor);


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;
	if (api_is_integer(args[1])) {
		wxFont font = w->GetFont();
		font.SetPointSize(api_get_integer(caller, args[1]));
		w->SetFont(font);
		return 0;
	}
	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("font", WINDOW_TYPE, win_font);


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);
	const char *type = api_get_string(caller, args[1]);
	if (strcmp(type, "herbox") == 0) {
		wxBoxSizer *sizer = new wxBoxSizer(wxHORIZONTAL);
		w->SetSizer(sizer);
		sizer->SetSizeHints(w);   
		return api_create_user(caller, sizer, 0, 0, SIZER_TYPE);
	}
	else if (strcmp(type, "verbox") == 0) {
		wxBoxSizer *sizer = new wxBoxSizer(wxVERTICAL);
		w->SetSizer(sizer);
		sizer->SetSizeHints(w);   
		return api_create_user(caller, sizer, 0, 0, SIZER_TYPE);
	}
	else if (strcmp(type, "herstatic") == 0) {
		if (nargs < 3) input_error(caller);
		wxStaticBoxSizer *sizer = new wxStaticBoxSizer(wxHORIZONTAL, 0, api_get_string(caller, args[2]));
		w->SetSizer(sizer);
		sizer->SetSizeHints(w);   
		return api_create_user(caller, sizer, 0, 0, SIZER_TYPE);
	}
	else if (strcmp(type, "verstatic") == 0) {
		if (nargs < 3) input_error(caller);
		wxStaticBoxSizer *sizer = new wxStaticBoxSizer(wxVERTICAL, 0, api_get_string(caller, args[2]));
		w->SetSizer(sizer);
		sizer->SetSizeHints(w);   
		return api_create_user(caller, sizer, 0, 0, SIZER_TYPE);
	}
	else if (strcmp(type, "flexgrid") == 0) {
		if (nargs < 6) input_error(caller);
		int rows = api_get_integer(caller, args[2]);
		int vgap = api_get_integer(caller, args[3]);
		int cols = api_get_integer(caller, args[4]);
		int hgap = api_get_integer(caller, args[5]);
		wxFlexGridSizer *sizer = new wxFlexGridSizer(rows, cols, vgap, hgap);
		w->SetSizer(sizer);
		sizer->SetSizeHints(w);   
		return api_create_user(caller, sizer, 0, 0, SIZER_TYPE);
	}
	api_runtime_error(caller, "unsupported 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);
	zsOptions ops[] = { { "simple", wxSIMPLE_BORDER },
						{ "double", wxDOUBLE_BORDER },
						{ "sunken", wxSUNKEN_BORDER },
						{ "raised", wxRAISED_BORDER },
						{ "static", wxSTATIC_BORDER },
						{ "none", wxNO_BORDER },
						{ "vscroll", wxVSCROLL },
						{ "hscroll", wxHSCROLL },
						{ "clip", wxCLIP_CHILDREN },
						{ "transparent", wxTRANSPARENT_WINDOW },
						{ 0, 0 } };
	w->SetWindowStyle(get_options(caller, api_get_string(caller, args[1]), ops));
	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_radiobutton(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 *caption = api_get_string(caller, args[1]);
	long style = wxRB_SINGLE;
	if (nargs > 2 && api_get_integer(caller, args[2]) != 0) style = wxRB_GROUP;
	wxRadioButton *p = new wxRadioButton(parent, wxID_ANY, _T(caption), wxDefaultPosition, wxDefaultSize, style);
	return api_create_user(caller, p, 0, 0, WINDOW_TYPE);
}
static zsRegPrimitive wx1g4a("radiobutton", WINDOW_TYPE, win_radiobutton);


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_LABELS|wxSL_AUTOTICKS;
	if (strcmp(s, "left") == 0) style |= wxSL_LEFT|wxSL_INVERSE;
	else if (strcmp(s, "right") == 0) style |= wxSL_RIGHT|wxSL_INVERSE;
	else if (strcmp(s, "top") == 0) style |= wxSL_TOP;
	else style |= wxSL_BOTTOM;
	int vmin  = api_get_integer(caller, args[2]);
	int vmax  = api_get_integer(caller, args[3]);
	int value = api_get_integer(caller, args[4]);
	int freq = (vmax-vmin) / 10;
	if (nargs > 5) freq = api_get_integer(caller, args[5]);
	wxSlider *p = new wxSlider(parent, wxID_ANY, value, vmin, vmax, wxDefaultPosition, wxDefaultSize, style);
	p->SetTickFreq(freq, 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) {
		zsOptions ops[] = { { "multiline", wxTE_MULTILINE },
							{ "password", wxTE_PASSWORD },
							{ "readonly", wxTE_READONLY },
							{ "left", wxTE_LEFT },
							{ "center", wxTE_CENTRE },
							{ "right", wxTE_RIGHT },
							{ 0, 0 } };
		style = get_options(caller, api_get_string(caller, args[2]), ops);
	}
	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);
	zsOptions ops[] = { { "top", wxNB_TOP },
						{ "left", wxNB_LEFT },
						{ "rigth", wxNB_RIGHT },
						{ "bottom", wxNB_BOTTOM },
						{ 0, 0 } };
	long style = get_options(caller, api_get_string(caller, args[1]), ops);
	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);


void* win_bitmap(void *caller, int nargs, void** args)
{
	if (nargs < 2) input_error(caller);
	wxWindow *win = (wxWindow*)api_get_user(caller, args[0], WINDOW_TYPE);
/*
	if (api_is_user(args[1]) && nargs > 5) {
		unsigned char *R = (unsigned char*)api_get_ptr(caller, args[1]);
		unsigned char *G = (unsigned char*)api_get_ptr(caller, args[2]);
		unsigned char *B = (unsigned char*)api_get_ptr(caller, args[3]);
		int width = api_get_integer(caller, args[4]);
		int height = api_get_integer(caller, args[5]);
		int logicalFunc = wxAND;
		if (nargs > 6 && api_get_integer(caller, args[6]) == 0) logicalFunc = wxCOPY;
		wxClientDC dc(win);
		dc.BeginDrawing();
		wxPen pen;
		pen.SetWidth(1);
		pen.SetStyle(wxSOLID);
		dc.SetPen(pen);
		int i, j, k = 0;
		for (i = 0; i < height; i++) {
			for (j = 0; j < width; j++) {
				pen.SetColour(R[k], G[k], B[k]);
				k++;
				dc.DrawPoint(j, i);
			}
		}
		dc.EndDrawing();
		return 0;
	}
*/
	wxImage img;
	if (!img.LoadFile(api_get_string(caller, args[1]), wxBITMAP_TYPE_ANY)) api_runtime_error(caller, "image type unsupported");
	wxClientDC dc(win);
	int logicalFunc = wxAND;
	if (nargs > 2 && api_get_integer(caller, args[2]) == 0) logicalFunc = wxCOPY;
	wxCoord xdest=0, ydest=0, width, height;
	if (nargs > 4) {
		xdest = api_get_integer(caller, args[2]);
		ydest = api_get_integer(caller, args[3]);
		width = img.GetWidth();
		height = img.GetHeight();
	}
	else {
		dc.GetSize(&width, &height);
		img.Rescale(width, height);
	}
	wxBitmap bmp(img);
	wxMemoryDC mdc;
	mdc.SelectObject(bmp);
	dc.BeginDrawing();
	dc.Blit(xdest, ydest, width, height, &mdc, 0, 0, logicalFunc, true);
	dc.EndDrawing();
	return 0;
}
static zsRegPrimitive wx1g12("bitmap", WINDOW_TYPE, win_bitmap);


void* win_label(void *caller, int nargs, void** args)
{
	if (nargs < 2) input_error(caller);
	wxWindow *win = (wxWindow*)api_get_user(caller, args[0], WINDOW_TYPE);
	wxString s(_T(api_get_string(caller, args[1])));
	win->SetLabel(s);
	return 0;
}
static zsRegPrimitive wx1g13("label", WINDOW_TYPE, win_label);

/*
void* win_fontface(void *caller, int nargs, void** args)
{
	if (nargs < 2) input_error(caller);
	wxWindow *win = (wxWindow*)api_get_user(caller, args[0], WINDOW_TYPE);
	wxString s(_T(api_get_string(caller, args[1])));
	wxFont font = win->GetFont();
	font.SetFaceName(s);
	win->SetFont(font);
	return 0;
}
static zsRegPrimitive wx1h1("fontface", WINDOW_TYPE, win_fontface);


void* win_fontsize(void *caller, int nargs, void** args)
{
	if (nargs < 2) input_error(caller);
	wxWindow *win = (wxWindow*)api_get_user(caller, args[0], WINDOW_TYPE);
	wxFont font = win->GetFont();
	font.SetPointSize(api_get_integer(caller, args[1]));
	win->SetFont(font);
	return 0;
}
static zsRegPrimitive wx1h2("fontsize", WINDOW_TYPE, win_fontsize);
*/

// 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);
	}
	else {
		api_runtime_error(caller, "unsupported icon type");
	}
	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;
		}
		wxImage img;
		if (!img.LoadFile(api_get_string(caller, args[i-1]), wxBITMAP_TYPE_ANY)) api_runtime_error(caller, "unsupported image type");
		wxBitmap bmp(img);
		long id = wxNewId();
		api_set_array_object2(caller, arr, j++, api_create_integer(caller, id));
		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);


void* win_transparent(void *caller, int nargs, void** args)
{
	if (nargs < 1) input_error(caller);
	wxWindow *win = (wxWindow*)api_get_user(caller, args[0], TOPWIN_TYPE);
	int alpha = 0, R = 255, G = 255, B = 255;
	if (nargs > 1) alpha = api_get_integer(caller, args[1]);
	if (nargs > 4) {
		R = api_get_integer(caller, args[2]);
		G = api_get_integer(caller, args[3]);
		B = api_get_integer(caller, args[4]);
	}
	// OS dependent
	HWND hwnd = (HWND)win->GetHandle(); //win->GetHWND(); //
#define WS_EX_LAYERED 0x80000
#define LWA_COLORKEY 1 
#define LWA_ALPHA 2
	SetWindowLong(hwnd, GWL_EXSTYLE, GetWindowLong(hwnd, GWL_EXSTYLE)|WS_EX_LAYERED);
	typedef DWORD (WINAPI *PSLWA)(HWND, DWORD, BYTE, DWORD);
	HMODULE hDLL = LoadLibrary ("user32");
	PSLWA pSetLayeredWindowAttributes = (PSLWA)GetProcAddress(hDLL,"SetLayeredWindowAttributes");
	if (pSetLayeredWindowAttributes != NULL) {
	    pSetLayeredWindowAttributes(hwnd, RGB(R, G, B), alpha, LWA_COLORKEY|LWA_ALPHA);
	}
	return 0;
}
static zsRegPrimitive wx2g("transparent", TOPWIN_TYPE, win_transparent);


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

long sizer_flags(void *caller, void* arg)
{
	zsOptions ops[] = {
		{ "top", wxTOP },
		{ "bottom", wxBOTTOM },
		{ "left", wxLEFT },
		{ "right", wxRIGHT },
		{ "all", wxALL },
		{ "expand", wxEXPAND },
		{ "shaped", wxSHAPED },
		{ "minsize", wxFIXED_MINSIZE },
		{ "aligncenter", wxALIGN_CENTER },
		{ "alignvertical", wxALIGN_CENTER_VERTICAL },
		{ "alignhorizontal", wxALIGN_CENTER_HORIZONTAL },
		{ "alignleft", wxALIGN_LEFT },
		{ "alignright", wxALIGN_RIGHT },
		{ "aligntop", wxALIGN_TOP },
		{ "alignbottom", wxALIGN_BOTTOM },
		{ 0, 0 } };
	return get_options(caller, api_get_string(caller, arg), ops);
}

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 (api_is_integer(args[1])) {
		if (nargs < 3) input_error(caller);
		int w = api_get_integer(caller, args[1]);
		int h = api_get_integer(caller, args[2]);
		if (nargs > 3) {
			flag = sizer_flags(caller, args[3]);
			if (nargs > 4) prop = api_get_integer(caller, args[4]);
		}
		sizer->Add(w, h, prop, flag);
		sizer->Layout();
		return 0;
	}
	if (nargs > 2) {
		flag = sizer_flags(caller, args[2]);
		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_sizer(void *caller, int nargs, void** args)
{
	if (nargs < 2) input_error(caller);
	wxSizer *topsizer = (wxSizer*)api_get_user(caller, args[0], SIZER_TYPE);
	const char *type = api_get_string(caller, args[1]);
	int flag = 0;
	int prop = 0;
	if (strcmp(type, "herbox") == 0) {
		wxBoxSizer *sizer = new wxBoxSizer(wxHORIZONTAL);
		if (nargs > 2) {
			flag = sizer_flags(caller, args[2]);
			if (nargs > 3) prop = api_get_integer(caller, args[3]);
		}
		topsizer->Add(sizer, prop, flag);
		topsizer->Layout();
		return api_create_user(caller, sizer, 0, 0, SIZER_TYPE);
	}
	else if (strcmp(type, "verbox") == 0) {
		wxBoxSizer *sizer = new wxBoxSizer(wxVERTICAL);
		if (nargs > 2) {
			flag = sizer_flags(caller, args[2]);
			if (nargs > 3) prop = api_get_integer(caller, args[3]);
		}
		topsizer->Add(sizer, prop, flag);
		topsizer->Layout();
		return api_create_user(caller, sizer, 0, 0, SIZER_TYPE);
	}
	else if (strcmp(type, "herstatic") == 0) {
		if (nargs < 3) input_error(caller);
		wxStaticBoxSizer *sizer = new wxStaticBoxSizer(wxHORIZONTAL, 0, api_get_string(caller, args[2]));
		if (nargs > 3) {
			flag = sizer_flags(caller, args[3]);
			if (nargs > 4) prop = api_get_integer(caller, args[4]);
		}
		topsizer->Add(sizer, prop, flag);
		topsizer->Layout();
		return api_create_user(caller, sizer, 0, 0, SIZER_TYPE);
	}
	else if (strcmp(type, "verstatic") == 0) {
		if (nargs < 3) input_error(caller);
		wxStaticBoxSizer *sizer = new wxStaticBoxSizer(wxVERTICAL, 0, api_get_string(caller, args[2]));
		if (nargs > 3) {
			flag = sizer_flags(caller, args[3]);
			if (nargs > 4) prop = api_get_integer(caller, args[4]);
		}
		topsizer->Add(sizer, prop, flag);
		topsizer->Layout();
		return api_create_user(caller, sizer, 0, 0, SIZER_TYPE);
	}
	else if (strcmp(type, "flexgrid") == 0) {
		if (nargs < 6) input_error(caller);
		int rows = api_get_integer(caller, args[2]);
		int vgap = api_get_integer(caller, args[3]);
		int cols = api_get_integer(caller, args[4]);
		int hgap = api_get_integer(caller, args[5]);
		wxFlexGridSizer *sizer = new wxFlexGridSizer(rows, cols, vgap, hgap);
		if (nargs > 6) {
			flag = sizer_flags(caller, args[6]);
			if (nargs > 7) prop = api_get_integer(caller, args[7]);
		}
		topsizer->Add(sizer, prop, flag);
		topsizer->Layout();
		return api_create_user(caller, sizer, 0, 0, SIZER_TYPE);
	}
	api_runtime_error(caller, "unsupported sizer type");
	return 0;
}
static zsRegPrimitive wx7b("sizer", SIZER_TYPE, sizer_sizer);


void* sizer_update(void *caller, int nargs, void** args)
{
	if (nargs < 1) input_error(caller);
	wxSizer* sizer = (wxSizer*)api_get_user(caller, args[0], SIZER_TYPE);
	sizer->Layout();
	return 0;
}
static zsRegPrimitive wx7d("update", SIZER_TYPE, sizer_update);


// the master event handler

void* wx_push(void *caller, int nargs, void** args)
{
	if (nargs < 3) 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]);
	if (strcmp(ev, "key") == 0) {
		w->Connect(wxEVT_KEY_UP,   (wxObjectEventFunction)(&myEvtHandler::OnKey), NULL, h);
//		w->Connect(wxEVT_KEY_DOWN, (wxObjectEventFunction)(&myEvtHandler::OnKey), NULL, h);
//		w->Connect(wxEVT_CHAR,     (wxObjectEventFunction)(&myEvtHandler::OnKey), NULL, h);
		return 0;
	}
	if (strcmp(ev, "mouse") == 0) {
		w->Connect(wxEVT_LEFT_UP,       (wxObjectEventFunction)(&myEvtHandler::OnMouse), NULL, h);
		w->Connect(wxEVT_LEFT_DOWN,     (wxObjectEventFunction)(&myEvtHandler::OnMouse), NULL, h);
		w->Connect(wxEVT_LEFT_DCLICK,   (wxObjectEventFunction)(&myEvtHandler::OnMouse), NULL, h);
		w->Connect(wxEVT_RIGHT_UP,      (wxObjectEventFunction)(&myEvtHandler::OnMouse), NULL, h);
		w->Connect(wxEVT_RIGHT_DOWN,    (wxObjectEventFunction)(&myEvtHandler::OnMouse), NULL, h);
		w->Connect(wxEVT_RIGHT_DCLICK,  (wxObjectEventFunction)(&myEvtHandler::OnMouse), NULL, h);
		w->Connect(wxEVT_MIDDLE_UP,     (wxObjectEventFunction)(&myEvtHandler::OnMouse), NULL, h);
		w->Connect(wxEVT_MIDDLE_DOWN,   (wxObjectEventFunction)(&myEvtHandler::OnMouse), NULL, h);
		w->Connect(wxEVT_MIDDLE_DCLICK, (wxObjectEventFunction)(&myEvtHandler::OnMouse), NULL, h);
		w->Connect(wxEVT_MOTION,        (wxObjectEventFunction)(&myEvtHandler::OnMouse), NULL, h);
		w->Connect(wxEVT_ENTER_WINDOW,  (wxObjectEventFunction)(&myEvtHandler::OnMouse), NULL, h);
		w->Connect(wxEVT_LEAVE_WINDOW,  (wxObjectEventFunction)(&myEvtHandler::OnMouse), NULL, h);
		w->Connect(wxEVT_MOUSEWHEEL,    (wxObjectEventFunction)(&myEvtHandler::OnMouse), NULL, h);
		return 0;
	}
/*
	if (strcmp(ev, "erase") == 0) {
		w->Connect(wxEVT_ERASE_BACKGROUND, (wxObjectEventFunction)(&myEvtHandler::OnErase), NULL, h);
		return 0;
	}
*/
	if (nargs < 4) input_error(caller);
	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, "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::OnErase(wxEraseEvent& event)
{
	return;
/*
	void *func = GetClientData();
	if (func) {
		void *p[1];
		p[0] = api_create_integer(func, event.GetId());
		api_call_func(func, 1, p);
	}
*/
}

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[4];
		p[0] = api_create_integer(func, event.GetKeyCode());
		p[1] = api_create_integer(func, event.ControlDown());
		p[2] = api_create_integer(func, event.AltDown());
		p[3] = api_create_integer(func, event.ShiftDown());
		api_call_func(func, 4, 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[2] = {  api_create_string(func, "timer"),
						api_create_integer(func, timer.GetInterval())
						};
		api_call_func(func, 2, p);
	}
	event.Skip();
}


void myFrame::OnDropFile(wxDropFilesEvent& event)
{
	void *func = GetClientData();
	if (func) {
		void *p[3];
		p[0] =  api_create_string(func, "dropfile");
		p[1] =  api_create_string(func, event.GetFiles()->c_str());
		p[2] =  api_create_integer(func, 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();
}