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

enum wxStockLabelQueryFlag
{
    wxSTOCK_NOFLAGS = 0,

    wxSTOCK_WITH_MNEMONIC = 1,
    wxSTOCK_WITH_ACCELERATOR = 2
};

// Returns label that should be used for given stock UI element (e.g. "&OK"
// for wxID_OK):
wxString wxGetStockLabel(wxWindowID id,
                         long flags = wxSTOCK_WITH_MNEMONIC);


enum wxStockHelpStringClient
{
    wxSTOCK_MENU        // help string to use for menu items
};

// Returns an help string for the given stock UI element and for the given "context".
wxString wxGetStockHelpString(wxWindowID id,
                              wxStockHelpStringClient client = wxSTOCK_MENU);


MustHaveApp(wxBell);
void wxBell();

MustHaveApp(wxEndBusyCursor);
void wxEndBusyCursor();

bool wxIsBusy();
wxString wxNow();
bool wxShell(const wxString& command = wxPyEmptyString);


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

wxString wxGetOsDescription();


// Get platform endianness
bool wxIsPlatformLittleEndian();

// Get platform architecture
bool wxIsPlatform64Bit();


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


%typemap(out) wxMemorySize {
    %#if wxUSE_LONGLONG
         $result = PyLong_FromLongLong($1.GetValue());
    %#else
         $result = PyInt_FromLong($1);
    %#endif
}

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


// flags for wxLaunchDefaultBrowser
enum
{
    wxBROWSER_NEW_WINDOW = 1
};

DocDeclStr(
    bool , wxLaunchDefaultBrowser(const wxString& url, int flags = 0),
    "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	enum wxStockLabelQueryFlag
	42	{
	43	wxSTOCK_NOFLAGS = 0,
	44
	45	wxSTOCK_WITH_MNEMONIC = 1,
	46	wxSTOCK_WITH_ACCELERATOR = 2
	47	};
	48
	49	// Returns label that should be used for given stock UI element (e.g. "&OK"
	50	// for wxID_OK):
	51	wxString wxGetStockLabel(wxWindowID id,
	52	long flags = wxSTOCK_WITH_MNEMONIC);
	53
	54
	55	enum wxStockHelpStringClient
	56	{
	57	wxSTOCK_MENU // help string to use for menu items
	58	};
	59
	60	// Returns an help string for the given stock UI element and for the given "context".
	61	wxString wxGetStockHelpString(wxWindowID id,
	62	wxStockHelpStringClient client = wxSTOCK_MENU);
	63
	64
	65
	66
	67	MustHaveApp(wxBell);
	68	void wxBell();
	69
	70	MustHaveApp(wxEndBusyCursor);
	71	void wxEndBusyCursor();
	72
	73	bool wxIsBusy();
	74	wxString wxNow();
	75	bool wxShell(const wxString& command = wxPyEmptyString);
	76
	77
	78	DocDeclA(
	79	int, wxGetOsVersion(int OUTPUT, int OUTPUT),
	80	"GetOsVersion() -> (platform, major, minor)");
	81
	82	wxString wxGetOsDescription();
	83
	84
	85	// Get platform endianness
	86	bool wxIsPlatformLittleEndian();
	87
	88	// Get platform architecture
	89	bool wxIsPlatform64Bit();
	90
	91
	92	// TODO:
	93	// // Parses the wildCard, returning the number of filters.
	94	// // Returns 0 if none or if there's a problem,
	95	// // The arrays will contain an equal number of items found before the error.
	96	// // wildCard is in the form:
	97	// // "All files ()\|\|Image Files (.jpeg .png)\|.jpg;.png"
	98	// int wxParseCommonDialogsFilter(const wxString& wildCard, wxArrayString& descriptions, wxArrayString& filters);
	99
	100
	101	%typemap(out) wxMemorySize {
	102	%#if wxUSE_LONGLONG
	103	$result = PyLong_FromLongLong($1.GetValue());
	104	%#else
	105	$result = PyInt_FromLong($1);
	106	%#endif
	107	}
	108
	109	#if defined(__WXMSW__) \|\| defined(__WXMAC__)
	110	wxMemorySize wxGetFreeMemory();
	111	#else
	112	%inline %{
	113	wxMemorySize wxGetFreeMemory()
	114	{ wxPyRaiseNotImplemented(); return 0; }
	115	%}
	116	#endif
	117
	118	enum wxShutdownFlags
	119	{
	120	wxSHUTDOWN_POWEROFF, // power off the computer
	121	wxSHUTDOWN_REBOOT // shutdown and reboot
	122	};
	123
	124	// Shutdown or reboot the PC
	125	MustHaveApp(wxShutdown);
	126	bool wxShutdown(wxShutdownFlags wFlags);
	127
	128
	129	void wxSleep(int secs);
	130	void wxMilliSleep(unsigned long milliseconds);
	131	void wxMicroSleep(unsigned long microseconds);
	132	%pythoncode { Usleep = MilliSleep }
	133
	134	void wxEnableTopLevelWindows(bool enable);
	135
	136	wxString wxStripMenuCodes(const wxString& in);
	137
	138
	139	wxString wxGetEmailAddress();
	140	wxString wxGetHostName();
	141	wxString wxGetFullHostName();
	142	wxString wxGetUserId();
	143	wxString wxGetUserName();
	144	wxString wxGetHomeDir();
	145	wxString wxGetUserHome(const wxString& user = wxPyEmptyString);
	146
	147	unsigned long wxGetProcessId();
	148
	149	void wxTrap();
	150
	151
	152	// Dialog Functions
	153
	154	MustHaveApp(wxFileSelector);
	155	wxString wxFileSelector(const wxString& message = wxPyFileSelectorPromptStr,
	156	const wxString& default_path = wxPyEmptyString,
	157	const wxString& default_filename = wxPyEmptyString,
	158	const wxString& default_extension = wxPyEmptyString,
	159	const wxString& wildcard = wxPyFileSelectorDefaultWildcardStr,
	160	int flags = 0,
	161	wxWindow *parent = NULL,
	162	int x = -1, int y = -1);
	163
	164	// TODO: wxFileSelectorEx
	165
	166
	167	// Ask for filename to load
	168	MustHaveApp(wxLoadFileSelector);
	169	wxString wxLoadFileSelector(const wxString& what,
	170	const wxString& extension,
	171	const wxString& default_name = wxPyEmptyString,
	172	wxWindow *parent = NULL);
	173
	174	// Ask for filename to save
	175	MustHaveApp(wxSaveFileSelector);
	176	wxString wxSaveFileSelector(const wxString& what,
	177	const wxString& extension,
	178	const wxString& default_name = wxPyEmptyString,
	179	wxWindow *parent = NULL);
	180
	181
	182	MustHaveApp(wxDirSelector);
	183	wxString wxDirSelector(const wxString& message = wxPyDirSelectorPromptStr,
	184	const wxString& defaultPath = wxPyEmptyString,
	185	long style = wxDD_DEFAULT_STYLE,
	186	const wxPoint& pos = wxDefaultPosition,
	187	wxWindow *parent = NULL);
	188
	189	MustHaveApp(wxGetTextFromUser);
	190	wxString wxGetTextFromUser(const wxString& message,
	191	const wxString& caption = wxPyEmptyString,
	192	const wxString& default_value = wxPyEmptyString,
	193	wxWindow *parent = NULL,
	194	int x = -1, int y = -1,
	195	bool centre = true);
	196
	197	MustHaveApp(wxGetPasswordFromUser);
	198	wxString wxGetPasswordFromUser(const wxString& message,
	199	const wxString& caption = wxPyEmptyString,
	200	const wxString& default_value = wxPyEmptyString,
	201	wxWindow *parent = NULL);
	202
	203
	204	// TODO: Need to custom wrap this one...
	205	// int wxGetMultipleChoice(char* message, char* caption,
	206	// int LCOUNT, char** choices,
	207	// int nsel, int *selection,
	208	// wxWindow *parent = NULL, int x = -1, int y = -1,
	209	// bool centre = true, int width=150, int height=200);
	210
	211
	212	MustHaveApp(wxGetSingleChoice);
	213	wxString wxGetSingleChoice(const wxString& message, const wxString& caption,
	214	int choices, wxString* choices_array,
	215	wxWindow *parent = NULL,
	216	int x = -1, int y = -1,
	217	bool centre = true,
	218	int width=150, int height=200);
	219
	220	MustHaveApp(wxGetSingleChoiceIndex);
	221	int wxGetSingleChoiceIndex(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
	229	MustHaveApp(wxMessageBox);
	230	int wxMessageBox(const wxString& message,
	231	const wxString& caption = wxPyEmptyString,
	232	int style = wxOK \| wxCENTRE,
	233	wxWindow *parent = NULL,
	234	int x = -1, int y = -1);
	235
	236	MustHaveApp(wxGetNumberFromUser);
	237	long wxGetNumberFromUser(const wxString& message,
	238	const wxString& prompt,
	239	const wxString& caption,
	240	long value,
	241	long min = 0, long max = 100,
	242	wxWindow *parent = NULL,
	243	const wxPoint& pos = wxDefaultPosition);
	244
	245	// GDI Functions
	246
	247	MustHaveApp(wxColourDisplay);
	248	bool wxColourDisplay();
	249
	250	MustHaveApp(wxDisplayDepth);
	251	int wxDisplayDepth();
	252
	253	MustHaveApp(wxGetDisplayDepth);
	254	int wxGetDisplayDepth();
	255
	256	MustHaveApp(wxDisplaySize);
	257	DocDeclA(
	258	void, wxDisplaySize(int* OUTPUT, int* OUTPUT),
	259	"DisplaySize() -> (width, height)");
	260
	261	MustHaveApp(wxGetDisplaySize);
	262	wxSize wxGetDisplaySize();
	263
	264	MustHaveApp(wxDisplaySizeMM);
	265	DocDeclA(
	266	void, wxDisplaySizeMM(int* OUTPUT, int* OUTPUT),
	267	"DisplaySizeMM() -> (width, height)");
	268
	269	MustHaveApp(wxGetDisplaySizeMM);
	270	wxSize wxGetDisplaySizeMM();
	271
	272	MustHaveApp(wxClientDisplayRect);
	273	DocDeclA(
	274	void, wxClientDisplayRect(int OUTPUT, int OUTPUT, int OUTPUT, int OUTPUT),
	275	"ClientDisplayRect() -> (x, y, width, height)");
	276
	277	MustHaveApp(wxGetClientDisplayRect);
	278	wxRect wxGetClientDisplayRect();
	279
	280
	281	MustHaveApp(wxSetCursor);
	282	void wxSetCursor(wxCursor& cursor);
	283
	284
	285	MustHaveApp(wxGetXDisplay);
	286	DocStr(wxGetXDisplay,
	287	"Returns a swigified pointer to the X11 display. Returns None on
	288	other platforms.", "");
	289	%inline %{
	290	void* wxGetXDisplay()
	291	{
	292	#ifdef __WXGTK__
	293	return wxGetDisplay();
	294	#else
	295	return NULL;
	296	#endif
	297	}
	298	%}
	299
	300
	301	// Miscellaneous functions
	302
	303	MustHaveApp(wxBeginBusyCursor);
	304	void wxBeginBusyCursor(wxCursor *cursor = wxHOURGLASS_CURSOR);
	305
	306
	307	MustHaveApp(wxGetMousePosition);
	308	DocDeclStr(
	309	wxPoint, wxGetMousePosition(),
	310	"Get the current mouse position on the screen.", "");
	311
	312	MustHaveApp(FindWindowAtPointer);
	313	DocStr(FindWindowAtPointer,
	314	"Returns the window currently under the mouse pointer, if it belongs to
	315	this application. Otherwise it returns None.", "");
	316	%inline %{
	317	wxWindow* FindWindowAtPointer() {
	318	wxPoint unused;
	319	return wxFindWindowAtPointer(unused);
	320	}
	321	%}
	322
	323
	324	MustHaveApp(wxGetActiveWindow);
	325	DocDeclStr(
	326	wxWindow *, wxGetActiveWindow(),
	327	"Get the currently active window of this application, or None", "");
	328
	329
	330	MustHaveApp(wxGenericFindWindowAtPoint);
	331	wxWindow* wxGenericFindWindowAtPoint(const wxPoint& pt);
	332
	333	MustHaveApp(wxFindWindowAtPoint);
	334	wxWindow* wxFindWindowAtPoint(const wxPoint& pt);
	335
	336	MustHaveApp(wxGetTopLevelParent);
	337	wxWindow* wxGetTopLevelParent(wxWindow *win);
	338
	339
	340	// flags for wxLaunchDefaultBrowser
	341	enum
	342	{
	343	wxBROWSER_NEW_WINDOW = 1
	344	};
	345
	346	DocDeclStr(
	347	bool , wxLaunchDefaultBrowser(const wxString& url, int flags = 0),
	348	"Launches the user's default browser and tells it to open the location
	349	at ``url``. Returns ``True`` if the application was successfully
	350	launched.", "");
	351
	352
	353
	354	MustHaveApp(wxGetKeyState);
	355	DocDeclStr(
	356	bool , wxGetKeyState(wxKeyCode key),
	357	"Get the state of a key (true if pressed or toggled on, false if not.)
	358	This is generally most useful getting the state of the modifier or
	359	toggle keys. On some platforms those may be the only keys that this
	360	function is able to detect.
	361	", "");
	362
	363
	364
	365	//---------------------------------------------------------------------------
	366
	367	DocStr(wxMouseState,
	368	"`wx.MouseState` is used to hold information about mouse button and
	369	modifier key states and is what is returned from `wx.GetMouseState`.",
	370	"");
	371
	372	class wxMouseState
	373	{
	374	public:
	375	wxMouseState();
	376	~wxMouseState();
	377
	378	wxCoord GetX();
	379	wxCoord GetY();
	380
	381	bool LeftDown();
	382	bool MiddleDown();
	383	bool RightDown();
	384
	385	bool ControlDown();
	386	bool ShiftDown();
	387	bool AltDown();
	388	bool MetaDown();
	389	bool CmdDown();
	390
	391	void SetX(wxCoord x);
	392	void SetY(wxCoord y);
	393
	394	void SetLeftDown(bool down);
	395	void SetMiddleDown(bool down);
	396	void SetRightDown(bool down);
	397
	398	void SetControlDown(bool down);
	399	void SetShiftDown(bool down);
	400	void SetAltDown(bool down);
	401	void SetMetaDown(bool down);
	402
	403	%pythoncode {
	404	x = property(GetX, SetX)
	405	y = property(GetY, SetY)
	406	leftDown = property(LeftDown, SetLeftDown)
	407	middleDown = property(MiddleDown, SetMiddleDown)
	408	rightDown = property(RightDown, SetRightDown)
	409	controlDown = property(ControlDown, SetControlDown)
	410	shiftDown = property(ShiftDown, SetShiftDown)
	411	altDown = property(AltDown, SetAltDown)
	412	metaDown = property(MetaDown, SetMetaDown)
	413	cmdDown = property(CmdDown)
	414	}
	415	};
	416
	417
	418	DocDeclStr(
	419	wxMouseState , wxGetMouseState(),
	420	"Returns the current state of the mouse. Returns an instance of a
	421	`wx.MouseState` object that contains the current position of the mouse
	422	pointer in screen coordinants, as well as boolean values indicating
	423	the up/down status of the mouse buttons and the modifier keys.", "");
	424
	425
	426	//---------------------------------------------------------------------------
	427
	428	MustHaveApp(wxWakeUpMainThread);
	429
	430	#if defined(__WXMSW__) \|\| defined(__WXMAC__)
	431	void wxWakeUpMainThread();
	432	#else
	433	%inline %{
	434	void wxWakeUpMainThread() {}
	435	%}
	436	#endif
	437
	438
	439	MustHaveApp(wxMutexGuiEnter);
	440	void wxMutexGuiEnter();
	441
	442	MustHaveApp(wxMutexGuiLeave);
	443	void wxMutexGuiLeave();
	444
	445
	446	MustHaveApp(wxMutexGuiLocker);
	447	class wxMutexGuiLocker {
	448	public:
	449	wxMutexGuiLocker();
	450	~wxMutexGuiLocker();
	451	};
	452
	453
	454	MustHaveApp(wxThread);
	455	%inline %{
	456	bool wxThread_IsMain() {
	457	#ifdef WXP_WITH_THREAD
	458	return wxThread::IsMain();
	459	#else
	460	return true;
	461	#endif
	462	}
	463	%}
	464
	465	//---------------------------------------------------------------------------
	466	//---------------------------------------------------------------------------