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


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	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	DocDeclStr(
	341	bool , wxLaunchDefaultBrowser(const wxString& url),
	342	"Launches the user's default browser and tells it to open the location
	343	at ``url``. Returns ``True`` if the application was successfully
	344	launched.", "");
	345
	346
	347
	348	MustHaveApp(wxGetKeyState);
	349	DocDeclStr(
	350	bool , wxGetKeyState(wxKeyCode key),
	351	"Get the state of a key (true if pressed or toggled on, false if not.)
	352	This is generally most useful getting the state of the modifier or
	353	toggle keys. On some platforms those may be the only keys that this
	354	function is able to detect.
	355	", "");
	356
	357
	358
	359	//---------------------------------------------------------------------------
	360
	361	DocStr(wxMouseState,
	362	"`wx.MouseState` is used to hold information about mouse button and
	363	modifier key states and is what is returned from `wx.GetMouseState`.",
	364	"");
	365
	366	class wxMouseState
	367	{
	368	public:
	369	wxMouseState();
	370	~wxMouseState();
	371
	372	wxCoord GetX();
	373	wxCoord GetY();
	374
	375	bool LeftDown();
	376	bool MiddleDown();
	377	bool RightDown();
	378
	379	bool ControlDown();
	380	bool ShiftDown();
	381	bool AltDown();
	382	bool MetaDown();
	383	bool CmdDown();
	384
	385	void SetX(wxCoord x);
	386	void SetY(wxCoord y);
	387
	388	void SetLeftDown(bool down);
	389	void SetMiddleDown(bool down);
	390	void SetRightDown(bool down);
	391
	392	void SetControlDown(bool down);
	393	void SetShiftDown(bool down);
	394	void SetAltDown(bool down);
	395	void SetMetaDown(bool down);
	396
	397	%pythoncode {
	398	x = property(GetX, SetX)
	399	y = property(GetY, SetY)
	400	leftDown = property(LeftDown, SetLeftDown)
	401	middleDown = property(MiddleDown, SetMiddleDown)
	402	rightDown = property(RightDown, SetRightDown)
	403	controlDown = property(ControlDown, SetControlDown)
	404	shiftDown = property(ShiftDown, SetShiftDown)
	405	altDown = property(AltDown, SetAltDown)
	406	metaDown = property(MetaDown, SetMetaDown)
	407	cmdDown = property(CmdDown)
	408	}
	409	};
	410
	411
	412	DocDeclStr(
	413	wxMouseState , wxGetMouseState(),
	414	"Returns the current state of the mouse. Returns an instance of a
	415	`wx.MouseState` object that contains the current position of the mouse
	416	pointer in screen coordinants, as well as boolean values indicating
	417	the up/down status of the mouse buttons and the modifier keys.", "");
	418
	419
	420	//---------------------------------------------------------------------------
	421
	422	MustHaveApp(wxWakeUpMainThread);
	423
	424	#if defined(__WXMSW__) \|\| defined(__WXMAC__)
	425	void wxWakeUpMainThread();
	426	#else
	427	%inline %{
	428	void wxWakeUpMainThread() {}
	429	%}
	430	#endif
	431
	432
	433	MustHaveApp(wxMutexGuiEnter);
	434	void wxMutexGuiEnter();
	435
	436	MustHaveApp(wxMutexGuiLeave);
	437	void wxMutexGuiLeave();
	438
	439
	440	MustHaveApp(wxMutexGuiLocker);
	441	class wxMutexGuiLocker {
	442	public:
	443	wxMutexGuiLocker();
	444	~wxMutexGuiLocker();
	445	};
	446
	447
	448	MustHaveApp(wxThread);
	449	%inline %{
	450	bool wxThread_IsMain() {
	451	#ifdef WXP_WITH_THREAD
	452	return wxThread::IsMain();
	453	#else
	454	return true;
	455	#endif
	456	}
	457	%}
	458
	459	//---------------------------------------------------------------------------
	460	//---------------------------------------------------------------------------