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

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, 0, PyInt_FromLong(self->width));
            PyTuple_SET_ITEM(tup, 1, 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);

//---------------------------------------------------------------------------
// 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);
    // ~wxAcceleratorEntry(); *** ?

};

//---------------------------------------------------------------------------
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();
	71	};
	72
	73	class wxPoint {
	74	public:
	75	long x;
	76	long y;
	77	wxPoint(long x=0, long y=0);
	78	~wxPoint();
	79
	80	%addmethods {
	81	void Set(long x, long y) {
	82	self->x = x;
	83	self->y = y;
	84	}
af309447	85	PyObject* asTuple() {
7bf85405 RD	86	PyObject* tup = PyTuple_New(2);
	87	PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
	88	PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
	89	return tup;
	90	}
	91	}
af309447 RD	92	%pragma(python) addtoclass = "def __str__(self): return str(self.asTuple())"
af309447 RD	93	%pragma(python) addtoclass = "def __repr__(self): return str(self.asTuple())"
7bf85405 RD	94	};
	95
	96	//---------------------------------------------------------------------------
	97
	98	class wxRect {
	99	public:
	100	wxRect(long x=0, long y=0, long w=0, long h=0);
	101	// TODO: do this one too... wxRect(const wxPoint& pos, const wxSize& size);
	102	~wxRect();
	103
	104	long GetX();
	105	void SetX(long X);
	106	long GetY();
	107	void SetY(long Y);
	108	long GetWidth();
	109	void SetWidth(long w);
	110	long GetHeight();
	111	void SetHeight(long h);
	112
	113
	114	wxPoint GetPosition();
	115	wxSize GetSize();
	116
	117	long GetLeft();
	118	long GetTop();
	119	long GetBottom();
	120	long GetRight();
	121
	122	long x, y, width, height;
af309447 RD	123
	124	%addmethods {
	125	PyObject* asTuple() {
	126	PyObject* tup = PyTuple_New(4);
	127	PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
	128	PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
	129	PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->width));
	130	PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->height));
	131	return tup;
	132	}
	133	}
	134	%pragma(python) addtoclass = "def __str__(self): return str(self.asTuple())"
	135	%pragma(python) addtoclass = "def __repr__(self): return str(self.asTuple())"
7bf85405 RD	136	};
	137
	138
	139
	140	//---------------------------------------------------------------------------
	141	// Dialog Functions
	142
08127323	143	wxString wxFileSelector(char* message,
7bf85405 RD	144	char* default_path = NULL,
	145	char* default_filename = NULL,
	146	char* default_extension = NULL,
	147	char* wildcard = ".",
	148	int flags = 0,
	149	wxWindow *parent = NULL,
	150	int x = -1, int y = -1);
	151
	152	wxString wxGetTextFromUser(const wxString& message,
	153	const wxString& caption = wxPyEmptyStr,
	154	const wxString& default_value = wxPyEmptyStr,
	155	wxWindow *parent = NULL,
	156	int x = -1, int y = -1,
	157	bool centre = TRUE);
	158
d24a34bb	159
7bf85405 RD	160	// TODO: Need to custom wrap this one...
	161	// int wxGetMultipleChoice(char* message, char* caption,
	162	// int LCOUNT, char** LIST,
	163	// int nsel, int *selection,
	164	// wxWindow *parent = NULL, int x = -1, int y = -1,
	165	// bool centre = TRUE, int width=150, int height=200);
	166
	167
	168	wxString wxGetSingleChoice(const wxString& message, const wxString& caption,
	169	int LCOUNT, wxString* LIST,
	170	wxWindow *parent = NULL,
	171	int x = -1, int y = -1,
	172	bool centre = TRUE,
	173	int width=150, int height=200);
	174
	175	int wxGetSingleChoiceIndex(const wxString& message, const wxString& caption,
	176	int LCOUNT, wxString* LIST,
	177	wxWindow *parent = NULL,
	178	int x = -1, int y = -1,
	179	bool centre = TRUE,
	180	int width=150, int height=200);
	181
	182
	183	int wxMessageBox(const wxString& message,
	184	const wxString& caption = wxPyEmptyStr,
	185	int style = wxOK \| wxCENTRE,
	186	wxWindow *parent = NULL,
	187	int x = -1, int y = -1);
	188
	189	//---------------------------------------------------------------------------
	190	// GDI Functions
	191
	192	bool wxColourDisplay();
	193	int wxDisplayDepth();
b8b8dda7	194	void wxSetCursor(wxCursor& cursor);
7bf85405 RD	195
	196	//---------------------------------------------------------------------------
	197	// Miscellaneous functions
	198
cf694132 RD	199	long wxNewId();
	200	void wxRegisterId(long id);
	201	%name(NewId) long wxNewId();
	202	%name(RegisterId) void wxRegisterId(long id);
	203
7bf85405 RD	204	void wxBeginBusyCursor(wxCursor *cursor = wxHOURGLASS_CURSOR);
	205	void wxBell();
	206	void wxDisplaySize(int OUTPUT, int OUTPUT);
	207	void wxEndBusyCursor();
	208	long wxExecute(const wxString& command, bool sync = FALSE);
714e6a9e	209	#ifdef __WXMSW__
7bf85405 RD	210	wxWindow * wxGetActiveWindow();
	211	long wxGetElapsedTime(bool resetTimer = TRUE);
	212	long wxGetFreeMemory();
fb5e0af0	213	#endif
7bf85405 RD	214	void wxGetMousePosition(int* OUTPUT, int* OUTPUT);
	215	bool wxIsBusy();
	216	wxString wxNow();
714e6a9e	217	#ifdef __WXMSW__
fb5e0af0	218	bool wxShell(const wxString& command = wxPyEmptyStr);
7bf85405	219	void wxStartTimer();
fb5e0af0	220	int wxGetOsVersion(int OUTPUT, int OUTPUT);
714e6a9e	221	#endif
fb5e0af0	222
bb0054cd	223	void wxSleep(int secs);
7bf85405	224	bool wxYield();
cf694132	225	bool wxSafeYield();
bb0054cd	226	void wxEnableTopLevelWindows(bool enable);
7bf85405	227
7bf85405 RD	228	%inline %{
	229	char* wxGetResource(char section, char entry, char *file = NULL) {
	230	char * retval;
	231	wxGetResource(section, entry, &retval, file);
	232	return retval;
	233	}
	234	%}
	235
	236	//---------------------------------------------------------------------------
	237	// Resource System
	238
	239	bool wxResourceAddIdentifier(char *name, int value);
	240	void wxResourceClear(void);
d5c9047a RD	241	wxBitmap wxResourceCreateBitmap(char *resource);
d5c9047a RD	242	wxIcon wxResourceCreateIcon(char *resource);
7bf85405 RD	243	wxMenuBar * wxResourceCreateMenuBar(char *resource);
	244	int wxResourceGetIdentifier(char *name);
	245	bool wxResourceParseData(char resource, wxResourceTable table = NULL);
	246	bool wxResourceParseFile(char filename, wxResourceTable table = NULL);
	247	bool wxResourceParseString(char resource, wxResourceTable table = NULL);
	248
	249
	250
	251	//----------------------------------------------------------------------
	252
	253	class wxPyTimer {
	254	public:
	255	wxPyTimer(PyObject* notify);
	256	~wxPyTimer();
	257	int Interval();
	258	void Start(int milliseconds=-1, int oneShot=FALSE);
	259	void Stop();
	260	};
	261
	262	//---------------------------------------------------------------------------
	263
	264	enum wxEdge { wxLeft, wxTop, wxRight, wxBottom, wxWidth, wxHeight,
	265	wxCentre, wxCenter = wxCentre, wxCentreX, wxCentreY };
	266	enum wxRelationship { wxUnconstrained = 0,
	267	wxAsIs,
	268	wxPercentOf,
	269	wxAbove,
	270	wxBelow,
	271	wxLeftOf,
	272	wxRightOf,
	273	wxSameAs,
	274	wxAbsolute };
	275
	276
	277	class wxIndividualLayoutConstraint {
	278	public:
	279	// wxIndividualLayoutConstraint();
	280	// ~wxIndividualLayoutConstraint();
	281
	282	void Above(wxWindow *otherWin, int margin=0);
	283	void Absolute(int value);
08127323	284	void AsIs();
7bf85405	285	void Below(wxWindow *otherWin, int margin=0);
08127323	286	void Unconstrained();
7bf85405 RD	287	void LeftOf(wxWindow *otherWin, int margin=0);
	288	void PercentOf(wxWindow *otherWin, wxEdge edge, int percent);
	289	void RightOf(wxWindow *otherWin, int margin=0);
	290	void SameAs(wxWindow *otherWin, wxEdge edge, int margin=0);
	291	void Set(wxRelationship rel, wxWindow *otherWin, wxEdge otherEdge, int value=0, int margin=0);
	292	};
	293
	294
	295	class wxLayoutConstraints {
	296	public:
	297	wxLayoutConstraints();
	298
	299	%readonly
	300	wxIndividualLayoutConstraint bottom;
	301	wxIndividualLayoutConstraint centreX;
	302	wxIndividualLayoutConstraint centreY;
	303	wxIndividualLayoutConstraint height;
	304	wxIndividualLayoutConstraint left;
	305	wxIndividualLayoutConstraint right;
	306	wxIndividualLayoutConstraint top;
	307	wxIndividualLayoutConstraint width;
	308	%readwrite
	309	}
	310
	311
b639c3c5 RD	312	//---------------------------------------------------------------------------
	313	// Regions, etc.
	314
	315	enum wxRegionContain {
	316	wxOutRegion, wxPartRegion, wxInRegion
	317	};
	318
	319
	320	class wxRegion {
	321	public:
	322	wxRegion();
	323	~wxRegion();
	324
	325	void Clear();
	326	wxRegionContain Contains(long x, long y);
	327	%name(ContainsPoint)wxRegionContain Contains(const wxPoint& pt);
	328	%name(ContainsRect)wxRegionContain Contains(const wxRect& rect);
	329
	330	wxRect GetBox();
	331	bool Intersect(const wxRect& rect);
105e45b9	332	#ifdef __WXMSW__
b639c3c5	333	bool IsEmpty();
105e45b9	334	#endif
b639c3c5 RD	335	bool Subtract(const wxRect& rect);
	336	bool Union(const wxRect& rect);
	337	bool Xor(const wxRect& rect);
	338	};
	339
	340
	341
	342	class wxRegionIterator {
	343	public:
	344	wxRegionIterator(const wxRegion& region);
	345	~wxRegionIterator();
	346
	347	long GetX();
	348	long GetY();
	349	long GetW();
	350	long GetWidth();
	351	long GetH();
	352	long GetHeight();
	353	wxRect GetRect();
	354	bool HaveRects();
	355	void Reset();
	356
	357	%addmethods {
	358	void Next() {
	359	(*self) ++;
	360	}
	361	};
	362	};
	363
	364
	365
7bf85405 RD	366	//---------------------------------------------------------------------------
	367	// Accelerator Entry and Table
	368
	369	class wxAcceleratorEntry {
	370	public:
	371	wxAcceleratorEntry(int flags = 0, int keyCode = 0, int cmd = 0);
	372	//~wxAcceleratorEntry(); *** ?
	373
	374	void Set(int flags, int keyCode, int Cmd);
	375	int GetFlags();
	376	int GetKeyCode();
	377	int GetCommand();
	378	};
	379
	380
	381	class wxAcceleratorTable {
	382	public:
	383	// Can also accept a list of 3-tuples
	384	wxAcceleratorTable(int LCOUNT, wxAcceleratorEntry* LIST);
	385	// ~wxAcceleratorEntry(); *** ?
	386
	387	};
faf3cb35	388
af309447	389	//---------------------------------------------------------------------------