[wxWidgets.git] / wxPython / src / _functions.i

/////////////////////////////////////////////////////////////////////////////
// Name:        _functions.i
// Purpose:     SWIG interface defs for various functions and such
//
// Author:      Robin Dunn
//
// Created:     3-July-1997
// RCS-ID:      $Id$
// Copyright:   (c) 2003 by Total Control Software
// Licence:     wxWindows license
/////////////////////////////////////////////////////////////////////////////

// Not a %module


%{
#include <wx/stockitem.h>
%}

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

MAKE_CONST_WXSTRING(FileSelectorPromptStr);
MAKE_CONST_WXSTRING(FileSelectorDefaultWildcardStr);
MAKE_CONST_WXSTRING(DirSelectorPromptStr);

//---------------------------------------------------------------------------
%newgroup;


long wxNewId();
void wxRegisterId(long id);
long wxGetCurrentId();

// Returns true if the ID is in the list of recognized stock actions
bool wxIsStockID(wxWindowID id);
 
// Returns true of the label is empty or label of a stock button with
// given ID
bool wxIsStockLabel(wxWindowID id, const wxString& label);

// Returns label that should be used for given stock UI element (e.g. "&OK"
// for wxID_OK):
wxString wxGetStockLabel(wxWindowID id,
                         bool withCodes = true,
                         wxString accelerator = wxPyEmptyString);
 

MustHaveApp(wxBell);
void wxBell();

MustHaveApp(wxEndBusyCursor);
void wxEndBusyCursor();

long wxGetElapsedTime(bool resetTimer = true);
%pythoncode { GetElapsedTime = wx._deprecated(GetElapsedTime) }
    
bool wxIsBusy();
wxString wxNow();
bool wxShell(const wxString& command = wxPyEmptyString);
void wxStartTimer();


enum
{
    wxUNKNOWN_PLATFORM,
    wxCURSES,                 /*  Text-only CURSES */
    wxXVIEW_X,                /*  Sun's XView OpenLOOK toolkit */
    wxMOTIF_X,                /*  OSF Motif 1.x.x */
    wxCOSE_X,                 /*  OSF Common Desktop Environment */
    wxNEXTSTEP,               /*  NeXTStep */
    wxMAC,                    /*  Apple Mac OS 8/9/X with Mac paths */
    wxMAC_DARWIN,             /*  Apple Mac OS X with Unix paths */
    wxBEOS,                   /*  BeOS */
    wxGTK,                    /*  GTK on X */
    wxGTK_WIN32,              /*  GTK on Win32 */
    wxGTK_OS2,                /*  GTK on OS/2 */
    wxGTK_BEOS,               /*  GTK on BeOS */
    wxGEOS,                   /*  GEOS */
    wxOS2_PM,                 /*  OS/2 Workplace */
    wxWINDOWS,                /*  Windows or WfW */
    wxMICROWINDOWS,           /*  MicroWindows */
    wxPENWINDOWS,             /*  Windows for Pen Computing */
    wxWINDOWS_NT,             /*  Windows NT */
    wxWIN32S,                 /*  Windows 32S API */
    wxWIN95,                  /*  Windows 95 */
    wxWIN386,                 /*  Watcom 32-bit supervisor modus */
    wxWINDOWS_CE,             /*  Windows CE (generic) */
    wxWINDOWS_POCKETPC,       /*  Windows CE PocketPC */
    wxWINDOWS_SMARTPHONE,     /*  Windows CE Smartphone */
    wxMGL_UNIX,               /*  MGL with direct hardware access */
    wxMGL_X,                  /*  MGL on X */
    wxMGL_WIN32,              /*  MGL on Win32 */
    wxMGL_OS2,                /*  MGL on OS/2 */
    wxMGL_DOS,                /*  MGL on MS-DOS */
    wxWINDOWS_OS2,            /*  Native OS/2 PM */
    wxUNIX,                   /*  wxBase under Unix */
    wxX11,                    /*  Plain X11 and Universal widgets */
    wxPALMOS,                 /*  PalmOS */
    wxDOS                     /*  wxBase under MS-DOS */
};

DocDeclA(
    int, wxGetOsVersion(int *OUTPUT, int *OUTPUT),
    "GetOsVersion() -> (platform, major, minor)");

wxString wxGetOsDescription();

// TODO:
// // Parses the wildCard, returning the number of filters.
// // Returns 0 if none or if there's a problem,
// // The arrays will contain an equal number of items found before the error.
// // wildCard is in the form:
// // "All files (*)|*|Image Files (*.jpeg *.png)|*.jpg;*.png"
// int wxParseCommonDialogsFilter(const wxString& wildCard, wxArrayString& descriptions, wxArrayString& filters);

#if defined(__WXMSW__) || defined(__WXMAC__)
wxMemorySize wxGetFreeMemory();
#else
%inline %{
    wxMemorySize wxGetFreeMemory()
        { wxPyRaiseNotImplemented(); return 0; }
%}
#endif

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

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


void wxSleep(int secs);
void wxMilliSleep(unsigned long milliseconds);
void wxMicroSleep(unsigned long microseconds);
%pythoncode { Usleep = MilliSleep }

void wxEnableTopLevelWindows(bool enable);

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

void wxTrap();


// Dialog Functions

MustHaveApp(wxFileSelector);
wxString wxFileSelector(const wxString& message = wxPyFileSelectorPromptStr,
                        const wxString& default_path = wxPyEmptyString,
                        const wxString& default_filename = wxPyEmptyString,
                        const wxString& default_extension = wxPyEmptyString,
                        const wxString& wildcard = wxPyFileSelectorDefaultWildcardStr,
                        int flags = 0,
                        wxWindow *parent = NULL,
                        int x = -1, int y = -1);

// TODO: wxFileSelectorEx


// Ask for filename to load
MustHaveApp(wxLoadFileSelector);
wxString wxLoadFileSelector(const wxString& what,
                            const wxString& extension,
                            const wxString& default_name = wxPyEmptyString,
                            wxWindow *parent = NULL);

// Ask for filename to save
MustHaveApp(wxSaveFileSelector);
wxString wxSaveFileSelector(const wxString& what,
                            const wxString& extension,
                            const wxString& default_name = wxPyEmptyString,
                            wxWindow *parent = NULL);


MustHaveApp(wxDirSelector);
wxString wxDirSelector(const wxString& message = wxPyDirSelectorPromptStr,
                       const wxString& defaultPath = wxPyEmptyString,
                       long style = wxDD_DEFAULT_STYLE,
                       const wxPoint& pos = wxDefaultPosition,
                       wxWindow *parent = NULL);

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

MustHaveApp(wxGetPasswordFromUser);
wxString wxGetPasswordFromUser(const wxString& message,
                               const wxString& caption = wxPyEmptyString,
                               const wxString& default_value = wxPyEmptyString,
                               wxWindow *parent = NULL);


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


MustHaveApp(wxGetSingleChoice);
wxString wxGetSingleChoice(const wxString& message, const wxString& caption,
                           int choices, wxString* choices_array,
                           wxWindow *parent = NULL,
                           int x = -1, int y = -1,
                           bool centre = true,
                           int width=150, int height=200);

MustHaveApp(wxGetSingleChoiceIndex);
int wxGetSingleChoiceIndex(const wxString& message, const wxString& caption,
                           int choices, wxString* choices_array,
                           wxWindow *parent = NULL,
                           int x = -1, int y = -1,
                           bool centre = true,
                           int width=150, int height=200);


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

// WXWIN_COMPATIBILITY_2_4
#if 0
MustHaveApp(wxGetNumberFromUser);
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 = wxDefaultPosition);
%pythoncode { GetNumberFromUser = wx._deprecated(GetNumberFromUser) }
#endif

// GDI Functions

MustHaveApp(wxColourDisplay);
bool wxColourDisplay();

MustHaveApp(wxDisplayDepth);
int wxDisplayDepth();

MustHaveApp(wxGetDisplayDepth);
int wxGetDisplayDepth();

MustHaveApp(wxDisplaySize);
DocDeclA(
    void, wxDisplaySize(int* OUTPUT, int* OUTPUT),
    "DisplaySize() -> (width, height)");

MustHaveApp(wxGetDisplaySize);
wxSize wxGetDisplaySize();

MustHaveApp(wxDisplaySizeMM);
DocDeclA(
    void, wxDisplaySizeMM(int* OUTPUT, int* OUTPUT),
    "DisplaySizeMM() -> (width, height)");

MustHaveApp(wxGetDisplaySizeMM);
wxSize wxGetDisplaySizeMM();

MustHaveApp(wxClientDisplayRect);
DocDeclA(
    void, wxClientDisplayRect(int *OUTPUT, int *OUTPUT, int *OUTPUT, int *OUTPUT),
    "ClientDisplayRect() -> (x, y, width, height)");

MustHaveApp(wxGetClientDisplayRect);
wxRect wxGetClientDisplayRect();


MustHaveApp(wxSetCursor);
void wxSetCursor(wxCursor& cursor);


MustHaveApp(wxGetXDisplay);
DocStr(wxGetXDisplay,
"Returns a swigified pointer to the X11 display.  Returns None on
other platforms.", "");
%inline %{
    void* wxGetXDisplay()
    {
#ifdef __WXGTK__
        return wxGetDisplay();
#else
        return NULL;
#endif
    }
%}


// Miscellaneous functions

MustHaveApp(wxBeginBusyCursor);
void wxBeginBusyCursor(wxCursor *cursor = wxHOURGLASS_CURSOR);


MustHaveApp(wxGetMousePosition);
DocDeclStr(
    wxPoint, wxGetMousePosition(),
    "Get the current mouse position on the screen.", "");

MustHaveApp(FindWindowAtPointer);
DocStr(FindWindowAtPointer,
       "Returns the window currently under the mouse pointer, if it belongs to
    this application.  Otherwise it returns None.", "");
%inline %{
    wxWindow* FindWindowAtPointer() {
        wxPoint unused;
        return wxFindWindowAtPointer(unused);
    }
%}
 

MustHaveApp(wxGetActiveWindow);
DocDeclStr(
    wxWindow *, wxGetActiveWindow(),
    "Get the currently active window of this application, or None", "");


MustHaveApp(wxGenericFindWindowAtPoint);
wxWindow* wxGenericFindWindowAtPoint(const wxPoint& pt);

MustHaveApp(wxFindWindowAtPoint);
wxWindow* wxFindWindowAtPoint(const wxPoint& pt);

MustHaveApp(wxGetTopLevelParent);
wxWindow* wxGetTopLevelParent(wxWindow *win);


DocDeclStr(
    bool , wxLaunchDefaultBrowser(const wxString& url),
    "Launches the user's default browser and tells it to open the location
at ``url``.  Returns ``True`` if the application was successfully
launched.", "");


MustHaveApp(wxGetKeyState);
DocDeclStr(
    bool , wxGetKeyState(wxKeyCode key),
    "Get the state of a key (true if pressed or toggled on, false if not.)
This is generally most useful getting the state of the modifier or
toggle keys.  On some platforms those may be the only keys that this
function is able to detect.
", "");


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

DocStr(wxMouseState,
"`wx.MouseState` is used to hold information about mouse button and
modifier key states and is what is returned from `wx.GetMouseState`.",
"");

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

    wxCoord     GetX();
    wxCoord     GetY();

    bool        LeftDown();
    bool        MiddleDown();
    bool        RightDown();

    bool        ControlDown();
    bool        ShiftDown();
    bool        AltDown();
    bool        MetaDown();
    bool        CmdDown();

    void        SetX(wxCoord x);
    void        SetY(wxCoord y);

    void        SetLeftDown(bool down);
    void        SetMiddleDown(bool down);
    void        SetRightDown(bool down);
    
    void        SetControlDown(bool down);
    void        SetShiftDown(bool down);
    void        SetAltDown(bool down);
    void        SetMetaDown(bool down);

    %pythoncode {
        x = property(GetX, SetX)
        y = property(GetY, SetY)
        leftDown = property(LeftDown, SetLeftDown)
        middleDown = property(MiddleDown, SetMiddleDown)
        rightDown = property(RightDown, SetRightDown)
        controlDown = property(ControlDown, SetControlDown)
        shiftDown = property(ShiftDown, SetShiftDown)
        altDown = property(AltDown, SetAltDown)
        metaDown = property(MetaDown, SetMetaDown)
        cmdDown = property(CmdDown)
    }
};


DocDeclStr(
    wxMouseState , wxGetMouseState(),
    "Returns the current state of the mouse.  Returns an instance of a
`wx.MouseState` object that contains the current position of the mouse
pointer in screen coordinants, as well as boolean values indicating
the up/down status of the mouse buttons and the modifier keys.", "");


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

MustHaveApp(wxWakeUpMainThread);

#if defined(__WXMSW__) || defined(__WXMAC__)
void wxWakeUpMainThread();
#else
%inline %{
    void wxWakeUpMainThread() {}
%}
#endif


MustHaveApp(wxMutexGuiEnter);
void wxMutexGuiEnter();

MustHaveApp(wxMutexGuiLeave);
void wxMutexGuiLeave();


MustHaveApp(wxMutexGuiLocker);
class wxMutexGuiLocker  {
public:
    wxMutexGuiLocker();
    ~wxMutexGuiLocker();
};


MustHaveApp(wxThread);
%inline %{
    bool wxThread_IsMain() {
#ifdef WXP_WITH_THREAD
        return wxThread::IsMain();
#else
        return true;
#endif
    }
%}

//---------------------------------------------------------------------------
//---------------------------------------------------------------------------
Commit	Line	Data
d14a1e28 RD	1	/////////////////////////////////////////////////////////////////////////////
	2	// Name: _functions.i
	3	// Purpose: SWIG interface defs for various functions and such
	4	//
	5	// Author: Robin Dunn
	6	//
	7	// Created: 3-July-1997
	8	// RCS-ID: $Id$
	9	// Copyright: (c) 2003 by Total Control Software
	10	// Licence: wxWindows license
	11	/////////////////////////////////////////////////////////////////////////////
	12
	13	// Not a %module
	14
	15
1e140719 RD	16	%{
	17	#include <wx/stockitem.h>
	18	%}
	19
d14a1e28 RD	20	//---------------------------------------------------------------------------
d14a1e28 RD	21
b2dc1044 RD	22	MAKE_CONST_WXSTRING(FileSelectorPromptStr);
	23	MAKE_CONST_WXSTRING(FileSelectorDefaultWildcardStr);
	24	MAKE_CONST_WXSTRING(DirSelectorPromptStr);
d14a1e28 RD	25
	26	//---------------------------------------------------------------------------
	27	%newgroup;
	28
	29
	30	long wxNewId();
	31	void wxRegisterId(long id);
	32	long wxGetCurrentId();
	33
1e140719 RD	34	// Returns true if the ID is in the list of recognized stock actions
	35	bool wxIsStockID(wxWindowID id);
	36
	37	// Returns true of the label is empty or label of a stock button with
	38	// given ID
	39	bool wxIsStockLabel(wxWindowID id, const wxString& label);
	40
	41	// Returns label that should be used for given stock UI element (e.g. "&OK"
	42	// for wxID_OK):
8815349a RD	43	wxString wxGetStockLabel(wxWindowID id,
	44	bool withCodes = true,
	45	wxString accelerator = wxPyEmptyString);
1e140719 RD	46
1e140719 RD	47
ab1f7d2a	48	MustHaveApp(wxBell);
d14a1e28	49	void wxBell();
ab1f7d2a RD	50
ab1f7d2a RD	51	MustHaveApp(wxEndBusyCursor);
d14a1e28 RD	52	void wxEndBusyCursor();
d14a1e28 RD	53
a72f4631	54	long wxGetElapsedTime(bool resetTimer = true);
15648073 RD	55	%pythoncode { GetElapsedTime = wx._deprecated(GetElapsedTime) }
15648073 RD	56
d14a1e28 RD	57	bool wxIsBusy();
	58	wxString wxNow();
	59	bool wxShell(const wxString& command = wxPyEmptyString);
	60	void wxStartTimer();
322913ce	61
cbb4b39d RD	62
	63
	64	enum
	65	{
	66	wxUNKNOWN_PLATFORM,
	67	wxCURSES, /* Text-only CURSES */
	68	wxXVIEW_X, /* Sun's XView OpenLOOK toolkit */
	69	wxMOTIF_X, /* OSF Motif 1.x.x */
	70	wxCOSE_X, /* OSF Common Desktop Environment */
	71	wxNEXTSTEP, /* NeXTStep */
	72	wxMAC, /* Apple Mac OS 8/9/X with Mac paths */
	73	wxMAC_DARWIN, /* Apple Mac OS X with Unix paths */
	74	wxBEOS, /* BeOS */
	75	wxGTK, /* GTK on X */
	76	wxGTK_WIN32, /* GTK on Win32 */
	77	wxGTK_OS2, /* GTK on OS/2 */
	78	wxGTK_BEOS, /* GTK on BeOS */
	79	wxGEOS, /* GEOS */
	80	wxOS2_PM, /* OS/2 Workplace */
	81	wxWINDOWS, /* Windows or WfW */
	82	wxMICROWINDOWS, /* MicroWindows */
	83	wxPENWINDOWS, /* Windows for Pen Computing */
	84	wxWINDOWS_NT, /* Windows NT */
	85	wxWIN32S, /* Windows 32S API */
	86	wxWIN95, /* Windows 95 */
	87	wxWIN386, /* Watcom 32-bit supervisor modus */
	88	wxWINDOWS_CE, /* Windows CE (generic) */
	89	wxWINDOWS_POCKETPC, /* Windows CE PocketPC */
	90	wxWINDOWS_SMARTPHONE, /* Windows CE Smartphone */
	91	wxMGL_UNIX, /* MGL with direct hardware access */
	92	wxMGL_X, /* MGL on X */
	93	wxMGL_WIN32, /* MGL on Win32 */
	94	wxMGL_OS2, /* MGL on OS/2 */
	95	wxMGL_DOS, /* MGL on MS-DOS */
	96	wxWINDOWS_OS2, /* Native OS/2 PM */
	97	wxUNIX, /* wxBase under Unix */
	98	wxX11, /* Plain X11 and Universal widgets */
	99	wxPALMOS, /* PalmOS */
	100	wxDOS /* wxBase under MS-DOS */
	101	};
	102
322913ce RD	103	DocDeclA(
	104	int, wxGetOsVersion(int OUTPUT, int OUTPUT),
	105	"GetOsVersion() -> (platform, major, minor)");
	106
d14a1e28 RD	107	wxString wxGetOsDescription();
d14a1e28 RD	108
03d51a2d RD	109	// TODO:
	110	// // Parses the wildCard, returning the number of filters.
	111	// // Returns 0 if none or if there's a problem,
	112	// // The arrays will contain an equal number of items found before the error.
	113	// // wildCard is in the form:
	114	// // "All files ()\|\|Image Files (.jpeg .png)\|.jpg;.png"
daf32463	115	// int wxParseCommonDialogsFilter(const wxString& wildCard, wxArrayString& descriptions, wxArrayString& filters);
03d51a2d	116
d14a1e28	117	#if defined(__WXMSW__) \|\| defined(__WXMAC__)
e88df737	118	wxMemorySize wxGetFreeMemory();
d14a1e28 RD	119	#else
d14a1e28 RD	120	%inline %{
e88df737	121	wxMemorySize wxGetFreeMemory()
81cfe5e1	122	{ wxPyRaiseNotImplemented(); return 0; }
d14a1e28 RD	123	%}
	124	#endif
	125
	126	enum wxShutdownFlags
	127	{
	128	wxSHUTDOWN_POWEROFF, // power off the computer
	129	wxSHUTDOWN_REBOOT // shutdown and reboot
	130	};
	131
	132	// Shutdown or reboot the PC
ab1f7d2a	133	MustHaveApp(wxShutdown);
d14a1e28 RD	134	bool wxShutdown(wxShutdownFlags wFlags);
	135
	136
	137	void wxSleep(int secs);
705b61cc RD	138	void wxMilliSleep(unsigned long milliseconds);
	139	void wxMicroSleep(unsigned long microseconds);
	140	%pythoncode { Usleep = MilliSleep }
	141
d14a1e28 RD	142	void wxEnableTopLevelWindows(bool enable);
	143
	144	wxString wxStripMenuCodes(const wxString& in);
	145
	146
	147	wxString wxGetEmailAddress();
	148	wxString wxGetHostName();
	149	wxString wxGetFullHostName();
	150	wxString wxGetUserId();
	151	wxString wxGetUserName();
	152	wxString wxGetHomeDir();
	153	wxString wxGetUserHome(const wxString& user = wxPyEmptyString);
	154
	155	unsigned long wxGetProcessId();
	156
	157	void wxTrap();
	158
	159
	160	// Dialog Functions
	161
ab1f7d2a	162	MustHaveApp(wxFileSelector);
d14a1e28 RD	163	wxString wxFileSelector(const wxString& message = wxPyFileSelectorPromptStr,
	164	const wxString& default_path = wxPyEmptyString,
	165	const wxString& default_filename = wxPyEmptyString,
	166	const wxString& default_extension = wxPyEmptyString,
	167	const wxString& wildcard = wxPyFileSelectorDefaultWildcardStr,
	168	int flags = 0,
	169	wxWindow *parent = NULL,
	170	int x = -1, int y = -1);
	171
	172	// TODO: wxFileSelectorEx
	173
	174
	175	// Ask for filename to load
ab1f7d2a	176	MustHaveApp(wxLoadFileSelector);
d14a1e28 RD	177	wxString wxLoadFileSelector(const wxString& what,
	178	const wxString& extension,
	179	const wxString& default_name = wxPyEmptyString,
	180	wxWindow *parent = NULL);
	181
	182	// Ask for filename to save
ab1f7d2a	183	MustHaveApp(wxSaveFileSelector);
d14a1e28 RD	184	wxString wxSaveFileSelector(const wxString& what,
	185	const wxString& extension,
	186	const wxString& default_name = wxPyEmptyString,
	187	wxWindow *parent = NULL);
	188
	189
ab1f7d2a	190	MustHaveApp(wxDirSelector);
d14a1e28 RD	191	wxString wxDirSelector(const wxString& message = wxPyDirSelectorPromptStr,
	192	const wxString& defaultPath = wxPyEmptyString,
	193	long style = wxDD_DEFAULT_STYLE,
	194	const wxPoint& pos = wxDefaultPosition,
	195	wxWindow *parent = NULL);
	196
ab1f7d2a	197	MustHaveApp(wxGetTextFromUser);
d14a1e28 RD	198	wxString wxGetTextFromUser(const wxString& message,
	199	const wxString& caption = wxPyEmptyString,
	200	const wxString& default_value = wxPyEmptyString,
	201	wxWindow *parent = NULL,
	202	int x = -1, int y = -1,
a72f4631	203	bool centre = true);
d14a1e28	204
ab1f7d2a	205	MustHaveApp(wxGetPasswordFromUser);
d14a1e28 RD	206	wxString wxGetPasswordFromUser(const wxString& message,
	207	const wxString& caption = wxPyEmptyString,
	208	const wxString& default_value = wxPyEmptyString,
	209	wxWindow *parent = NULL);
	210
	211
	212	// TODO: Need to custom wrap this one...
	213	// int wxGetMultipleChoice(char* message, char* caption,
	214	// int LCOUNT, char** choices,
	215	// int nsel, int *selection,
	216	// wxWindow *parent = NULL, int x = -1, int y = -1,
a72f4631	217	// bool centre = true, int width=150, int height=200);
d14a1e28 RD	218
d14a1e28 RD	219
ab1f7d2a	220	MustHaveApp(wxGetSingleChoice);
d14a1e28 RD	221	wxString wxGetSingleChoice(const wxString& message, const wxString& caption,
	222	int choices, wxString* choices_array,
	223	wxWindow *parent = NULL,
	224	int x = -1, int y = -1,
a72f4631	225	bool centre = true,
d14a1e28 RD	226	int width=150, int height=200);
d14a1e28 RD	227
ab1f7d2a	228	MustHaveApp(wxGetSingleChoiceIndex);
d14a1e28 RD	229	int wxGetSingleChoiceIndex(const wxString& message, const wxString& caption,
	230	int choices, wxString* choices_array,
	231	wxWindow *parent = NULL,
	232	int x = -1, int y = -1,
a72f4631	233	bool centre = true,
d14a1e28 RD	234	int width=150, int height=200);
	235
	236
ab1f7d2a	237	MustHaveApp(wxMessageBox);
d14a1e28 RD	238	int wxMessageBox(const wxString& message,
	239	const wxString& caption = wxPyEmptyString,
	240	int style = wxOK \| wxCENTRE,
	241	wxWindow *parent = NULL,
	242	int x = -1, int y = -1);
	243
aeee37c3	244	// WXWIN_COMPATIBILITY_2_4
2f91e3df	245	#if 0
ab1f7d2a	246	MustHaveApp(wxGetNumberFromUser);
d14a1e28 RD	247	long wxGetNumberFromUser(const wxString& message,
	248	const wxString& prompt,
	249	const wxString& caption,
	250	long value,
	251	long min = 0, long max = 100,
	252	wxWindow *parent = NULL,
	253	const wxPoint& pos = wxDefaultPosition);
02b800ce	254	%pythoncode { GetNumberFromUser = wx._deprecated(GetNumberFromUser) }
2f91e3df	255	#endif
02b800ce	256
d14a1e28 RD	257	// GDI Functions
d14a1e28 RD	258
ab1f7d2a	259	MustHaveApp(wxColourDisplay);
d14a1e28 RD	260	bool wxColourDisplay();
d14a1e28 RD	261
ab1f7d2a	262	MustHaveApp(wxDisplayDepth);
d14a1e28	263	int wxDisplayDepth();
ab1f7d2a RD	264
ab1f7d2a RD	265	MustHaveApp(wxGetDisplayDepth);
d14a1e28 RD	266	int wxGetDisplayDepth();
d14a1e28 RD	267
ab1f7d2a	268	MustHaveApp(wxDisplaySize);
322913ce RD	269	DocDeclA(
	270	void, wxDisplaySize(int* OUTPUT, int* OUTPUT),
	271	"DisplaySize() -> (width, height)");
ab1f7d2a RD	272
ab1f7d2a RD	273	MustHaveApp(wxGetDisplaySize);
d14a1e28 RD	274	wxSize wxGetDisplaySize();
d14a1e28 RD	275
ab1f7d2a	276	MustHaveApp(wxDisplaySizeMM);
322913ce RD	277	DocDeclA(
	278	void, wxDisplaySizeMM(int* OUTPUT, int* OUTPUT),
	279	"DisplaySizeMM() -> (width, height)");
ab1f7d2a RD	280
ab1f7d2a RD	281	MustHaveApp(wxGetDisplaySizeMM);
d14a1e28 RD	282	wxSize wxGetDisplaySizeMM();
d14a1e28 RD	283
ab1f7d2a	284	MustHaveApp(wxClientDisplayRect);
322913ce RD	285	DocDeclA(
	286	void, wxClientDisplayRect(int OUTPUT, int OUTPUT, int OUTPUT, int OUTPUT),
	287	"ClientDisplayRect() -> (x, y, width, height)");
ab1f7d2a RD	288
ab1f7d2a RD	289	MustHaveApp(wxGetClientDisplayRect);
d14a1e28 RD	290	wxRect wxGetClientDisplayRect();
d14a1e28 RD	291
ab1f7d2a RD	292
ab1f7d2a RD	293	MustHaveApp(wxSetCursor);
d14a1e28 RD	294	void wxSetCursor(wxCursor& cursor);
	295
	296
2327fb3b RD	297	MustHaveApp(wxGetXDisplay);
	298	DocStr(wxGetXDisplay,
	299	"Returns a swigified pointer to the X11 display. Returns None on
	300	other platforms.", "");
	301	%inline %{
	302	void* wxGetXDisplay()
	303	{
	304	#ifdef __WXGTK__
	305	return wxGetDisplay();
	306	#else
	307	return NULL;
	308	#endif
	309	}
	310	%}
	311
d14a1e28 RD	312
	313	// Miscellaneous functions
	314
ab1f7d2a	315	MustHaveApp(wxBeginBusyCursor);
d14a1e28	316	void wxBeginBusyCursor(wxCursor *cursor = wxHOURGLASS_CURSOR);
ab1f7d2a	317
095315e2 RD	318
	319	MustHaveApp(wxGetMousePosition);
	320	DocDeclStr(
	321	wxPoint, wxGetMousePosition(),
	322	"Get the current mouse position on the screen.", "");
	323
	324	MustHaveApp(FindWindowAtPointer);
	325	DocStr(FindWindowAtPointer,
	326	"Returns the window currently under the mouse pointer, if it belongs to
	327	this application. Otherwise it returns None.", "");
	328	%inline %{
	329	wxWindow* FindWindowAtPointer() {
	330	wxPoint unused;
	331	return wxFindWindowAtPointer(unused);
	332	}
	333	%}
	334
	335
ab1f7d2a	336	MustHaveApp(wxGetActiveWindow);
095315e2 RD	337	DocDeclStr(
	338	wxWindow *, wxGetActiveWindow(),
	339	"Get the currently active window of this application, or None", "");
	340
d14a1e28	341
ab1f7d2a	342	MustHaveApp(wxGenericFindWindowAtPoint);
d14a1e28	343	wxWindow* wxGenericFindWindowAtPoint(const wxPoint& pt);
ab1f7d2a RD	344
ab1f7d2a RD	345	MustHaveApp(wxFindWindowAtPoint);
d14a1e28 RD	346	wxWindow* wxFindWindowAtPoint(const wxPoint& pt);
d14a1e28 RD	347
ab1f7d2a	348	MustHaveApp(wxGetTopLevelParent);
d14a1e28 RD	349	wxWindow* wxGetTopLevelParent(wxWindow *win);
d14a1e28 RD	350
d14a1e28	351
aa2fc802 RD	352	DocDeclStr(
	353	bool , wxLaunchDefaultBrowser(const wxString& url),
	354	"Launches the user's default browser and tells it to open the location
	355	at ``url``. Returns ``True`` if the application was successfully
	356	launched.", "");
d14a1e28 RD	357
d14a1e28 RD	358
89c876de	359
ab1f7d2a	360	MustHaveApp(wxGetKeyState);
ad411ab2 RD	361	DocDeclStr(
	362	bool , wxGetKeyState(wxKeyCode key),
	363	"Get the state of a key (true if pressed or toggled on, false if not.)
	364	This is generally most useful getting the state of the modifier or
095315e2 RD	365	toggle keys. On some platforms those may be the only keys that this
095315e2 RD	366	function is able to detect.
ad411ab2 RD	367	", "");
ad411ab2 RD	368
57b1892f RD	369
57b1892f RD	370
095315e2 RD	371	//---------------------------------------------------------------------------
	372
	373	DocStr(wxMouseState,
	374	"`wx.MouseState` is used to hold information about mouse button and
	375	modifier key states and is what is returned from `wx.GetMouseState`.",
	376	"");
	377
	378	class wxMouseState
	379	{
	380	public:
	381	wxMouseState();
	382	~wxMouseState();
	383
	384	wxCoord GetX();
	385	wxCoord GetY();
	386
	387	bool LeftDown();
	388	bool MiddleDown();
	389	bool RightDown();
	390
	391	bool ControlDown();
	392	bool ShiftDown();
	393	bool AltDown();
	394	bool MetaDown();
	395	bool CmdDown();
	396
	397	void SetX(wxCoord x);
	398	void SetY(wxCoord y);
	399
	400	void SetLeftDown(bool down);
	401	void SetMiddleDown(bool down);
	402	void SetRightDown(bool down);
	403
	404	void SetControlDown(bool down);
	405	void SetShiftDown(bool down);
	406	void SetAltDown(bool down);
	407	void SetMetaDown(bool down);
	408
	409	%pythoncode {
	410	x = property(GetX, SetX)
	411	y = property(GetY, SetY)
	412	leftDown = property(LeftDown, SetLeftDown)
	413	middleDown = property(MiddleDown, SetMiddleDown)
	414	rightDown = property(RightDown, SetRightDown)
	415	controlDown = property(ControlDown, SetControlDown)
	416	shiftDown = property(ShiftDown, SetShiftDown)
	417	altDown = property(AltDown, SetAltDown)
	418	metaDown = property(MetaDown, SetMetaDown)
	419	cmdDown = property(CmdDown)
	420	}
	421	};
	422
	423
	424	DocDeclStr(
	425	wxMouseState , wxGetMouseState(),
	426	"Returns the current state of the mouse. Returns an instance of a
	427	`wx.MouseState` object that contains the current position of the mouse
	428	pointer in screen coordinants, as well as boolean values indicating
	429	the up/down status of the mouse buttons and the modifier keys.", "");
	430
	431
d14a1e28 RD	432	//---------------------------------------------------------------------------
d14a1e28 RD	433
ab1f7d2a RD	434	MustHaveApp(wxWakeUpMainThread);
ab1f7d2a RD	435
d14a1e28 RD	436	#if defined(__WXMSW__) \|\| defined(__WXMAC__)
	437	void wxWakeUpMainThread();
	438	#else
	439	%inline %{
	440	void wxWakeUpMainThread() {}
	441	%}
	442	#endif
	443
ab1f7d2a RD	444
ab1f7d2a RD	445	MustHaveApp(wxMutexGuiEnter);
d14a1e28	446	void wxMutexGuiEnter();
ab1f7d2a RD	447
ab1f7d2a RD	448	MustHaveApp(wxMutexGuiLeave);
d14a1e28 RD	449	void wxMutexGuiLeave();
	450
	451
ab1f7d2a	452	MustHaveApp(wxMutexGuiLocker);
d14a1e28 RD	453	class wxMutexGuiLocker {
	454	public:
	455	wxMutexGuiLocker();
	456	~wxMutexGuiLocker();
	457	};
	458
	459
ab1f7d2a	460	MustHaveApp(wxThread);
d14a1e28 RD	461	%inline %{
	462	bool wxThread_IsMain() {
	463	#ifdef WXP_WITH_THREAD
	464	return wxThread::IsMain();
	465	#else
a72f4631	466	return true;
d14a1e28 RD	467	#endif
	468	}
	469	%}
	470
	471	//---------------------------------------------------------------------------
	472	//---------------------------------------------------------------------------