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

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

// 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
	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
	16	%{
	17	#include <wx/stockitem.h>
	18	%}
	19
	20	//---------------------------------------------------------------------------
	21
	22	MAKE_CONST_WXSTRING(FileSelectorPromptStr);
	23	MAKE_CONST_WXSTRING(FileSelectorDefaultWildcardStr);
	24	MAKE_CONST_WXSTRING(DirSelectorPromptStr);
	25
	26	//---------------------------------------------------------------------------
	27	%newgroup;
	28
	29
	30	long wxNewId();
	31	void wxRegisterId(long id);
	32	long wxGetCurrentId();
	33
	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):
	43	wxString wxGetStockLabel(wxWindowID id,
	44	bool withCodes = true,
	45	wxString accelerator = wxPyEmptyString);
	46
	47
	48	MustHaveApp(wxBell);
	49	void wxBell();
	50
	51	MustHaveApp(wxEndBusyCursor);
	52	void wxEndBusyCursor();
	53
	54	long wxGetElapsedTime(bool resetTimer = true);
	55	%pythoncode { GetElapsedTime = wx._deprecated(GetElapsedTime) }
	56
	57	bool wxIsBusy();
	58	wxString wxNow();
	59	bool wxShell(const wxString& command = wxPyEmptyString);
	60	void wxStartTimer();
	61
	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
	103	DocDeclA(
	104	int, wxGetOsVersion(int OUTPUT, int OUTPUT),
	105	"GetOsVersion() -> (platform, major, minor)");
	106
	107	wxString wxGetOsDescription();
	108
	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"
	115	// int wxParseCommonDialogsFilter(const wxString& wildCard, wxArrayString& descriptions, wxArrayString& filters);
	116
	117	#if defined(__WXMSW__) \|\| defined(__WXMAC__)
	118	wxMemorySize wxGetFreeMemory();
	119	#else
	120	%inline %{
	121	wxMemorySize wxGetFreeMemory()
	122	{ wxPyRaiseNotImplemented(); return 0; }
	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
	133	MustHaveApp(wxShutdown);
	134	bool wxShutdown(wxShutdownFlags wFlags);
	135
	136
	137	void wxSleep(int secs);
	138	void wxMilliSleep(unsigned long milliseconds);
	139	void wxMicroSleep(unsigned long microseconds);
	140	%pythoncode { Usleep = MilliSleep }
	141
	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
	162	MustHaveApp(wxFileSelector);
	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
	176	MustHaveApp(wxLoadFileSelector);
	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
	183	MustHaveApp(wxSaveFileSelector);
	184	wxString wxSaveFileSelector(const wxString& what,
	185	const wxString& extension,
	186	const wxString& default_name = wxPyEmptyString,
	187	wxWindow *parent = NULL);
	188
	189
	190	MustHaveApp(wxDirSelector);
	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
	197	MustHaveApp(wxGetTextFromUser);
	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,
	203	bool centre = true);
	204
	205	MustHaveApp(wxGetPasswordFromUser);
	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,
	217	// bool centre = true, int width=150, int height=200);
	218
	219
	220	MustHaveApp(wxGetSingleChoice);
	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,
	225	bool centre = true,
	226	int width=150, int height=200);
	227
	228	MustHaveApp(wxGetSingleChoiceIndex);
	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,
	233	bool centre = true,
	234	int width=150, int height=200);
	235
	236
	237	MustHaveApp(wxMessageBox);
	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
	244	MustHaveApp(wxGetNumberFromUser);
	245	long wxGetNumberFromUser(const wxString& message,
	246	const wxString& prompt,
	247	const wxString& caption,
	248	long value,
	249	long min = 0, long max = 100,
	250	wxWindow *parent = NULL,
	251	const wxPoint& pos = wxDefaultPosition);
	252
	253	// GDI Functions
	254
	255	MustHaveApp(wxColourDisplay);
	256	bool wxColourDisplay();
	257
	258	MustHaveApp(wxDisplayDepth);
	259	int wxDisplayDepth();
	260
	261	MustHaveApp(wxGetDisplayDepth);
	262	int wxGetDisplayDepth();
	263
	264	MustHaveApp(wxDisplaySize);
	265	DocDeclA(
	266	void, wxDisplaySize(int* OUTPUT, int* OUTPUT),
	267	"DisplaySize() -> (width, height)");
	268
	269	MustHaveApp(wxGetDisplaySize);
	270	wxSize wxGetDisplaySize();
	271
	272	MustHaveApp(wxDisplaySizeMM);
	273	DocDeclA(
	274	void, wxDisplaySizeMM(int* OUTPUT, int* OUTPUT),
	275	"DisplaySizeMM() -> (width, height)");
	276
	277	MustHaveApp(wxGetDisplaySizeMM);
	278	wxSize wxGetDisplaySizeMM();
	279
	280	MustHaveApp(wxClientDisplayRect);
	281	DocDeclA(
	282	void, wxClientDisplayRect(int OUTPUT, int OUTPUT, int OUTPUT, int OUTPUT),
	283	"ClientDisplayRect() -> (x, y, width, height)");
	284
	285	MustHaveApp(wxGetClientDisplayRect);
	286	wxRect wxGetClientDisplayRect();
	287
	288
	289	MustHaveApp(wxSetCursor);
	290	void wxSetCursor(wxCursor& cursor);
	291
	292
	293	MustHaveApp(wxGetXDisplay);
	294	DocStr(wxGetXDisplay,
	295	"Returns a swigified pointer to the X11 display. Returns None on
	296	other platforms.", "");
	297	%inline %{
	298	void* wxGetXDisplay()
	299	{
	300	#ifdef __WXGTK__
	301	return wxGetDisplay();
	302	#else
	303	return NULL;
	304	#endif
	305	}
	306	%}
	307
	308
	309	// Miscellaneous functions
	310
	311	MustHaveApp(wxBeginBusyCursor);
	312	void wxBeginBusyCursor(wxCursor *cursor = wxHOURGLASS_CURSOR);
	313
	314
	315	MustHaveApp(wxGetMousePosition);
	316	DocDeclStr(
	317	wxPoint, wxGetMousePosition(),
	318	"Get the current mouse position on the screen.", "");
	319
	320	MustHaveApp(FindWindowAtPointer);
	321	DocStr(FindWindowAtPointer,
	322	"Returns the window currently under the mouse pointer, if it belongs to
	323	this application. Otherwise it returns None.", "");
	324	%inline %{
	325	wxWindow* FindWindowAtPointer() {
	326	wxPoint unused;
	327	return wxFindWindowAtPointer(unused);
	328	}
	329	%}
	330
	331
	332	MustHaveApp(wxGetActiveWindow);
	333	DocDeclStr(
	334	wxWindow *, wxGetActiveWindow(),
	335	"Get the currently active window of this application, or None", "");
	336
	337
	338	MustHaveApp(wxGenericFindWindowAtPoint);
	339	wxWindow* wxGenericFindWindowAtPoint(const wxPoint& pt);
	340
	341	MustHaveApp(wxFindWindowAtPoint);
	342	wxWindow* wxFindWindowAtPoint(const wxPoint& pt);
	343
	344	MustHaveApp(wxGetTopLevelParent);
	345	wxWindow* wxGetTopLevelParent(wxWindow *win);
	346
	347
	348	DocDeclStr(
	349	bool , wxLaunchDefaultBrowser(const wxString& url),
	350	"Launches the user's default browser and tells it to open the location
	351	at ``url``. Returns ``True`` if the application was successfully
	352	launched.", "");
	353
	354
	355
	356	MustHaveApp(wxGetKeyState);
	357	DocDeclStr(
	358	bool , wxGetKeyState(wxKeyCode key),
	359	"Get the state of a key (true if pressed or toggled on, false if not.)
	360	This is generally most useful getting the state of the modifier or
	361	toggle keys. On some platforms those may be the only keys that this
	362	function is able to detect.
	363	", "");
	364
	365
	366
	367	//---------------------------------------------------------------------------
	368
	369	DocStr(wxMouseState,
	370	"`wx.MouseState` is used to hold information about mouse button and
	371	modifier key states and is what is returned from `wx.GetMouseState`.",
	372	"");
	373
	374	class wxMouseState
	375	{
	376	public:
	377	wxMouseState();
	378	~wxMouseState();
	379
	380	wxCoord GetX();
	381	wxCoord GetY();
	382
	383	bool LeftDown();
	384	bool MiddleDown();
	385	bool RightDown();
	386
	387	bool ControlDown();
	388	bool ShiftDown();
	389	bool AltDown();
	390	bool MetaDown();
	391	bool CmdDown();
	392
	393	void SetX(wxCoord x);
	394	void SetY(wxCoord y);
	395
	396	void SetLeftDown(bool down);
	397	void SetMiddleDown(bool down);
	398	void SetRightDown(bool down);
	399
	400	void SetControlDown(bool down);
	401	void SetShiftDown(bool down);
	402	void SetAltDown(bool down);
	403	void SetMetaDown(bool down);
	404
	405	%pythoncode {
	406	x = property(GetX, SetX)
	407	y = property(GetY, SetY)
	408	leftDown = property(LeftDown, SetLeftDown)
	409	middleDown = property(MiddleDown, SetMiddleDown)
	410	rightDown = property(RightDown, SetRightDown)
	411	controlDown = property(ControlDown, SetControlDown)
	412	shiftDown = property(ShiftDown, SetShiftDown)
	413	altDown = property(AltDown, SetAltDown)
	414	metaDown = property(MetaDown, SetMetaDown)
	415	cmdDown = property(CmdDown)
	416	}
	417	};
	418
	419
	420	DocDeclStr(
	421	wxMouseState , wxGetMouseState(),
	422	"Returns the current state of the mouse. Returns an instance of a
	423	`wx.MouseState` object that contains the current position of the mouse
	424	pointer in screen coordinants, as well as boolean values indicating
	425	the up/down status of the mouse buttons and the modifier keys.", "");
	426
	427
	428	//---------------------------------------------------------------------------
	429
	430	MustHaveApp(wxWakeUpMainThread);
	431
	432	#if defined(__WXMSW__) \|\| defined(__WXMAC__)
	433	void wxWakeUpMainThread();
	434	#else
	435	%inline %{
	436	void wxWakeUpMainThread() {}
	437	%}
	438	#endif
	439
	440
	441	MustHaveApp(wxMutexGuiEnter);
	442	void wxMutexGuiEnter();
	443
	444	MustHaveApp(wxMutexGuiLeave);
	445	void wxMutexGuiLeave();
	446
	447
	448	MustHaveApp(wxMutexGuiLocker);
	449	class wxMutexGuiLocker {
	450	public:
	451	wxMutexGuiLocker();
	452	~wxMutexGuiLocker();
	453	};
	454
	455
	456	MustHaveApp(wxThread);
	457	%inline %{
	458	bool wxThread_IsMain() {
	459	#ifdef WXP_WITH_THREAD
	460	return wxThread::IsMain();
	461	#else
	462	return true;
	463	#endif
	464	}
	465	%}
	466
	467	//---------------------------------------------------------------------------
	468	//---------------------------------------------------------------------------