[wxWidgets.git] / utils / wxPython / src / misc.i

/////////////////////////////////////////////////////////////////////////////
// Name:        misc.i
// Purpose:     Definitions of miscelaneous functions and classes
//
// Author:      Robin Dunn
//
// Created:     7/3/97
// RCS-ID:      $Id$
// Copyright:   (c) 1998 by Total Control Software
// Licence:     wxWindows license
/////////////////////////////////////////////////////////////////////////////

%module misc

%{
#include "helpers.h"
#include <wx/resource.h>
#include <wx/tooltip.h>
%}

//----------------------------------------------------------------------

%include typemaps.i
%include my_typemaps.i

// Import some definitions of other classes, etc.
%import _defs.i


//---------------------------------------------------------------------------


class wxSize {
public:
    long x;
    long y;
    %name(width) long x;
    %name(height)long y;

    wxSize(long w=0, long h=0);
    ~wxSize();
    void Set(long w, long h);
    long GetX();
    long GetY();
    long GetWidth();
    long GetHeight();
    void SetWidth(long w);
    void SetHeight(long h);

    %addmethods {
        PyObject* asTuple() {
            PyObject* tup = PyTuple_New(2);
            PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
            PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
            return tup;
        }
    }
    %pragma(python) addtoclass = "def __str__(self): return str(self.asTuple())"
    %pragma(python) addtoclass = "def __repr__(self): return str(self.asTuple())"

};

//---------------------------------------------------------------------------

class wxRealPoint {
public:
    double x;
    double y;
    wxRealPoint(double x=0.0, double y=0.0);
    ~wxRealPoint();

    %addmethods {
        void Set(double x, double y) {
            self->x = x;
            self->y = y;
        }
        PyObject* asTuple() {
            PyObject* tup = PyTuple_New(2);
            PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->x));
            PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->y));
            return tup;
        }
    }
    %pragma(python) addtoclass = "def __str__(self): return str(self.asTuple())"
    %pragma(python) addtoclass = "def __repr__(self): return str(self.asTuple())"
};


class wxPoint {
public:
    long x;
    long y;
    wxPoint(long x=0, long y=0);
    ~wxPoint();

    %addmethods {
        void Set(long x, long y) {
            self->x = x;
            self->y = y;
        }
        PyObject* asTuple() {
            PyObject* tup = PyTuple_New(2);
            PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
            PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
            return tup;
        }
    }
    %pragma(python) addtoclass = "def __str__(self): return str(self.asTuple())"
    %pragma(python) addtoclass = "def __repr__(self): return str(self.asTuple())"
};

//---------------------------------------------------------------------------

class wxRect {
public:
   wxRect(long x=0, long y=0, long w=0, long h=0);
   // TODO: do this one too... wxRect(const wxPoint& pos, const wxSize& size);
   ~wxRect();

   long  GetX();
   void SetX(long X);
   long  GetY();
   void SetY(long Y);
   long  GetWidth();
   void SetWidth(long w);
   long  GetHeight();
   void SetHeight(long h);


   wxPoint GetPosition();
   wxSize GetSize();

   long  GetLeft();
   long  GetTop();
   long  GetBottom();
   long  GetRight();

   long x, y, width, height;

    %addmethods {
        PyObject* asTuple() {
            PyObject* tup = PyTuple_New(4);
            PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
            PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
            PyTuple_SET_ITEM(tup, 2, PyInt_FromLong(self->width));
            PyTuple_SET_ITEM(tup, 3, PyInt_FromLong(self->height));
            return tup;
        }
    }
    %pragma(python) addtoclass = "def __str__(self): return str(self.asTuple())"
    %pragma(python) addtoclass = "def __repr__(self): return str(self.asTuple())"
};


//---------------------------------------------------------------------------
// Dialog Functions

wxString wxFileSelector(char* message,
                        char* default_path = NULL,
                        char* default_filename = NULL,
                        char* default_extension = NULL,
                        char* wildcard = "*.*",
                        int flags = 0,
                        wxWindow *parent = NULL,
                        int x = -1, int y = -1);

wxString wxGetTextFromUser(const wxString& message,
                           const wxString& caption = wxPyEmptyStr,
                           const wxString& default_value = wxPyEmptyStr,
                           wxWindow *parent = NULL,
                           int x = -1, int y = -1,
                           bool centre = TRUE);


// TODO: Need to custom wrap this one...
// int wxGetMultipleChoice(char* message, char* caption,
//                         int LCOUNT, char** LIST,
//                         int nsel, int *selection,
//                         wxWindow *parent = NULL, int x = -1, int y = -1,
//                         bool centre = TRUE, int width=150, int height=200);


wxString wxGetSingleChoice(const wxString& message, const wxString& caption,
                           int LCOUNT, wxString* LIST,
                           wxWindow *parent = NULL,
                           int x = -1, int y = -1,
                           bool centre = TRUE,
                           int width=150, int height=200);

int wxGetSingleChoiceIndex(const wxString& message, const wxString& caption,
                           int LCOUNT, wxString* LIST,
                           wxWindow *parent = NULL,
                           int x = -1, int y = -1,
                           bool centre = TRUE,
                           int width=150, int height=200);


int wxMessageBox(const wxString& message,
                 const wxString& caption = wxPyEmptyStr,
                 int style = wxOK | wxCENTRE,
                 wxWindow *parent = NULL,
                 int x = -1, int y = -1);

long wxGetNumberFromUser(const wxString& message,
                         const wxString& prompt,
                         const wxString& caption,
                         long value,
                         long min = 0, long max = 100,
                         wxWindow *parent = NULL,
                         const wxPoint& pos = wxPyDefaultPosition);

//---------------------------------------------------------------------------
// GDI Functions

bool wxColourDisplay();
int wxDisplayDepth();
void wxSetCursor(wxCursor& cursor);

//---------------------------------------------------------------------------
// Miscellaneous functions

long wxNewId();
void wxRegisterId(long id);
%name(NewId) long wxNewId();
%name(RegisterId) void wxRegisterId(long id);

void wxBeginBusyCursor(wxCursor *cursor = wxHOURGLASS_CURSOR);
void wxBell();
void wxDisplaySize(int *OUTPUT, int *OUTPUT);
void wxEndBusyCursor();
long wxExecute(const wxString& command, bool sync = FALSE);
#ifdef __WXMSW__
wxWindow * wxGetActiveWindow();
long wxGetElapsedTime(bool resetTimer = TRUE);
long wxGetFreeMemory();
#endif
void wxGetMousePosition(int* OUTPUT, int* OUTPUT);
bool wxIsBusy();
wxString wxNow();
#ifdef __WXMSW__
bool wxShell(const wxString& command = wxPyEmptyStr);
void wxStartTimer();
int wxGetOsVersion(int *OUTPUT, int *OUTPUT);
#endif

void wxSleep(int secs);
bool wxYield();
bool wxSafeYield();
void wxEnableTopLevelWindows(bool enable);

%inline %{
    char* wxGetResource(char *section, char *entry, char *file = NULL) {
        char * retval;
        wxGetResource(section, entry, &retval, file);
        return retval;
    }
%}

//---------------------------------------------------------------------------
// Resource System

bool wxResourceAddIdentifier(char *name, int value);
void wxResourceClear(void);
wxBitmap  wxResourceCreateBitmap(char *resource);
wxIcon  wxResourceCreateIcon(char *resource);
wxMenuBar * wxResourceCreateMenuBar(char *resource);
int wxResourceGetIdentifier(char *name);
bool wxResourceParseData(char *resource, wxResourceTable *table = NULL);
bool wxResourceParseFile(char *filename, wxResourceTable *table = NULL);
bool wxResourceParseString(char *resource, wxResourceTable *table = NULL);


//----------------------------------------------------------------------

class wxPyTimer {
public:
    wxPyTimer(PyObject* notify);
    ~wxPyTimer();
    int Interval();
    void Start(int milliseconds=-1, int oneShot=FALSE);
    void Stop();
};

//---------------------------------------------------------------------------

enum wxEdge { wxLeft, wxTop, wxRight, wxBottom, wxWidth, wxHeight,
              wxCentre, wxCenter = wxCentre, wxCentreX, wxCentreY };
enum wxRelationship { wxUnconstrained = 0,
                      wxAsIs,
                      wxPercentOf,
                      wxAbove,
                      wxBelow,
                      wxLeftOf,
                      wxRightOf,
                      wxSameAs,
                      wxAbsolute };


class wxIndividualLayoutConstraint {
public:
//    wxIndividualLayoutConstraint();
//    ~wxIndividualLayoutConstraint();

    void Above(wxWindow *otherWin, int margin=0);
    void Absolute(int value);
    void AsIs();
    void Below(wxWindow *otherWin, int margin=0);
    void Unconstrained();
    void LeftOf(wxWindow *otherWin, int margin=0);
    void PercentOf(wxWindow *otherWin, wxEdge edge, int percent);
    void RightOf(wxWindow *otherWin, int margin=0);
    void SameAs(wxWindow *otherWin, wxEdge edge, int margin=0);
    void Set(wxRelationship rel, wxWindow *otherWin, wxEdge otherEdge, int value=0, int margin=0);
};


class wxLayoutConstraints {
public:
    wxLayoutConstraints();

%readonly
    wxIndividualLayoutConstraint bottom;
    wxIndividualLayoutConstraint centreX;
    wxIndividualLayoutConstraint centreY;
    wxIndividualLayoutConstraint height;
    wxIndividualLayoutConstraint left;
    wxIndividualLayoutConstraint right;
    wxIndividualLayoutConstraint top;
    wxIndividualLayoutConstraint width;
%readwrite
}


//---------------------------------------------------------------------------
// Regions, etc.

enum wxRegionContain {
	wxOutRegion, wxPartRegion, wxInRegion
};


class wxRegion {
public:
    wxRegion();
    ~wxRegion();

    void Clear();
    wxRegionContain Contains(long x, long y);
    %name(ContainsPoint)wxRegionContain Contains(const wxPoint& pt);
    %name(ContainsRect)wxRegionContain Contains(const wxRect& rect);

    wxRect GetBox();
    bool Intersect(const wxRect& rect);
#ifdef __WXMSW__
    bool IsEmpty();
#endif
    bool Subtract(const wxRect& rect);
    bool Union(const wxRect& rect);
    bool Xor(const wxRect& rect);
};


class wxRegionIterator {
public:
    wxRegionIterator(const wxRegion& region);
    ~wxRegionIterator();

    long GetX();
    long GetY();
    long GetW();
    long GetWidth();
    long GetH();
    long GetHeight();
    wxRect GetRect();
    bool HaveRects();
    void Reset();

    %addmethods {
        void Next() {
            (*self) ++;
        }
    };
};


//---------------------------------------------------------------------------
// Accelerator Entry and Table

class wxAcceleratorEntry {
public:
    wxAcceleratorEntry(int flags = 0, int keyCode = 0, int cmd = 0);
    ~wxAcceleratorEntry();

    void Set(int flags, int keyCode, int Cmd);
    int GetFlags();
    int GetKeyCode();
    int GetCommand();
};


class wxAcceleratorTable {
public:
    // Can also accept a list of 3-tuples
    wxAcceleratorTable(int LCOUNT, wxAcceleratorEntry* LIST);
    ~wxAcceleratorTable();

};

//---------------------------------------------------------------------------

enum {
    wxSYS_WHITE_BRUSH,
    wxSYS_LTGRAY_BRUSH,
    wxSYS_GRAY_BRUSH,
    wxSYS_DKGRAY_BRUSH,
    wxSYS_BLACK_BRUSH,
    wxSYS_NULL_BRUSH,
    wxSYS_HOLLOW_BRUSH,
    wxSYS_WHITE_PEN,
    wxSYS_BLACK_PEN,
    wxSYS_NULL_PEN,
    wxSYS_OEM_FIXED_FONT,
    wxSYS_ANSI_FIXED_FONT,
    wxSYS_ANSI_VAR_FONT,
    wxSYS_SYSTEM_FONT,
    wxSYS_DEVICE_DEFAULT_FONT,
    wxSYS_DEFAULT_PALETTE,
    wxSYS_SYSTEM_FIXED_FONT,
    wxSYS_DEFAULT_GUI_FONT,

    wxSYS_COLOUR_SCROLLBAR,
    wxSYS_COLOUR_BACKGROUND,
    wxSYS_COLOUR_ACTIVECAPTION,
    wxSYS_COLOUR_INACTIVECAPTION,
    wxSYS_COLOUR_MENU,
    wxSYS_COLOUR_WINDOW,
    wxSYS_COLOUR_WINDOWFRAME,
    wxSYS_COLOUR_MENUTEXT,
    wxSYS_COLOUR_WINDOWTEXT,
    wxSYS_COLOUR_CAPTIONTEXT,
    wxSYS_COLOUR_ACTIVEBORDER,
    wxSYS_COLOUR_INACTIVEBORDER,
    wxSYS_COLOUR_APPWORKSPACE,
    wxSYS_COLOUR_HIGHLIGHT,
    wxSYS_COLOUR_HIGHLIGHTTEXT,
    wxSYS_COLOUR_BTNFACE,
    wxSYS_COLOUR_BTNSHADOW,
    wxSYS_COLOUR_GRAYTEXT,
    wxSYS_COLOUR_BTNTEXT,
    wxSYS_COLOUR_INACTIVECAPTIONTEXT,
    wxSYS_COLOUR_BTNHIGHLIGHT,

    wxSYS_COLOUR_3DDKSHADOW,
    wxSYS_COLOUR_3DLIGHT,
    wxSYS_COLOUR_INFOTEXT,
    wxSYS_COLOUR_INFOBK,

    wxSYS_COLOUR_DESKTOP,
    wxSYS_COLOUR_3DFACE,
    wxSYS_COLOUR_3DSHADOW,
    wxSYS_COLOUR_3DHIGHLIGHT,
    wxSYS_COLOUR_3DHILIGHT,
    wxSYS_COLOUR_BTNHILIGHT,

    wxSYS_MOUSE_BUTTONS,
    wxSYS_BORDER_X,
    wxSYS_BORDER_Y,
    wxSYS_CURSOR_X,
    wxSYS_CURSOR_Y,
    wxSYS_DCLICK_X,
    wxSYS_DCLICK_Y,
    wxSYS_DRAG_X,
    wxSYS_DRAG_Y,
    wxSYS_EDGE_X,
    wxSYS_EDGE_Y,
    wxSYS_HSCROLL_ARROW_X,
    wxSYS_HSCROLL_ARROW_Y,
    wxSYS_HTHUMB_X,
    wxSYS_ICON_X,
    wxSYS_ICON_Y,
    wxSYS_ICONSPACING_X,
    wxSYS_ICONSPACING_Y,
    wxSYS_WINDOWMIN_X,
    wxSYS_WINDOWMIN_Y,
    wxSYS_SCREEN_X,
    wxSYS_SCREEN_Y,
    wxSYS_FRAMESIZE_X,
    wxSYS_FRAMESIZE_Y,
    wxSYS_SMALLICON_X,
    wxSYS_SMALLICON_Y,
    wxSYS_HSCROLL_Y,
    wxSYS_VSCROLL_X,
    wxSYS_VSCROLL_ARROW_X,
    wxSYS_VSCROLL_ARROW_Y,
    wxSYS_VTHUMB_Y,
    wxSYS_CAPTION_Y,
    wxSYS_MENU_Y,
    wxSYS_NETWORK_PRESENT,
    wxSYS_PENWINDOWS_PRESENT,
    wxSYS_SHOW_SOUNDS,
    wxSYS_SWAP_BUTTONS,
};


%inline %{

    wxColour wxSystemSettings_GetSystemColour(int index) {
        return wxSystemSettings::GetSystemColour(index);
    }

    wxFont wxSystemSettings_GetSystemFont(int index) {
        return wxSystemSettings::GetSystemFont(index);
    }

    int wxSystemSettings_GetSystemMetric(int index) {
        return wxSystemSettings::GetSystemMetric(index);
    }
%}

//---------------------------------------------------------------------------
//---------------------------------------------------------------------------
Commit	Line	Data
7bf85405 RD	1	/////////////////////////////////////////////////////////////////////////////
	2	// Name: misc.i
	3	// Purpose: Definitions of miscelaneous functions and classes
	4	//
	5	// Author: Robin Dunn
	6	//
	7	// Created: 7/3/97
	8	// RCS-ID: $Id$
	9	// Copyright: (c) 1998 by Total Control Software
	10	// Licence: wxWindows license
	11	/////////////////////////////////////////////////////////////////////////////
	12
03e9bead	13	%module misc
7bf85405	14
03e9bead	15	%{
7bf85405 RD	16	#include "helpers.h"
7bf85405 RD	17	#include <wx/resource.h>
af309447	18	#include <wx/tooltip.h>
7bf85405 RD	19	%}
	20
	21	//----------------------------------------------------------------------
	22
	23	%include typemaps.i
	24	%include my_typemaps.i
	25
	26	// Import some definitions of other classes, etc.
	27	%import _defs.i
	28
7bf85405	29
bb0054cd	30	//---------------------------------------------------------------------------
7bf85405 RD	31
	32
	33	class wxSize {
	34	public:
af309447 RD	35	long x;
af309447 RD	36	long y;
7bf85405 RD	37	%name(width) long x;
	38	%name(height)long y;
	39
	40	wxSize(long w=0, long h=0);
	41	~wxSize();
	42	void Set(long w, long h);
af309447 RD	43	long GetX();
af309447 RD	44	long GetY();
bb0054cd RD	45	long GetWidth();
	46	long GetHeight();
	47	void SetWidth(long w);
	48	void SetHeight(long h);
7bf85405 RD	49
7bf85405 RD	50	%addmethods {
af309447	51	PyObject* asTuple() {
7bf85405 RD	52	PyObject* tup = PyTuple_New(2);
	53	PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
	54	PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
	55	return tup;
	56	}
	57	}
af309447 RD	58	%pragma(python) addtoclass = "def __str__(self): return str(self.asTuple())"
	59	%pragma(python) addtoclass = "def __repr__(self): return str(self.asTuple())"
	60
7bf85405 RD	61	};
	62
	63	//---------------------------------------------------------------------------
	64
	65	class wxRealPoint {
	66	public:
	67	double x;
	68	double y;
	69	wxRealPoint(double x=0.0, double y=0.0);
	70	~wxRealPoint();
efc5f224 RD	71
	72	%addmethods {
	73	void Set(double x, double y) {
	74	self->x = x;
	75	self->y = y;
	76	}
	77	PyObject* asTuple() {
	78	PyObject* tup = PyTuple_New(2);
	79	PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->x));
	80	PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->y));
	81	return tup;
	82	}
	83	}
	84	%pragma(python) addtoclass = "def __str__(self): return str(self.asTuple())"
	85	%pragma(python) addtoclass = "def __repr__(self): return str(self.asTuple())"
7bf85405 RD	86	};
7bf85405 RD	87
efc5f224	88
7bf85405 RD	89	class wxPoint {
	90	public:
	91	long x;
	92	long y;
	93	wxPoint(long x=0, long y=0);
	94	~wxPoint();
	95
	96	%addmethods {
	97	void Set(long x, long y) {
	98	self->x = x;
	99	self->y = y;
	100	}
af309447	101	PyObject* asTuple() {
7bf85405 RD	102	PyObject* tup = PyTuple_New(2);
	103	PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
	104	PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
	105	return tup;
	106	}
	107	}
af309447 RD	108	%pragma(python) addtoclass = "def __str__(self): return str(self.asTuple())"
af309447 RD	109	%pragma(python) addtoclass = "def __repr__(self): return str(self.asTuple())"
7bf85405 RD	110	};
	111
	112	//---------------------------------------------------------------------------
	113
	114	class wxRect {
	115	public:
	116	wxRect(long x=0, long y=0, long w=0, long h=0);
	117	// TODO: do this one too... wxRect(const wxPoint& pos, const wxSize& size);
	118	~wxRect();
	119
	120	long GetX();
	121	void SetX(long X);
	122	long GetY();
	123	void SetY(long Y);
	124	long GetWidth();
	125	void SetWidth(long w);
	126	long GetHeight();
	127	void SetHeight(long h);
	128
	129
	130	wxPoint GetPosition();
	131	wxSize GetSize();
	132
	133	long GetLeft();
	134	long GetTop();
	135	long GetBottom();
	136	long GetRight();
	137
	138	long x, y, width, height;
af309447 RD	139
	140	%addmethods {
	141	PyObject* asTuple() {
	142	PyObject* tup = PyTuple_New(4);
	143	PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
	144	PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
f0261a72 RD	145	PyTuple_SET_ITEM(tup, 2, PyInt_FromLong(self->width));
f0261a72 RD	146	PyTuple_SET_ITEM(tup, 3, PyInt_FromLong(self->height));
af309447 RD	147	return tup;
	148	}
	149	}
	150	%pragma(python) addtoclass = "def __str__(self): return str(self.asTuple())"
	151	%pragma(python) addtoclass = "def __repr__(self): return str(self.asTuple())"
7bf85405 RD	152	};
	153
	154
	155
	156	//---------------------------------------------------------------------------
	157	// Dialog Functions
	158
08127323	159	wxString wxFileSelector(char* message,
7bf85405 RD	160	char* default_path = NULL,
	161	char* default_filename = NULL,
	162	char* default_extension = NULL,
	163	char* wildcard = ".",
	164	int flags = 0,
	165	wxWindow *parent = NULL,
	166	int x = -1, int y = -1);
	167
	168	wxString wxGetTextFromUser(const wxString& message,
	169	const wxString& caption = wxPyEmptyStr,
	170	const wxString& default_value = wxPyEmptyStr,
	171	wxWindow *parent = NULL,
	172	int x = -1, int y = -1,
	173	bool centre = TRUE);
	174
d24a34bb	175
7bf85405 RD	176	// TODO: Need to custom wrap this one...
	177	// int wxGetMultipleChoice(char* message, char* caption,
	178	// int LCOUNT, char** LIST,
	179	// int nsel, int *selection,
	180	// wxWindow *parent = NULL, int x = -1, int y = -1,
	181	// bool centre = TRUE, int width=150, int height=200);
	182
	183
	184	wxString wxGetSingleChoice(const wxString& message, const wxString& caption,
	185	int LCOUNT, wxString* LIST,
	186	wxWindow *parent = NULL,
	187	int x = -1, int y = -1,
	188	bool centre = TRUE,
	189	int width=150, int height=200);
	190
	191	int wxGetSingleChoiceIndex(const wxString& message, const wxString& caption,
	192	int LCOUNT, wxString* LIST,
	193	wxWindow *parent = NULL,
	194	int x = -1, int y = -1,
	195	bool centre = TRUE,
	196	int width=150, int height=200);
	197
	198
	199	int wxMessageBox(const wxString& message,
	200	const wxString& caption = wxPyEmptyStr,
	201	int style = wxOK \| wxCENTRE,
	202	wxWindow *parent = NULL,
	203	int x = -1, int y = -1);
	204
8bf5d46e RD	205	long wxGetNumberFromUser(const wxString& message,
	206	const wxString& prompt,
	207	const wxString& caption,
	208	long value,
	209	long min = 0, long max = 100,
	210	wxWindow *parent = NULL,
	211	const wxPoint& pos = wxPyDefaultPosition);
	212
7bf85405 RD	213	//---------------------------------------------------------------------------
	214	// GDI Functions
	215
	216	bool wxColourDisplay();
	217	int wxDisplayDepth();
b8b8dda7	218	void wxSetCursor(wxCursor& cursor);
7bf85405 RD	219
	220	//---------------------------------------------------------------------------
	221	// Miscellaneous functions
	222
cf694132 RD	223	long wxNewId();
	224	void wxRegisterId(long id);
	225	%name(NewId) long wxNewId();
	226	%name(RegisterId) void wxRegisterId(long id);
	227
7bf85405 RD	228	void wxBeginBusyCursor(wxCursor *cursor = wxHOURGLASS_CURSOR);
	229	void wxBell();
	230	void wxDisplaySize(int OUTPUT, int OUTPUT);
	231	void wxEndBusyCursor();
	232	long wxExecute(const wxString& command, bool sync = FALSE);
714e6a9e	233	#ifdef __WXMSW__
7bf85405 RD	234	wxWindow * wxGetActiveWindow();
	235	long wxGetElapsedTime(bool resetTimer = TRUE);
	236	long wxGetFreeMemory();
fb5e0af0	237	#endif
7bf85405 RD	238	void wxGetMousePosition(int* OUTPUT, int* OUTPUT);
	239	bool wxIsBusy();
	240	wxString wxNow();
714e6a9e	241	#ifdef __WXMSW__
fb5e0af0	242	bool wxShell(const wxString& command = wxPyEmptyStr);
7bf85405	243	void wxStartTimer();
fb5e0af0	244	int wxGetOsVersion(int OUTPUT, int OUTPUT);
714e6a9e	245	#endif
fb5e0af0	246
bb0054cd	247	void wxSleep(int secs);
7bf85405	248	bool wxYield();
cf694132	249	bool wxSafeYield();
bb0054cd	250	void wxEnableTopLevelWindows(bool enable);
7bf85405	251
7bf85405 RD	252	%inline %{
	253	char* wxGetResource(char section, char entry, char *file = NULL) {
	254	char * retval;
	255	wxGetResource(section, entry, &retval, file);
	256	return retval;
	257	}
	258	%}
	259
	260	//---------------------------------------------------------------------------
	261	// Resource System
	262
	263	bool wxResourceAddIdentifier(char *name, int value);
	264	void wxResourceClear(void);
d5c9047a RD	265	wxBitmap wxResourceCreateBitmap(char *resource);
d5c9047a RD	266	wxIcon wxResourceCreateIcon(char *resource);
7bf85405 RD	267	wxMenuBar * wxResourceCreateMenuBar(char *resource);
	268	int wxResourceGetIdentifier(char *name);
	269	bool wxResourceParseData(char resource, wxResourceTable table = NULL);
	270	bool wxResourceParseFile(char filename, wxResourceTable table = NULL);
	271	bool wxResourceParseString(char resource, wxResourceTable table = NULL);
	272
	273
	274
	275	//----------------------------------------------------------------------
	276
	277	class wxPyTimer {
	278	public:
	279	wxPyTimer(PyObject* notify);
	280	~wxPyTimer();
	281	int Interval();
	282	void Start(int milliseconds=-1, int oneShot=FALSE);
	283	void Stop();
	284	};
	285
	286	//---------------------------------------------------------------------------
	287
	288	enum wxEdge { wxLeft, wxTop, wxRight, wxBottom, wxWidth, wxHeight,
	289	wxCentre, wxCenter = wxCentre, wxCentreX, wxCentreY };
	290	enum wxRelationship { wxUnconstrained = 0,
	291	wxAsIs,
	292	wxPercentOf,
	293	wxAbove,
	294	wxBelow,
	295	wxLeftOf,
	296	wxRightOf,
	297	wxSameAs,
	298	wxAbsolute };
	299
	300
	301	class wxIndividualLayoutConstraint {
	302	public:
	303	// wxIndividualLayoutConstraint();
	304	// ~wxIndividualLayoutConstraint();
	305
	306	void Above(wxWindow *otherWin, int margin=0);
	307	void Absolute(int value);
08127323	308	void AsIs();
7bf85405	309	void Below(wxWindow *otherWin, int margin=0);
08127323	310	void Unconstrained();
7bf85405 RD	311	void LeftOf(wxWindow *otherWin, int margin=0);
	312	void PercentOf(wxWindow *otherWin, wxEdge edge, int percent);
	313	void RightOf(wxWindow *otherWin, int margin=0);
	314	void SameAs(wxWindow *otherWin, wxEdge edge, int margin=0);
	315	void Set(wxRelationship rel, wxWindow *otherWin, wxEdge otherEdge, int value=0, int margin=0);
	316	};
	317
	318
	319	class wxLayoutConstraints {
	320	public:
	321	wxLayoutConstraints();
	322
	323	%readonly
	324	wxIndividualLayoutConstraint bottom;
	325	wxIndividualLayoutConstraint centreX;
	326	wxIndividualLayoutConstraint centreY;
	327	wxIndividualLayoutConstraint height;
	328	wxIndividualLayoutConstraint left;
	329	wxIndividualLayoutConstraint right;
	330	wxIndividualLayoutConstraint top;
	331	wxIndividualLayoutConstraint width;
	332	%readwrite
	333	}
	334
	335
b639c3c5 RD	336	//---------------------------------------------------------------------------
	337	// Regions, etc.
	338
	339	enum wxRegionContain {
	340	wxOutRegion, wxPartRegion, wxInRegion
	341	};
	342
	343
	344	class wxRegion {
	345	public:
	346	wxRegion();
	347	~wxRegion();
	348
	349	void Clear();
	350	wxRegionContain Contains(long x, long y);
	351	%name(ContainsPoint)wxRegionContain Contains(const wxPoint& pt);
	352	%name(ContainsRect)wxRegionContain Contains(const wxRect& rect);
	353
	354	wxRect GetBox();
	355	bool Intersect(const wxRect& rect);
105e45b9	356	#ifdef __WXMSW__
b639c3c5	357	bool IsEmpty();
105e45b9	358	#endif
b639c3c5 RD	359	bool Subtract(const wxRect& rect);
	360	bool Union(const wxRect& rect);
	361	bool Xor(const wxRect& rect);
	362	};
	363
	364
	365
	366	class wxRegionIterator {
	367	public:
	368	wxRegionIterator(const wxRegion& region);
	369	~wxRegionIterator();
	370
	371	long GetX();
	372	long GetY();
	373	long GetW();
	374	long GetWidth();
	375	long GetH();
	376	long GetHeight();
	377	wxRect GetRect();
	378	bool HaveRects();
	379	void Reset();
	380
	381	%addmethods {
	382	void Next() {
	383	(*self) ++;
	384	}
	385	};
	386	};
	387
	388
	389
7bf85405 RD	390	//---------------------------------------------------------------------------
	391	// Accelerator Entry and Table
	392
	393	class wxAcceleratorEntry {
	394	public:
	395	wxAcceleratorEntry(int flags = 0, int keyCode = 0, int cmd = 0);
2f90df85	396	~wxAcceleratorEntry();
7bf85405 RD	397
	398	void Set(int flags, int keyCode, int Cmd);
	399	int GetFlags();
	400	int GetKeyCode();
	401	int GetCommand();
	402	};
	403
	404
	405	class wxAcceleratorTable {
	406	public:
	407	// Can also accept a list of 3-tuples
	408	wxAcceleratorTable(int LCOUNT, wxAcceleratorEntry* LIST);
2f90df85	409	~wxAcceleratorTable();
7bf85405 RD	410
7bf85405 RD	411	};
faf3cb35	412
af309447	413	//---------------------------------------------------------------------------
8bf5d46e RD	414
	415	enum {
	416	wxSYS_WHITE_BRUSH,
	417	wxSYS_LTGRAY_BRUSH,
	418	wxSYS_GRAY_BRUSH,
	419	wxSYS_DKGRAY_BRUSH,
	420	wxSYS_BLACK_BRUSH,
	421	wxSYS_NULL_BRUSH,
	422	wxSYS_HOLLOW_BRUSH,
	423	wxSYS_WHITE_PEN,
	424	wxSYS_BLACK_PEN,
	425	wxSYS_NULL_PEN,
	426	wxSYS_OEM_FIXED_FONT,
	427	wxSYS_ANSI_FIXED_FONT,
	428	wxSYS_ANSI_VAR_FONT,
	429	wxSYS_SYSTEM_FONT,
	430	wxSYS_DEVICE_DEFAULT_FONT,
	431	wxSYS_DEFAULT_PALETTE,
	432	wxSYS_SYSTEM_FIXED_FONT,
	433	wxSYS_DEFAULT_GUI_FONT,
	434
	435	wxSYS_COLOUR_SCROLLBAR,
	436	wxSYS_COLOUR_BACKGROUND,
	437	wxSYS_COLOUR_ACTIVECAPTION,
	438	wxSYS_COLOUR_INACTIVECAPTION,
	439	wxSYS_COLOUR_MENU,
	440	wxSYS_COLOUR_WINDOW,
	441	wxSYS_COLOUR_WINDOWFRAME,
	442	wxSYS_COLOUR_MENUTEXT,
	443	wxSYS_COLOUR_WINDOWTEXT,
	444	wxSYS_COLOUR_CAPTIONTEXT,
	445	wxSYS_COLOUR_ACTIVEBORDER,
	446	wxSYS_COLOUR_INACTIVEBORDER,
	447	wxSYS_COLOUR_APPWORKSPACE,
	448	wxSYS_COLOUR_HIGHLIGHT,
	449	wxSYS_COLOUR_HIGHLIGHTTEXT,
	450	wxSYS_COLOUR_BTNFACE,
	451	wxSYS_COLOUR_BTNSHADOW,
	452	wxSYS_COLOUR_GRAYTEXT,
	453	wxSYS_COLOUR_BTNTEXT,
	454	wxSYS_COLOUR_INACTIVECAPTIONTEXT,
	455	wxSYS_COLOUR_BTNHIGHLIGHT,
	456
	457	wxSYS_COLOUR_3DDKSHADOW,
	458	wxSYS_COLOUR_3DLIGHT,
	459	wxSYS_COLOUR_INFOTEXT,
	460	wxSYS_COLOUR_INFOBK,
	461
	462	wxSYS_COLOUR_DESKTOP,
	463	wxSYS_COLOUR_3DFACE,
	464	wxSYS_COLOUR_3DSHADOW,
	465	wxSYS_COLOUR_3DHIGHLIGHT,
	466	wxSYS_COLOUR_3DHILIGHT,
	467	wxSYS_COLOUR_BTNHILIGHT,
	468
	469	wxSYS_MOUSE_BUTTONS,
	470	wxSYS_BORDER_X,
	471	wxSYS_BORDER_Y,
	472	wxSYS_CURSOR_X,
	473	wxSYS_CURSOR_Y,
	474	wxSYS_DCLICK_X,
	475	wxSYS_DCLICK_Y,
	476	wxSYS_DRAG_X,
	477	wxSYS_DRAG_Y,
478	wxSYS_EDGE_X,
479	wxSYS_EDGE_Y,
480	wxSYS_HSCROLL_ARROW_X,
481	wxSYS_HSCROLL_ARROW_Y,
482	wxSYS_HTHUMB_X,
483	wxSYS_ICON_X,
484	wxSYS_ICON_Y,
485	wxSYS_ICONSPACING_X,
486	wxSYS_ICONSPACING_Y,
487	wxSYS_WINDOWMIN_X,
488	wxSYS_WINDOWMIN_Y,
489	wxSYS_SCREEN_X,
490	wxSYS_SCREEN_Y,
491	wxSYS_FRAMESIZE_X,
492	wxSYS_FRAMESIZE_Y,
493	wxSYS_SMALLICON_X,
494	wxSYS_SMALLICON_Y,
495	wxSYS_HSCROLL_Y,
496	wxSYS_VSCROLL_X,
497	wxSYS_VSCROLL_ARROW_X,
498	wxSYS_VSCROLL_ARROW_Y,
499	wxSYS_VTHUMB_Y,
500	wxSYS_CAPTION_Y,
501	wxSYS_MENU_Y,
502	wxSYS_NETWORK_PRESENT,
503	wxSYS_PENWINDOWS_PRESENT,
504	wxSYS_SHOW_SOUNDS,
505	wxSYS_SWAP_BUTTONS,
506	};
507
508
509
510	%inline %{
511
512	wxColour wxSystemSettings_GetSystemColour(int index) {
513	return wxSystemSettings::GetSystemColour(index);
514	}
515
516	wxFont wxSystemSettings_GetSystemFont(int index) {
517	return wxSystemSettings::GetSystemFont(index);
518	}
519
520	int wxSystemSettings_GetSystemMetric(int index) {
521	return wxSystemSettings::GetSystemMetric(index);
522	}
523	%}
524
525	//---------------------------------------------------------------------------
526	//---------------------------------------------------------------------------
527
528