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 <wx/busyinfo.h>
%}

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

%include typemaps.i
%include my_typemaps.i

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


//---------------------------------------------------------------------------
%{
    // Put some wx default wxChar* values into wxStrings.
    static const wxString wxPyEmptyString(wxT(""));
%}
//---------------------------------------------------------------------------


class wxObject {
public:

    %addmethods {
        wxString GetClassName() {
            return self->GetClassInfo()->GetClassName();
        }

        void Destroy() {
            delete self;
        }
    }
};

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

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() {
            wxPyBeginBlockThreads();
            PyObject* tup = PyTuple_New(2);
            PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
            PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
            wxPyEndBlockThreads();
            return tup;
        }

        int __cmp__(const wxSize* sz) {
            if (! sz) return 1;
            if (*self == *sz) return 0;
            return -1;
        }
    }

    %pragma(python) addtoclass = "
    def __str__(self):                   return str(self.asTuple())
    def __repr__(self):                  return str(self.asTuple())
    def __len__(self):                   return len(self.asTuple())
    def __getitem__(self, index):        return self.asTuple()[index]
    def __setitem__(self, index, val):
        if index == 0: self.width = val
        elif index == 1: self.height = val
        else: raise IndexError
"

};

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

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() {
            wxPyBeginBlockThreads();
            PyObject* tup = PyTuple_New(2);
            PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->x));
            PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->y));
            wxPyEndBlockThreads();
            return tup;
        }

        wxRealPoint __add__(const wxRealPoint* p) {
            if (! p) return *self;
            return *self + *p;
        }

        wxRealPoint __sub__(const wxRealPoint* p) {
            if (! p) return *self;
            return *self - *p;
        }

        int __cmp__(const wxRealPoint* p) {
            if (! p) return 1;
            if (*self == *p) return 0;
            return -1;
        }
    }
    %pragma(python) addtoclass = "
    def __str__(self):                   return str(self.asTuple())
    def __repr__(self):                  return str(self.asTuple())
    def __len__(self):                   return len(self.asTuple())
    def __getitem__(self, index):        return self.asTuple()[index]
    def __setitem__(self, index, val):
        if index == 0: self.width = val
        elif index == 1: self.height = val
        else: raise IndexError
"
};


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() {
            wxPyBeginBlockThreads();
            PyObject* tup = PyTuple_New(2);
            PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
            PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
            wxPyEndBlockThreads();
            return tup;
        }

        wxPoint __add__(const wxPoint* p) {
            if (! p) return *self;
            return *self + *p;
        }

        wxPoint __sub__(const wxPoint* p) {
            if (! p) return *self;
            return *self - *p;
        }

        int __cmp__(const wxPoint* p) {
            if (! p) return 1;
            if (*self == *p) return 0;
            return -1;
        }
    }
    %pragma(python) addtoclass = "
    def __str__(self):                   return str(self.asTuple())
    def __repr__(self):                  return str(self.asTuple())
    def __len__(self):                   return len(self.asTuple())
    def __getitem__(self, index):        return self.asTuple()[index]
    def __setitem__(self, index, val):
        if index == 0: self.x = val
        elif index == 1: self.y = val
        else: raise IndexError
"
};

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

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

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


    wxPoint GetPosition();
    wxSize GetSize();
    void SetPosition( const wxPoint &p );
    void SetSize( const wxSize &s );

    int  GetLeft();
    int  GetTop();
    int  GetBottom();
    int  GetRight();

    void SetLeft(int left);
    void SetRight(int right);
    void SetTop(int top);
    void SetBottom(int bottom);

    void Inflate(int dx, int dy);
    bool Inside(int cx, int cy);

    int x, y, width, height;

    %addmethods {
        PyObject* asTuple() {
            wxPyBeginBlockThreads();
            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));
            wxPyEndBlockThreads();
            return tup;
        }

        wxRect __add__(const wxRect* rect) {
            if (! rect) return *self;
            return *self + *rect;
        }

        int __cmp__(const wxRect* rect) {
            if (! rect) return 1;
            if (*self == *rect) return 0;
            return -1;
        }
    }

    %pragma(python) addtoclass = "
    def __str__(self):                   return str(self.asTuple())
    def __repr__(self):                  return str(self.asTuple())
    def __len__(self):                   return len(self.asTuple())
    def __getitem__(self, index):        return self.asTuple()[index]
    def __setitem__(self, index, val):
        if index == 0: self.x = val
        elif index == 1: self.y = val
        elif index == 2: self.width = val
        elif index == 3: self.height = val
        else: raise IndexError

    # override the __getattr__ made by SWIG
    def __getattr__(self, name):
        d = {
            'x' : miscc.wxRect_x_get,
            'y' : miscc.wxRect_y_get,
            'width' : miscc.wxRect_width_get,
            'height' : miscc.wxRect_height_get,
            'top' : miscc.wxRect_GetTop,
            'bottom' : miscc.wxRect_GetBottom,
            'left' : miscc.wxRect_GetLeft,
            'right' : miscc.wxRect_GetRight,
            }
        try:
            func = d[name]
        except KeyError:
            raise AttributeError,name
        return func(self)

    # and also the __setattr__
    def __setattr__(self, name, value):
        d = {
            'x' : miscc.wxRect_x_set,
            'y' : miscc.wxRect_y_set,
            'width' : miscc.wxRect_width_set,
            'height' : miscc.wxRect_height_set,
            'top' : miscc.wxRect_SetTop,
            'bottom' : miscc.wxRect_SetBottom,
            'left' : miscc.wxRect_SetLeft,
            'right' : miscc.wxRect_SetRight,
            }
        try:
            func = d[name]
        except KeyError:
            self.__dict__[name] = value
            return
        func(self, value)
    "

};


%inline %{
    PyObject* wxIntersectRect(wxRect* r1, wxRect* r2) {
        wxRegion  reg1(*r1);
        wxRegion  reg2(*r2);
        wxRect    dest(0,0,0,0);
        PyObject* obj;

        reg1.Intersect(reg2);
        dest = reg1.GetBox();

        if (dest != wxRect(0,0,0,0)) {
            wxPyBeginBlockThreads();
            wxRect* newRect = new wxRect(dest);
            obj = wxPyConstructObject((void*)newRect, "wxRect");
            PyObject* one = PyInt_FromLong(1);
            PyObject_SetAttrString(obj, "thisown", one);
            Py_DECREF(one);
            wxPyEndBlockThreads();
            return obj;
        }
        Py_INCREF(Py_None);
        return Py_None;
    }
%}


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

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

void wxBell();
void wxEndBusyCursor();

long wxGetElapsedTime(bool resetTimer = TRUE);
#ifdef __WXMSW__
long wxGetFreeMemory();
#endif
void wxGetMousePosition(int* OUTPUT, int* OUTPUT);
bool wxIsBusy();
wxString wxNow();
bool wxShell(const wxString& command = wxPyEmptyString);
void wxStartTimer();
int wxGetOsVersion(int *OUTPUT, int *OUTPUT);
wxString wxGetOsDescription();

enum wxShutdownFlags
{
    wxSHUTDOWN_POWEROFF,    // power off the computer
    wxSHUTDOWN_REBOOT       // shutdown and reboot
};

// Shutdown or reboot the PC
bool wxShutdown(wxShutdownFlags wFlags);


void wxSleep(int secs);
void wxUsleep(unsigned long milliseconds);
bool wxYield();
bool wxYieldIfNeeded();
void wxEnableTopLevelWindows(bool enable);

%inline %{
    wxString wxGetResource(const wxString& section, const wxString& entry,
                           const wxString& file = wxPyEmptyString) {
        wxChar * retval;
        wxGetResource(section, entry, &retval, file);
        return retval;
    }
%}

wxString wxStripMenuCodes(const wxString& in);


wxString wxGetEmailAddress();
wxString wxGetHostName();
wxString wxGetFullHostName();
wxString wxGetUserId();
wxString wxGetUserName();
wxString wxGetHomeDir();
wxString wxGetUserHome(const wxString& user = wxPyEmptyString);

unsigned long wxGetProcessId();

// When wxApp gets the virtual method magic then enable this.
// bool wxHandleFatalExceptions(bool doIt = TRUE);

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

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 wxObject {
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 wxObject {
public:
    wxLayoutConstraints();

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


//---------------------------------------------------------------------------
// 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 wxObject {
public:
    // Can also accept a list of 3-tuples
    wxAcceleratorTable(int LCOUNT, wxAcceleratorEntry* choices);
    ~wxAcceleratorTable();

};

wxAcceleratorEntry *wxGetAccelFromString(const wxString& label);

%readonly
%{
#if 0  // we want to use the definition from the header, not the
       // one SWIG will generate.
%}
extern wxAcceleratorTable wxNullAcceleratorTable;
%{
#endif
%}
%readwrite

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

class wxBusyInfo : public wxObject {
public:
    wxBusyInfo(const wxString& message);
    ~wxBusyInfo();
};


//---------------------------------------------------------------------------
Commit	Line	Data
	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
	13	%module misc
	14
	15	%{
	16	#include "helpers.h"
	17	#include <wx/resource.h>
	18	#include <wx/tooltip.h>
	19	#include <wx/busyinfo.h>
	20	%}
	21
	22	//----------------------------------------------------------------------
	23
	24	%include typemaps.i
	25	%include my_typemaps.i
	26
	27	// Import some definitions of other classes, etc.
	28	%import _defs.i
	29
	30
	31	//---------------------------------------------------------------------------
	32	%{
	33	// Put some wx default wxChar* values into wxStrings.
	34	static const wxString wxPyEmptyString(wxT(""));
	35	%}
	36	//---------------------------------------------------------------------------
	37
	38
	39	class wxObject {
	40	public:
	41
	42	%addmethods {
	43	wxString GetClassName() {
	44	return self->GetClassInfo()->GetClassName();
	45	}
	46
	47	void Destroy() {
	48	delete self;
	49	}
	50	}
	51	};
	52
	53	//---------------------------------------------------------------------------
	54
	55	class wxSize {
	56	public:
	57	long x;
	58	long y;
	59	%name(width) long x;
	60	%name(height)long y;
	61
	62	wxSize(long w=0, long h=0);
	63	~wxSize();
	64	void Set(long w, long h);
	65	long GetX();
	66	long GetY();
	67	long GetWidth();
	68	long GetHeight();
	69	void SetWidth(long w);
	70	void SetHeight(long h);
	71
	72	%addmethods {
	73	PyObject* asTuple() {
	74	wxPyBeginBlockThreads();
	75	PyObject* tup = PyTuple_New(2);
	76	PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
	77	PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
	78	wxPyEndBlockThreads();
	79	return tup;
	80	}
	81
	82	int __cmp__(const wxSize* sz) {
	83	if (! sz) return 1;
	84	if (self == sz) return 0;
	85	return -1;
	86	}
	87	}
	88
	89	%pragma(python) addtoclass = "
	90	def __str__(self): return str(self.asTuple())
	91	def __repr__(self): return str(self.asTuple())
	92	def __len__(self): return len(self.asTuple())
	93	def __getitem__(self, index): return self.asTuple()[index]
	94	def __setitem__(self, index, val):
	95	if index == 0: self.width = val
	96	elif index == 1: self.height = val
	97	else: raise IndexError
	98	"
	99
	100	};
	101
	102	//---------------------------------------------------------------------------
	103
	104	class wxRealPoint {
	105	public:
	106	double x;
	107	double y;
	108	wxRealPoint(double x=0.0, double y=0.0);
	109	~wxRealPoint();
	110
	111	%addmethods {
	112	void Set(double x, double y) {
	113	self->x = x;
	114	self->y = y;
	115	}
	116	PyObject* asTuple() {
	117	wxPyBeginBlockThreads();
	118	PyObject* tup = PyTuple_New(2);
	119	PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->x));
	120	PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->y));
	121	wxPyEndBlockThreads();
	122	return tup;
	123	}
	124
	125	wxRealPoint __add__(const wxRealPoint* p) {
	126	if (! p) return *self;
	127	return self + p;
	128	}
	129
	130	wxRealPoint __sub__(const wxRealPoint* p) {
	131	if (! p) return *self;
	132	return self - p;
	133	}
	134
	135	int __cmp__(const wxRealPoint* p) {
	136	if (! p) return 1;
	137	if (self == p) return 0;
	138	return -1;
	139	}
	140	}
	141	%pragma(python) addtoclass = "
	142	def __str__(self): return str(self.asTuple())
	143	def __repr__(self): return str(self.asTuple())
	144	def __len__(self): return len(self.asTuple())
	145	def __getitem__(self, index): return self.asTuple()[index]
	146	def __setitem__(self, index, val):
	147	if index == 0: self.width = val
	148	elif index == 1: self.height = val
	149	else: raise IndexError
	150	"
	151	};
	152
	153
	154	class wxPoint {
	155	public:
	156	long x;
	157	long y;
	158	wxPoint(long x=0, long y=0);
	159	~wxPoint();
	160
	161	%addmethods {
	162	void Set(long x, long y) {
	163	self->x = x;
	164	self->y = y;
	165	}
	166	PyObject* asTuple() {
	167	wxPyBeginBlockThreads();
	168	PyObject* tup = PyTuple_New(2);
	169	PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
	170	PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
	171	wxPyEndBlockThreads();
	172	return tup;
	173	}
	174
	175	wxPoint __add__(const wxPoint* p) {
	176	if (! p) return *self;
	177	return self + p;
	178	}
	179
	180	wxPoint __sub__(const wxPoint* p) {
	181	if (! p) return *self;
	182	return self - p;
	183	}
	184
	185	int __cmp__(const wxPoint* p) {
	186	if (! p) return 1;
	187	if (self == p) return 0;
	188	return -1;
	189	}
	190	}
	191	%pragma(python) addtoclass = "
	192	def __str__(self): return str(self.asTuple())
	193	def __repr__(self): return str(self.asTuple())
	194	def __len__(self): return len(self.asTuple())
	195	def __getitem__(self, index): return self.asTuple()[index]
	196	def __setitem__(self, index, val):
	197	if index == 0: self.x = val
	198	elif index == 1: self.y = val
	199	else: raise IndexError
	200	"
	201	};
	202
	203	//---------------------------------------------------------------------------
	204
	205	class wxRect {
	206	public:
	207	wxRect(int x=0, int y=0, int w=0, int h=0);
	208	// TODO: do this one too... wxRect(const wxPoint& pos, const wxSize& size);
	209	~wxRect();
	210
	211	int GetX();
	212	void SetX(int X);
	213	int GetY();
	214	void SetY(int Y);
	215	int GetWidth();
	216	void SetWidth(int w);
	217	int GetHeight();
	218	void SetHeight(int h);
	219
	220
	221	wxPoint GetPosition();
	222	wxSize GetSize();
	223	void SetPosition( const wxPoint &p );
	224	void SetSize( const wxSize &s );
	225
	226	int GetLeft();
	227	int GetTop();
	228	int GetBottom();
	229	int GetRight();
	230
	231	void SetLeft(int left);
	232	void SetRight(int right);
	233	void SetTop(int top);
	234	void SetBottom(int bottom);
	235
	236	void Inflate(int dx, int dy);
	237	bool Inside(int cx, int cy);
	238
	239	int x, y, width, height;
	240
	241	%addmethods {
	242	PyObject* asTuple() {
	243	wxPyBeginBlockThreads();
	244	PyObject* tup = PyTuple_New(4);
	245	PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
	246	PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
	247	PyTuple_SET_ITEM(tup, 2, PyInt_FromLong(self->width));
	248	PyTuple_SET_ITEM(tup, 3, PyInt_FromLong(self->height));
	249	wxPyEndBlockThreads();
	250	return tup;
	251	}
	252
	253	wxRect __add__(const wxRect* rect) {
	254	if (! rect) return *self;
	255	return self + rect;
	256	}
	257
	258	int __cmp__(const wxRect* rect) {
	259	if (! rect) return 1;
	260	if (self == rect) return 0;
	261	return -1;
	262	}
	263	}
	264
	265	%pragma(python) addtoclass = "
	266	def __str__(self): return str(self.asTuple())
	267	def __repr__(self): return str(self.asTuple())
	268	def __len__(self): return len(self.asTuple())
	269	def __getitem__(self, index): return self.asTuple()[index]
	270	def __setitem__(self, index, val):
	271	if index == 0: self.x = val
	272	elif index == 1: self.y = val
	273	elif index == 2: self.width = val
	274	elif index == 3: self.height = val
	275	else: raise IndexError
	276
	277	# override the __getattr__ made by SWIG
	278	def __getattr__(self, name):
	279	d = {
	280	'x' : miscc.wxRect_x_get,
	281	'y' : miscc.wxRect_y_get,
	282	'width' : miscc.wxRect_width_get,
	283	'height' : miscc.wxRect_height_get,
	284	'top' : miscc.wxRect_GetTop,
	285	'bottom' : miscc.wxRect_GetBottom,
	286	'left' : miscc.wxRect_GetLeft,
	287	'right' : miscc.wxRect_GetRight,
	288	}
	289	try:
	290	func = d[name]
	291	except KeyError:
	292	raise AttributeError,name
	293	return func(self)
	294
	295	# and also the __setattr__
	296	def __setattr__(self, name, value):
	297	d = {
	298	'x' : miscc.wxRect_x_set,
	299	'y' : miscc.wxRect_y_set,
	300	'width' : miscc.wxRect_width_set,
	301	'height' : miscc.wxRect_height_set,
	302	'top' : miscc.wxRect_SetTop,
	303	'bottom' : miscc.wxRect_SetBottom,
	304	'left' : miscc.wxRect_SetLeft,
	305	'right' : miscc.wxRect_SetRight,
	306	}
	307	try:
	308	func = d[name]
	309	except KeyError:
	310	self.__dict__[name] = value
	311	return
	312	func(self, value)
	313	"
	314
	315	};
	316
	317
	318	%inline %{
	319	PyObject* wxIntersectRect(wxRect* r1, wxRect* r2) {
	320	wxRegion reg1(*r1);
	321	wxRegion reg2(*r2);
	322	wxRect dest(0,0,0,0);
	323	PyObject* obj;
	324
	325	reg1.Intersect(reg2);
	326	dest = reg1.GetBox();
	327
	328	if (dest != wxRect(0,0,0,0)) {
	329	wxPyBeginBlockThreads();
	330	wxRect* newRect = new wxRect(dest);
	331	obj = wxPyConstructObject((void*)newRect, "wxRect");
	332	PyObject* one = PyInt_FromLong(1);
	333	PyObject_SetAttrString(obj, "thisown", one);
	334	Py_DECREF(one);
	335	wxPyEndBlockThreads();
	336	return obj;
	337	}
	338	Py_INCREF(Py_None);
	339	return Py_None;
	340	}
	341	%}
	342
	343
	344	//---------------------------------------------------------------------------
	345	// Miscellaneous functions
	346
	347	long wxNewId();
	348	void wxRegisterId(long id);
	349	%name(NewId) long wxNewId();
	350	%name(RegisterId) void wxRegisterId(long id);
	351	long wxGetCurrentId();
	352
	353	void wxBell();
	354	void wxEndBusyCursor();
	355
	356	long wxGetElapsedTime(bool resetTimer = TRUE);
	357	#ifdef __WXMSW__
	358	long wxGetFreeMemory();
	359	#endif
	360	void wxGetMousePosition(int* OUTPUT, int* OUTPUT);
	361	bool wxIsBusy();
	362	wxString wxNow();
	363	bool wxShell(const wxString& command = wxPyEmptyString);
	364	void wxStartTimer();
	365	int wxGetOsVersion(int OUTPUT, int OUTPUT);
	366	wxString wxGetOsDescription();
	367
	368	enum wxShutdownFlags
	369	{
	370	wxSHUTDOWN_POWEROFF, // power off the computer
	371	wxSHUTDOWN_REBOOT // shutdown and reboot
	372	};
	373
	374	// Shutdown or reboot the PC
	375	bool wxShutdown(wxShutdownFlags wFlags);
	376
	377
	378	void wxSleep(int secs);
	379	void wxUsleep(unsigned long milliseconds);
	380	bool wxYield();
	381	bool wxYieldIfNeeded();
	382	void wxEnableTopLevelWindows(bool enable);
	383
	384	%inline %{
	385	wxString wxGetResource(const wxString& section, const wxString& entry,
	386	const wxString& file = wxPyEmptyString) {
	387	wxChar * retval;
	388	wxGetResource(section, entry, &retval, file);
	389	return retval;
	390	}
	391	%}
	392
	393	wxString wxStripMenuCodes(const wxString& in);
	394
	395
	396	wxString wxGetEmailAddress();
	397	wxString wxGetHostName();
	398	wxString wxGetFullHostName();
	399	wxString wxGetUserId();
	400	wxString wxGetUserName();
	401	wxString wxGetHomeDir();
	402	wxString wxGetUserHome(const wxString& user = wxPyEmptyString);
	403
	404	unsigned long wxGetProcessId();
	405
	406	// When wxApp gets the virtual method magic then enable this.
	407	// bool wxHandleFatalExceptions(bool doIt = TRUE);
	408
	409	//----------------------------------------------------------------------
	410
	411	enum wxEdge { wxLeft, wxTop, wxRight, wxBottom, wxWidth, wxHeight,
	412	wxCentre, wxCenter = wxCentre, wxCentreX, wxCentreY };
	413	enum wxRelationship { wxUnconstrained = 0,
	414	wxAsIs,
	415	wxPercentOf,
	416	wxAbove,
	417	wxBelow,
	418	wxLeftOf,
	419	wxRightOf,
	420	wxSameAs,
	421	wxAbsolute };
	422
	423
	424	class wxIndividualLayoutConstraint : public wxObject {
	425	public:
	426	// wxIndividualLayoutConstraint();
	427	// ~wxIndividualLayoutConstraint();
	428
	429	void Above(wxWindow *otherWin, int margin=0);
	430	void Absolute(int value);
	431	void AsIs();
	432	void Below(wxWindow *otherWin, int margin=0);
	433	void Unconstrained();
	434	void LeftOf(wxWindow *otherWin, int margin=0);
	435	void PercentOf(wxWindow *otherWin, wxEdge edge, int percent);
	436	void RightOf(wxWindow *otherWin, int margin=0);
	437	void SameAs(wxWindow *otherWin, wxEdge edge, int margin=0);
	438	void Set(wxRelationship rel, wxWindow *otherWin, wxEdge otherEdge, int value=0, int margin=0);
	439	};
	440
	441
	442	class wxLayoutConstraints : public wxObject {
	443	public:
	444	wxLayoutConstraints();
	445
	446	%readonly
	447	wxIndividualLayoutConstraint bottom;
	448	wxIndividualLayoutConstraint centreX;
	449	wxIndividualLayoutConstraint centreY;
	450	wxIndividualLayoutConstraint height;
	451	wxIndividualLayoutConstraint left;
	452	wxIndividualLayoutConstraint right;
	453	wxIndividualLayoutConstraint top;
	454	wxIndividualLayoutConstraint width;
	455	%readwrite
	456	}
	457
	458
	459
	460	//---------------------------------------------------------------------------
	461	// Accelerator Entry and Table
	462
	463	class wxAcceleratorEntry {
	464	public:
	465	wxAcceleratorEntry(int flags = 0, int keyCode = 0, int cmd = 0);
	466	~wxAcceleratorEntry();
	467
	468	void Set(int flags, int keyCode, int Cmd);
	469	int GetFlags();
	470	int GetKeyCode();
	471	int GetCommand();
	472	};
	473
	474
	475	class wxAcceleratorTable : public wxObject {
	476	public:
	477	// Can also accept a list of 3-tuples
	478	wxAcceleratorTable(int LCOUNT, wxAcceleratorEntry* choices);
	479	~wxAcceleratorTable();
	480
	481	};
	482
	483	wxAcceleratorEntry *wxGetAccelFromString(const wxString& label);
	484
	485	%readonly
	486	%{
	487	#if 0 // we want to use the definition from the header, not the
	488	// one SWIG will generate.
	489	%}
	490	extern wxAcceleratorTable wxNullAcceleratorTable;
	491	%{
	492	#endif
	493	%}
	494	%readwrite
	495
	496	//---------------------------------------------------------------------------
	497
	498	class wxBusyInfo : public wxObject {
	499	public:
	500	wxBusyInfo(const wxString& message);
	501	~wxBusyInfo();
	502	};
	503
	504
	505	//---------------------------------------------------------------------------
	506
	507
	508