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


%{
    static wxString wxPyEmptyStr("");
%}

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


class wxObject {
public:

    %addmethods {
        const char* 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() {
            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())
    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() {
            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;
        }

        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 0;
            return *self == *p;
        }
    }
    %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() {
            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;
        }

        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 0;
            return *self == *p;
        }
    }
    %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();

    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() {
            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;
        }

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

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

    %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)) {
            bool doSave = wxPyRestoreThread();
            wxRect* newRect = new wxRect(dest);
            obj = wxPyConstructObject((void*)newRect, "wxRect");
            PyObject* one = PyInt_FromLong(1);
            PyObject_SetAttrString(obj, "thisown", one);
            Py_DECREF(one);
            wxPySaveThread(doSave);
            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 = wxPyEmptyStr);
void wxStartTimer();
int wxGetOsVersion(int *OUTPUT, int *OUTPUT);
wxString wxGetOsDescription();

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

%inline %{
    char* wxGetResource(char *section, char *entry, char *file = NULL) {
        char * 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();


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

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