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
	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	// WXWIN_COMPATIBILITY_2_4
	245	#if 0
	246	MustHaveApp(wxGetNumberFromUser);
	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);
	254	%pythoncode { GetNumberFromUser = wx._deprecated(GetNumberFromUser) }
	255	#endif
	256
	257	// GDI Functions
	258
	259	MustHaveApp(wxColourDisplay);
	260	bool wxColourDisplay();
	261
	262	MustHaveApp(wxDisplayDepth);
	263	int wxDisplayDepth();
	264
	265	MustHaveApp(wxGetDisplayDepth);
	266	int wxGetDisplayDepth();
	267
	268	MustHaveApp(wxDisplaySize);
	269	DocDeclA(
	270	void, wxDisplaySize(int* OUTPUT, int* OUTPUT),
	271	"DisplaySize() -> (width, height)");
	272
	273	MustHaveApp(wxGetDisplaySize);
	274	wxSize wxGetDisplaySize();
	275
	276	MustHaveApp(wxDisplaySizeMM);
	277	DocDeclA(
	278	void, wxDisplaySizeMM(int* OUTPUT, int* OUTPUT),
	279	"DisplaySizeMM() -> (width, height)");
	280
	281	MustHaveApp(wxGetDisplaySizeMM);
	282	wxSize wxGetDisplaySizeMM();
	283
	284	MustHaveApp(wxClientDisplayRect);
	285	DocDeclA(
	286	void, wxClientDisplayRect(int OUTPUT, int OUTPUT, int OUTPUT, int OUTPUT),
	287	"ClientDisplayRect() -> (x, y, width, height)");
	288
	289	MustHaveApp(wxGetClientDisplayRect);
	290	wxRect wxGetClientDisplayRect();
	291
	292
	293	MustHaveApp(wxSetCursor);
	294	void wxSetCursor(wxCursor& cursor);
	295
	296
	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
	312
	313	// Miscellaneous functions
	314
	315	MustHaveApp(wxBeginBusyCursor);
	316	void wxBeginBusyCursor(wxCursor *cursor = wxHOURGLASS_CURSOR);
	317
	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
	336	MustHaveApp(wxGetActiveWindow);
	337	DocDeclStr(
	338	wxWindow *, wxGetActiveWindow(),
	339	"Get the currently active window of this application, or None", "");
	340
	341
	342	MustHaveApp(wxGenericFindWindowAtPoint);
	343	wxWindow* wxGenericFindWindowAtPoint(const wxPoint& pt);
	344
	345	MustHaveApp(wxFindWindowAtPoint);
	346	wxWindow* wxFindWindowAtPoint(const wxPoint& pt);
	347
	348	MustHaveApp(wxGetTopLevelParent);
	349	wxWindow* wxGetTopLevelParent(wxWindow *win);
	350
	351
	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.", "");
	357
	358
	359
	360	MustHaveApp(wxGetKeyState);
	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
	365	toggle keys. On some platforms those may be the only keys that this
	366	function is able to detect.
	367	", "");
	368
	369
	370
	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
	432	//---------------------------------------------------------------------------
	433
	434	MustHaveApp(wxWakeUpMainThread);
	435
	436	#if defined(__WXMSW__) \|\| defined(__WXMAC__)
	437	void wxWakeUpMainThread();
	438	#else
	439	%inline %{
	440	void wxWakeUpMainThread() {}
	441	%}
	442	#endif
	443
	444
	445	MustHaveApp(wxMutexGuiEnter);
	446	void wxMutexGuiEnter();
	447
	448	MustHaveApp(wxMutexGuiLeave);
	449	void wxMutexGuiLeave();
	450
	451
	452	MustHaveApp(wxMutexGuiLocker);
	453	class wxMutexGuiLocker {
	454	public:
	455	wxMutexGuiLocker();
	456	~wxMutexGuiLocker();
	457	};
	458
	459
	460	MustHaveApp(wxThread);
	461	%inline %{
	462	bool wxThread_IsMain() {
	463	#ifdef WXP_WITH_THREAD
	464	return wxThread::IsMain();
	465	#else
	466	return true;
	467	#endif
	468	}
	469	%}
	470
	471	//---------------------------------------------------------------------------
	472	//---------------------------------------------------------------------------