+The functions and macros defined in wxWidgets are described here: you can
+either look up a function using the alphabetical listing of them or find it in
+the corresponding topic.
+
+\section{Alphabetical functions and macros list}\label{functionsalphabetically}
+
+\helpref{CLASSINFO}{classinfo}\\
+\helpref{copystring}{copystring}\\
+\helpref{DECLARE\_ABSTRACT\_CLASS}{declareabstractclass}\\
+\helpref{DECLARE\_APP}{declareapp}\\
+\helpref{DECLARE\_CLASS}{declareclass}\\
+\helpref{DECLARE\_DYNAMIC\_CLASS}{declaredynamicclass}\\
+\helpref{IMPLEMENT\_ABSTRACT\_CLASS2}{implementabstractclass2}\\
+\helpref{IMPLEMENT\_ABSTRACT\_CLASS}{implementabstractclass}\\
+\helpref{IMPLEMENT\_APP}{implementapp}\\
+\helpref{IMPLEMENT\_CLASS2}{implementclass2}\\
+\helpref{IMPLEMENT\_CLASS}{implementclass}\\
+\helpref{IMPLEMENT\_DYNAMIC\_CLASS2}{implementdynamicclass2}\\
+\helpref{IMPLEMENT\_DYNAMIC\_CLASS}{implementdynamicclass}\\
+\helpref{wxCONCAT}{wxconcat}\\
+\helpref{WXDEBUG\_NEW}{debugnew}\\
+\helpref{WXTRACELEVEL}{tracelevel}\\
+\helpref{WXTRACE}{trace}\\
+\helpref{wxASSERT\_MIN\_BITSIZE}{wxassertminbitsize}\\
+\helpref{wxASSERT\_MSG}{wxassertmsg}\\
+\helpref{wxASSERT}{wxassert}\\
+\helpref{wxBITMAP}{wxbitmapmacro}\\
+\helpref{wxBeginBusyCursor}{wxbeginbusycursor}\\
+\helpref{wxBell}{wxbell}\\
+\helpref{wxCHANGE\_UMASK}{wxchangeumask}\\
+\helpref{wxCHECK}{wxcheck}\\
+\helpref{wxCHECK2\_MSG}{wxcheck2msg}\\
+\helpref{wxCHECK2}{wxcheck2}\\
+\helpref{wxCHECK\_GCC\_VERSION}{wxcheckgccversion}\\
+\helpref{wxCHECK\_MSG}{wxcheckmsg}\\
+\helpref{wxCHECK\_RET}{wxcheckret}\\
+\helpref{wxCHECK\_VERSION}{wxcheckversion}\\
+\helpref{wxCHECK\_VERSION\_FULL}{wxcheckversionfull}\\
+\helpref{wxCHECK\_W32API\_VERSION}{wxcheckw32apiversion}\\
+\helpref{wxClientDisplayRect}{wxclientdisplayrect}\\
+\helpref{wxClipboardOpen}{functionwxclipboardopen}\\
+\helpref{wxCloseClipboard}{wxcloseclipboard}\\
+\helpref{wxColourDisplay}{wxcolourdisplay}\\
+\helpref{wxCOMPILE\_TIME\_ASSERT}{wxcompiletimeassert}\\
+\helpref{wxCOMPILE\_TIME\_ASSERT2}{wxcompiletimeassert2}\\
+\helpref{wxConcatFiles}{wxconcatfiles}\\
+\helpref{wxConstCast}{wxconstcast}\\
+\helpref{wxCopyFile}{wxcopyfile}\\
+\helpref{wxCreateDynamicObject}{wxcreatedynamicobject}\\
+\helpref{wxCreateFileTipProvider}{wxcreatefiletipprovider}\\
+\helpref{wxCRIT\_SECT\_DECLARE}{wxcritsectdeclare}\\
+\helpref{wxCRIT\_SECT\_DECLARE\_MEMBER}{wxcritsectdeclaremember}\\
+\helpref{wxCRIT\_SECT\_LOCKER}{wxcritsectlocker}\\
+\helpref{wxCRITICAL\_SECTION}{wxcriticalsectionmacro}\\ % wxcs already taken!
+\helpref{wxDDECleanUp}{wxddecleanup}\\
+\helpref{wxDDEInitialize}{wxddeinitialize}\\
+\helpref{wxDROP\_ICON}{wxdropicon}\\
+\helpref{wxDebugMsg}{wxdebugmsg}\\
+\helpref{wxDirExists}{functionwxdirexists}\\
+\helpref{wxDirSelector}{wxdirselector}\\
+\helpref{wxDisplayDepth}{wxdisplaydepth}\\
+\helpref{wxDisplaySize}{wxdisplaysize}\\
+\helpref{wxDisplaySizeMM}{wxdisplaysizemm}\\
+\helpref{wxDos2UnixFilename}{wxdos2unixfilename}\\
+\helpref{wxDynamicCastThis}{wxdynamiccastthis}\\
+\helpref{wxDynamicCast}{wxdynamiccast}\\
+\helpref{wxDYNLIB\_FUNCTION}{wxdynlibfunction}\\
+\helpref{wxEmptyClipboard}{wxemptyclipboard}\\
+\helpref{wxEnableTopLevelWindows}{wxenabletoplevelwindows}\\
+\helpref{wxEndBusyCursor}{wxendbusycursor}\\
+\helpref{wxENTER\_CRIT\_SECT}{wxentercritsect}\\
+\helpref{wxEntry}{wxentry}\\
+\helpref{wxEnumClipboardFormats}{wxenumclipboardformats}\\
+\helpref{wxError}{wxerror}\\
+\helpref{wxExecute}{wxexecute}\\
+\helpref{wxExit}{wxexit}\\
+\helpref{wxEXPLICIT}{wxexplicit}\\
+\helpref{wxFAIL\_MSG}{wxfailmsg}\\
+\helpref{wxFAIL}{wxfail}\\
+\helpref{wxFatalError}{wxfatalerror}\\
+\helpref{wxFileExists}{functionwxfileexists}\\
+\helpref{wxFileModificationTime}{wxfilemodificationtime}\\
+\helpref{wxFileNameFromPath}{wxfilenamefrompath}\\
+\helpref{wxFileSelector}{wxfileselector}\\
+\helpref{wxFindFirstFile}{wxfindfirstfile}\\
+\helpref{wxFindMenuItemId}{wxfindmenuitemid}\\
+\helpref{wxFindNextFile}{wxfindnextfile}\\
+\helpref{wxFindWindowAtPointer}{wxfindwindowatpointer}\\
+\helpref{wxFindWindowAtPoint}{wxfindwindowatpoint}\\
+\helpref{wxFindWindowByLabel}{wxfindwindowbylabel}\\
+\helpref{wxFindWindowByName}{wxfindwindowbyname}\\
+\helpref{wxFinite}{wxfinite}\\
+\helpref{wxGetActiveWindow}{wxgetactivewindow}\\
+\helpref{wxGetApp}{wxgetapp}\\
+\helpref{wxGetClipboardData}{wxgetclipboarddata}\\
+\helpref{wxGetClipboardFormatName}{wxgetclipboardformatname}\\
+\helpref{wxGetColourFromUser}{wxgetcolourfromuser}\\
+\helpref{wxGetCwd}{wxgetcwd}\\
+\helpref{wxGetDiskSpace}{wxgetdiskspace}\\
+\helpref{wxGetDisplayName}{wxgetdisplayname}\\
+\helpref{wxGetDisplaySize}{wxdisplaysize}\\
+\helpref{wxGetDisplaySizeMM}{wxdisplaysizemm}\\
+\helpref{wxGetElapsedTime}{wxgetelapsedtime}\\
+\helpref{wxGetEmailAddress}{wxgetemailaddress}\\
+\helpref{wxGetEnv}{wxgetenv}\\
+\helpref{wxGetFontFromUser}{wxgetfontfromuser}\\
+\helpref{wxGetFreeMemory}{wxgetfreememory}\\
+\helpref{wxGetFullHostName}{wxgetfullhostname}\\
+\helpref{wxGetHomeDir}{wxgethomedir}\\
+\helpref{wxGetHostName}{wxgethostname}\\
+\helpref{wxGetKeyState}{wxgetkeystate}\\
+\helpref{wxGetLocalTimeMillis}{wxgetlocaltimemillis}\\
+\helpref{wxGetLocalTime}{wxgetlocaltime}\\
+\helpref{wxGetMousePosition}{wxgetmouseposition}\\
+\helpref{wxGetMultipleChoices}{wxgetmultiplechoices}\\
+\helpref{wxGetMultipleChoice}{wxgetmultiplechoice}\\
+\helpref{wxGetNumberFromUser}{wxgetnumberfromuser}\\
+\helpref{wxGetOSDirectory}{wxgetosdirectory}\\
+\helpref{wxGetOsDescription}{wxgetosdescription}\\
+\helpref{wxGetOsVersion}{wxgetosversion}\\
+\helpref{wxGetPasswordFromUser}{wxgetpasswordfromuser}\\
+\helpref{wxGetPrinterCommand}{wxgetprintercommand}\\
+\helpref{wxGetPrinterFile}{wxgetprinterfile}\\
+\helpref{wxGetPrinterMode}{wxgetprintermode}\\
+\helpref{wxGetPrinterOptions}{wxgetprinteroptions}\\
+\helpref{wxGetPrinterOrientation}{wxgetprinterorientation}\\
+\helpref{wxGetPrinterPreviewCommand}{wxgetprinterpreviewcommand}\\
+\helpref{wxGetPrinterScaling}{wxgetprinterscaling}\\
+\helpref{wxGetPrinterTranslation}{wxgetprintertranslation}\\
+\helpref{wxGetProcessId}{wxgetprocessid}\\
+\helpref{wxGetResource}{wxgetresource}\\
+\helpref{wxGetSingleChoiceData}{wxgetsinglechoicedata}\\
+\helpref{wxGetSingleChoiceIndex}{wxgetsinglechoiceindex}\\
+\helpref{wxGetSingleChoice}{wxgetsinglechoice}\\
+\helpref{wxGetTempFileName}{wxgettempfilename}\\
+\helpref{wxGetTextFromUser}{wxgettextfromuser}\\
+\helpref{wxGetTopLevelParent}{wxgettoplevelparent}\\
+\helpref{wxGetTranslation}{wxgettranslation}\\
+\helpref{wxGetUTCTime}{wxgetutctime}\\
+\helpref{wxGetUserHome}{wxgetuserhome}\\
+\helpref{wxGetUserId}{wxgetuserid}\\
+\helpref{wxGetUserName}{wxgetusername}\\
+\helpref{wxGetWorkingDirectory}{wxgetworkingdirectory}\\
+\helpref{wxGetenv}{wxgetenvmacro}\\
+\helpref{wxHandleFatalExceptions}{wxhandlefatalexceptions}\\
+\helpref{wxICON}{wxiconmacro}\\
+\helpref{wxINTXX\_SWAP\_ALWAYS}{intswapalways}\\
+\helpref{wxINTXX\_SWAP\_ON\_BE}{intswaponbe}\\
+\helpref{wxINTXX\_SWAP\_ON\_LE}{intswaponle}\\
+\helpref{wxInitAllImageHandlers}{wxinitallimagehandlers}\\
+\helpref{wxInitialize}{wxinitialize}\\
+\helpref{wxIsAbsolutePath}{wxisabsolutepath}\\
+\helpref{wxIsBusy}{wxisbusy}\\
+\helpref{wxIsClipboardFormatAvailable}{wxisclipboardformatavailable}\\
+\helpref{wxIsDebuggerRunning}{wxisdebuggerrunning}\\
+\helpref{wxIsEmpty}{wxisempty}\\
+\helpref{wxIsMainThread}{wxismainthread}\\
+\helpref{wxIsNaN}{wxisnan}\\
+\helpref{wxIsWild}{wxiswild}\\
+\helpref{wxKill}{wxkill}\\
+\helpref{wxLEAVE\_CRIT\_SECT}{wxleavecritsect}\\
+\helpref{wxLoadUserResource}{wxloaduserresource}\\
+\helpref{wxLogDebug}{wxlogdebug}\\
+\helpref{wxLogError}{wxlogerror}\\
+\helpref{wxLogFatalError}{wxlogfatalerror}\\
+\helpref{wxLogMessage}{wxlogmessage}\\
+\helpref{wxLogStatus}{wxlogstatus}\\
+\helpref{wxLogSysError}{wxlogsyserror}\\
+\helpref{wxLogTrace}{wxlogtrace}\\
+\helpref{wxLogVerbose}{wxlogverbose}\\
+\helpref{wxLogWarning}{wxlogwarning}\\
+\helpref{wxLL}{wxll}\\
+\helpref{wxLongLongFmtSpec}{wxlonglongfmtspec}\\
+\helpref{wxMakeMetafilePlaceable}{wxmakemetafileplaceable}\\
+\helpref{wxMatchWild}{wxmatchwild}\\
+\helpref{wxMessageBox}{wxmessagebox}\\
+\helpref{wxMilliSleep}{wxmillisleep}\\
+\helpref{wxMicroSleep}{wxmicrosleep}\\
+\helpref{wxMkdir}{wxmkdir}\\
+\helpref{wxMutexGuiEnter}{wxmutexguienter}\\
+\helpref{wxMutexGuiLeave}{wxmutexguileave}\\
+\helpref{wxNewId}{wxnewid}\\
+\helpref{wxNow}{wxnow}\\
+\helpref{wxOnAssert}{wxonassert}\\
+\helpref{wxOpenClipboard}{wxopenclipboard}\\
+\helpref{wxParseCommonDialogsFilter}{wxparsecommondialogsfilter}\\
+\helpref{wxPathOnly}{wxpathonly}\\
+\helpref{wxPostDelete}{wxpostdelete}\\
+\helpref{wxPostEvent}{wxpostevent}\\
+\helpref{wxRegisterClipboardFormat}{wxregisterclipboardformat}\\
+\helpref{wxRegisterId}{wxregisterid}\\
+\helpref{wxRemoveFile}{wxremovefile}\\
+\helpref{wxRenameFile}{wxrenamefile}\\
+\helpref{wxRmdir}{wxrmdir}\\
+\helpref{wxSafeShowMessage}{wxsafeshowmessage}\\
+\helpref{wxSafeYield}{wxsafeyield}\\
+\helpref{wxSetClipboardData}{wxsetclipboarddata}\\
+\helpref{wxSetCursor}{wxsetcursor}\\
+\helpref{wxSetDisplayName}{wxsetdisplayname}\\
+\helpref{wxSetEnv}{wxsetenv}\\
+\helpref{wxSetPrinterCommand}{wxsetprintercommand}\\
+\helpref{wxSetPrinterFile}{wxsetprinterfile}\\
+\helpref{wxSetPrinterMode}{wxsetprintermode}\\
+\helpref{wxSetPrinterOptions}{wxsetprinteroptions}\\
+\helpref{wxSetPrinterOrientation}{wxsetprinterorientation}\\
+\helpref{wxSetPrinterPreviewCommand}{wxsetprinterpreviewcommand}\\
+\helpref{wxSetPrinterScaling}{wxsetprinterscaling}\\
+\helpref{wxSetPrinterTranslation}{wxsetprintertranslation}\\
+\helpref{wxSetWorkingDirectory}{wxsetworkingdirectory}\\
+\helpref{wxShell}{wxshell}\\
+\helpref{wxShowTip}{wxshowtip}\\
+\helpref{wxShutdown}{wxshutdown}\\
+\helpref{wxSleep}{wxsleep}\\
+\helpref{wxSnprintf}{wxsnprintf}\\
+\helpref{wxSplitPath}{wxsplitfunction}\\
+\helpref{wxStartTimer}{wxstarttimer}\\
+\helpref{wxStaticCast}{wxstaticcast}\\
+\helpref{wxStrcmp}{wxstrcmp}\\
+\helpref{wxStricmp}{wxstricmp}\\
+\helpref{wxStringEq}{wxstringeq}\\
+\helpref{wxStringMatch}{wxstringmatch}\\
+\helpref{wxStripMenuCodes}{wxstripmenucodes}\\
+\helpref{wxStrlen}{wxstrlen}\\
+\helpref{wxSysErrorCode}{wxsyserrorcode}\\
+\helpref{wxSysErrorMsg}{wxsyserrormsg}\\
+\helpref{wxT}{wxt}\\
+\helpref{wxTraceLevel}{wxtracelevel}\\
+\helpref{wxTrace}{wxtrace}\\
+\helpref{wxTransferFileToStream}{wxtransferfiletostream}\\
+\helpref{wxTransferStreamToFile}{wxtransferstreamtofile}\\
+\helpref{wxTrap}{wxtrap}\\
+\helpref{wxULL}{wxull}\\
+\helpref{wxUninitialize}{wxuninitialize}\\
+\helpref{wxUnix2DosFilename}{wxunix2dosfilename}\\
+\helpref{wxUnsetEnv}{wxunsetenv}\\
+\helpref{wxUsleep}{wxusleep}\\
+\helpref{wxVaCopy}{wxvacopy}\\
+\helpref{wxVsnprintf}{wxvsnprintf}\\
+\helpref{wxWakeUpIdle}{wxwakeupidle}\\
+\helpref{wxWriteResource}{wxwriteresource}\\
+\helpref{wxYield}{wxyield}\\
+\helpref{wx\_const\_cast}{wxconstcastraw}\\
+\helpref{wx\_reinterpret\_cast}{wxreinterpretcastraw}\\
+\helpref{wx\_static\_cast}{wxstaticcastraw}\\
+\helpref{\_}{underscore}\\
+\helpref{\_T}{underscoret}
+
+
+
+\section{Version macros}\label{versionfunctions}
+
+The following constants are defined in wxWidgets:
+
+\begin{itemize}\itemsep=0pt
+\item {\tt wxMAJOR\_VERSION} is the major version of wxWidgets
+\item {\tt wxMINOR\_VERSION} is the minor version of wxWidgets
+\item {\tt wxRELEASE\_NUMBER} is the release number
+\item {\tt wxSUBRELEASE\_NUMBER} is the subrelease number which is $0$ for all
+official releases
+\end{itemize}
+
+For example, the values or these constants for wxWidgets 2.1.15 are 2, 1 and
+15.
+
+Additionally, {\tt wxVERSION\_STRING} is a user-readable string containing
+the full wxWidgets version and {\tt wxVERSION\_NUMBER} is a combination of the
+three version numbers above: for 2.1.15, it is 2115 and it is 2200 for
+wxWidgets 2.2.
+
+The subrelease number is only used for the sources in between official releases
+and so normally is not useful.
+
+\wxheading{Include files}
+
+<wx/version.h> or <wx/defs.h>
+
+
+\membersection{wxCHECK\_GCC\_VERSION}\label{wxcheckgccversion}
+
+\func{bool}{wxCHECK\_GCC\_VERSION}{\param{}{major, minor, release}}
+
+Returns $1$ if the compiler being used to compile the code is GNU C++
+compiler (g++) version major.minor.release or greater. Otherwise, and also if
+the compiler is not GNU C++ at all, returns $0$.
+
+
+\membersection{wxCHECK\_VERSION}\label{wxcheckversion}
+
+\func{bool}{wxCHECK\_VERSION}{\param{}{major, minor, release}}
+
+This is a macro which evaluates to true if the current wxWidgets version is at
+least major.minor.release.
+
+For example, to test if the program is compiled with wxWidgets 2.2 or higher,
+the following can be done:
+
+\begin{verbatim}
+ wxString s;
+#if wxCHECK_VERSION(2, 2, 0)
+ if ( s.StartsWith("foo") )
+#else // replacement code for old version
+ if ( strncmp(s, "foo", 3) == 0 )
+#endif
+ {
+ ...
+ }
+\end{verbatim}
+
+
+\membersection{wxCHECK\_VERSION\_FULL}\label{wxcheckversionfull}
+
+\func{bool}{wxCHECK\_VERSION\_FULL}{\param{}{major, minor, release, subrel}}
+
+Same as \helpref{wxCHECK\_VERSION}{wxcheckversion} but also checks that
+\texttt{wxSUBRELEASE\_NUMBER} is at least \arg{subrel}.
+
+
+\membersection{wxCHECK\_W32API\_VERSION}\label{wxcheckw32apiversion}
+
+\func{bool}{wxCHECK\_GCC\_VERSION}{\param{}{major, minor, release}}
+
+Returns $1$ if the version of w32api headers used is major.minor.release or
+greater. Otherwise, and also if we are not compiling with mingw32/cygwin under
+Win32 at all, returns $0$.
+
+
+
+\section{Application initialization and termination}\label{appinifunctions}
+
+The functions in this section are used on application startup/shutdown and also
+to control the behaviour of the main event loop of the GUI programs.
+
+
+\membersection{::wxEntry}\label{wxentry}
+
+This initializes wxWidgets in a platform-dependent way. Use this if you
+are not using the default wxWidgets entry code (e.g. main or WinMain). For example,
+you can initialize wxWidgets from an Microsoft Foundation Classes application using
+this function.
+
+\func{void}{wxEntry}{\param{HANDLE}{ hInstance}, \param{HANDLE}{ hPrevInstance},
+ \param{const wxString\& }{commandLine}, \param{int}{ cmdShow}, \param{bool}{ enterLoop = true}}
+
+wxWidgets initialization under Windows (non-DLL). If {\it enterLoop} is false, the
+function will return immediately after calling wxApp::OnInit. Otherwise, the wxWidgets
+message loop will be entered.
+
+\func{void}{wxEntry}{\param{HANDLE}{ hInstance}, \param{HANDLE}{ hPrevInstance},
+ \param{WORD}{ wDataSegment}, \param{WORD}{ wHeapSize}, \param{const wxString\& }{ commandLine}}
+
+wxWidgets initialization under Windows (for applications constructed as a DLL).
+
+\func{int}{wxEntry}{\param{int}{ argc}, \param{const wxString\& *}{argv}}
+
+wxWidgets initialization under Unix.
+
+\wxheading{Remarks}
+
+To clean up wxWidgets, call wxApp::OnExit followed by the static function
+wxApp::CleanUp. For example, if exiting from an MFC application that also uses wxWidgets:
+
+\begin{verbatim}
+int CTheApp::ExitInstance()
+{
+ // OnExit isn't called by CleanUp so must be called explicitly.
+ wxTheApp->OnExit();
+ wxApp::CleanUp();
+
+ return CWinApp::ExitInstance();
+}
+\end{verbatim}
+
+\wxheading{Include files}
+
+<wx/app.h>
+
+
+
+\membersection{::wxGetApp}\label{wxgetapp}
+
+\func{wxAppDerivedClass\&}{wxGetApp}{\void}
+
+This function doesn't exist in wxWidgets but it is created by using
+the \helpref{IMPLEMENT\_APP}{implementapp} macro. Thus, before using it
+anywhere but in the same module where this macro is used, you must make it
+available using \helpref{DECLARE\_APP}{declareapp}.
+
+The advantage of using this function compared to directly using the global
+wxTheApp pointer is that the latter is of type {\tt wxApp *} and so wouldn't
+allow you to access the functions specific to your application class but not
+present in wxApp while wxGetApp() returns the object of the right type.
+
+
+\membersection{::wxHandleFatalExceptions}\label{wxhandlefatalexceptions}
+
+\func{bool}{wxHandleFatalExceptions}{\param{bool}{ doIt = true}}
+
+If {\it doIt} is true, the fatal exceptions (also known as general protection
+faults under Windows or segmentation violations in the Unix world) will be
+caught and passed to \helpref{wxApp::OnFatalException}{wxapponfatalexception}.
+By default, i.e. before this function is called, they will be handled in the
+normal way which usually just means that the application will be terminated.
+Calling wxHandleFatalExceptions() with {\it doIt} equal to false will restore
+this default behaviour.
+
+
+\membersection{::wxInitAllImageHandlers}\label{wxinitallimagehandlers}
+
+\func{void}{wxInitAllImageHandlers}{\void}
+
+Initializes all available image handlers. For a list of available handlers,
+see \helpref{wxImage}{wximage}.
+
+\wxheading{See also}
+
+\helpref{wxImage}{wximage}, \helpref{wxImageHandler}{wximagehandler}
+
+\wxheading{Include files}
+
+<wx/image.h>
+
+
+\membersection{::wxInitialize}\label{wxinitialize}
+
+\func{bool}{wxInitialize}{\void}
+
+This function is used in wxBase only and only if you don't create
+\helpref{wxApp}{wxapp} object at all. In this case you must call it from your
+{\tt main()} function before calling any other wxWidgets functions.
+
+If the function returns {\tt false} the initialization could not be performed,
+in this case the library cannot be used and
+\helpref{wxUninitialize}{wxuninitialize} shouldn't be called neither.
+
+This function may be called several times but
+\helpref{wxUninitialize}{wxuninitialize} must be called for each successful
+call to this function.
+
+\wxheading{Include files}
+
+<wx/app.h>
+
+
+\membersection{::wxSafeYield}\label{wxsafeyield}
+
+\func{bool}{wxSafeYield}{\param{wxWindow*}{ win = NULL}, \param{bool}{
+ onlyIfNeeded = false}}
+
+This function is similar to wxYield, except that it disables the user input to
+all program windows before calling wxYield and re-enables it again
+afterwards. If {\it win} is not NULL, this window will remain enabled,
+allowing the implementation of some limited user interaction.
+
+Returns the result of the call to \helpref{::wxYield}{wxyield}.
+
+\wxheading{Include files}
+
+<wx/utils.h>
+
+
+\membersection{::wxUninitialize}\label{wxuninitialize}
+
+\func{void}{wxUninitialize}{\void}
+
+This function is for use in console (wxBase) programs only. It must be called
+once for each previous successful call to \helpref{wxInitialize}{wxinitialize}.
+
+\wxheading{Include files}
+
+<wx/app.h>
+
+
+\membersection{::wxYield}\label{wxyield}
+
+\func{bool}{wxYield}{\void}
+
+Calls \helpref{wxApp::Yield}{wxappyield}.
+
+This function is kept only for backwards compatibility. Please use
+the \helpref{wxApp::Yield}{wxappyield} method instead in any new code.
+
+\wxheading{Include files}
+
+<wx/app.h> or <wx/utils.h>
+
+
+\membersection{::wxWakeUpIdle}\label{wxwakeupidle}
+
+\func{void}{wxWakeUpIdle}{\void}
+
+This functions wakes up the (internal and platform dependent) idle system, i.e. it
+will force the system to send an idle event even if the system currently {\it is}
+ idle and thus would not send any idle event until after some other event would get
+sent. This is also useful for sending events between two threads and is used by
+the corresponding functions \helpref{::wxPostEvent}{wxpostevent} and
+\helpref{wxEvtHandler::AddPendingEvent}{wxevthandleraddpendingevent}.
+
+\wxheading{Include files}
+
+<wx/event.h>
+
+
+
+\section{Process control functions}\label{processfunctions}
+
+The functions in this section are used to launch or terminate the other
+processes.
+
+
+\membersection{::wxExecute}\label{wxexecute}
+
+\func{long}{wxExecute}{\param{const wxString\& }{command}, \param{int }{sync = wxEXEC\_ASYNC}, \param{wxProcess *}{callback = NULL}}
+
+\perlnote{In wxPerl this function is called \texttt{Wx::ExecuteCommand}}
+
+\func{long}{wxExecute}{\param{char **}{argv}, \param{int }{flags = wxEXEC\_ASYNC}, \param{wxProcess *}{callback = NULL}}
+
+\perlnote{In wxPerl this function is called \texttt{Wx::ExecuteArgs}}
+
+\func{long}{wxExecute}{\param{const wxString\& }{command}, \param{wxArrayString\& }{output}, \param{int }{flags = 0}}
+
+\perlnote{In wxPerl this function is called \texttt{Wx::ExecuteStdout} and it
+only takes the {\tt command} argument,
+and returns a 2-element list {\tt ( status, output )}, where {\tt output} is
+an array reference.}
+
+\func{long}{wxExecute}{\param{const wxString\& }{command}, \param{wxArrayString\& }{output}, \param{wxArrayString\& }{errors}, \param{int }{flags = 0}}
+
+\perlnote{In wxPerl this function is called \texttt{Wx::ExecuteStdoutStderr}
+and it only takes the {\tt command} argument,
+and returns a 3-element list {\tt ( status, output, errors )}, where
+{\tt output} and {\tt errors} are array references.}
+
+Executes another program in Unix or Windows.
+
+The first form takes a command string, such as {\tt "emacs file.txt"}.
+
+The second form takes an array of values: a command, any number of
+arguments, terminated by NULL.
+
+The semantics of the third and fourth versions is different from the first two
+and is described in more details below.
+
+If {\it flags} parameter contains {\tt wxEXEC\_ASYNC} flag (the default), flow
+of control immediately returns. If it contains {\tt wxEXEC\_SYNC}, the current
+application waits until the other program has terminated.
+
+In the case of synchronous execution, the return value is the exit code of
+the process (which terminates by the moment the function returns) and will be
+$-1$ if the process couldn't be started and typically 0 if the process
+terminated successfully. Also, while waiting for the process to
+terminate, wxExecute will call \helpref{wxYield}{wxyield}. Because of this, by
+default this function disables all application windows to avoid unexpected
+reentrancies which could result from the users interaction with the program
+while the child process is running. If you are sure that it is safe to not
+disable the program windows, you may pass \texttt{wxEXEC\_NODISABLE} flag to
+prevent this automatic disabling from happening.
+
+For asynchronous execution, however, the return value is the process id and
+zero value indicates that the command could not be executed. As an added
+complication, the return value of $-1$ in this case indicates that we didn't
+launch a new process, but connected to the running one (this can only happen in
+case of using DDE under Windows for command execution). In particular, in this,
+and only this, case the calling code will not get the notification about
+process termination.
+
+If callback isn't NULL and if execution is asynchronous,
+\helpref{wxProcess::OnTerminate}{wxprocessonterminate} will be called when
+the process finishes. Specifying this parameter also allows you to redirect the
+standard input and/or output of the process being launched by calling
+\helpref{Redirect}{wxprocessredirect}. If the child process IO is redirected,
+under Windows the process window is not shown by default (this avoids having to
+flush an unnecessary console for the processes which don't create any windows
+anyhow) but a {\tt wxEXEC\_NOHIDE} flag can be used to prevent this from
+happening, i.e. with this flag the child process window will be shown normally.
+
+Under Unix the flag {\tt wxEXEC\_MAKE\_GROUP\_LEADER} may be used to ensure
+that the new process is a group leader (this will create a new session if
+needed). Calling \helpref{wxKill}{wxkill} passing wxKILL\_CHILDREN will
+will kill this process as well as all of its children (except those which have
+started their own session).
+
+Finally, you may use the third overloaded version of this function to execute
+a process (always synchronously, the contents of \arg{flags} is or'd with
+\textt{wxEXEC\_SYNC}) and capture its output in the array \arg{output}. The
+fourth version adds the possibility to additionally capture the messages from
+standard error output in the \arg{errors} array.
+
+{\bf NB:} Currently wxExecute() can only be used from the main thread, calling
+this function from another thread will result in an assert failure in debug
+build and won't work.
+
+\wxheading{See also}
+
+\helpref{wxShell}{wxshell}, \helpref{wxProcess}{wxprocess}, \helpref{Exec sample}{sampleexec}.
+
+\wxheading{Parameters}
+
+\docparam{command}{The command to execute and any parameters to pass to it as a
+single string.}
+
+\docparam{argv}{The command to execute should be the first element of this
+array, any additional ones are the command parameters and the array must be
+terminated with a NULL pointer.}
+
+\docparam{flags}{Combination of bit masks {\tt wxEXEC\_ASYNC},\rtfsp
+{\tt wxEXEC\_SYNC} and {\tt wxEXEC\_NOHIDE}}
+
+\docparam{callback}{An optional pointer to \helpref{wxProcess}{wxprocess}}
+
+\wxheading{Include files}
+
+<wx/utils.h>
+
+
+\membersection{::wxExit}\label{wxexit}
+
+\func{void}{wxExit}{\void}
+
+Exits application after calling \helpref{wxApp::OnExit}{wxapponexit}.
+Should only be used in an emergency: normally the top-level frame
+should be deleted (after deleting all other frames) to terminate the
+application. See \helpref{wxCloseEvent}{wxcloseevent} and \helpref{wxApp}{wxapp}.
+
+\wxheading{Include files}
+
+<wx/app.h>
+
+
+\membersection{::wxKill}\label{wxkill}
+
+\func{int}{wxKill}{\param{long}{ pid}, \param{int}{ sig = wxSIGTERM}, \param{wxKillError }{*rc = NULL}, \param{int }{flags = 0}}
+
+Equivalent to the Unix kill function: send the given signal {\it sig} to the
+process with PID {\it pid}. The valid signal values are
+
+\begin{verbatim}
+enum wxSignal
+{
+ wxSIGNONE = 0, // verify if the process exists under Unix
+ wxSIGHUP,
+ wxSIGINT,
+ wxSIGQUIT,
+ wxSIGILL,
+ wxSIGTRAP,
+ wxSIGABRT,
+ wxSIGEMT,
+ wxSIGFPE,
+ wxSIGKILL, // forcefully kill, dangerous!
+ wxSIGBUS,
+ wxSIGSEGV,
+ wxSIGSYS,
+ wxSIGPIPE,
+ wxSIGALRM,
+ wxSIGTERM // terminate the process gently
+};
+\end{verbatim}
+
+{\tt wxSIGNONE}, {\tt wxSIGKILL} and {\tt wxSIGTERM} have the same meaning
+under both Unix and Windows but all the other signals are equivalent to
+{\tt wxSIGTERM} under Windows.
+
+Returns 0 on success, -1 on failure. If {\it rc} parameter is not NULL, it will
+be filled with an element of {\tt wxKillError} enum:
+
+\begin{verbatim}
+enum wxKillError
+{
+ wxKILL_OK, // no error
+ wxKILL_BAD_SIGNAL, // no such signal
+ wxKILL_ACCESS_DENIED, // permission denied
+ wxKILL_NO_PROCESS, // no such process
+ wxKILL_ERROR // another, unspecified error
+};
+\end{verbatim}
+
+The {\it flags} parameter can be wxKILL\_NOCHILDREN (the default),
+or wxKILL\_CHILDREN, in which case the child processes of this
+process will be killed too. Note that under Unix, for wxKILL\_CHILDREN
+to work you should have created the process by passing wxEXEC\_MAKE_GROUP\_LEADER
+to wxExecute.
+
+\wxheading{See also}
+
+\helpref{wxProcess::Kill}{wxprocesskill},\rtfsp
+\helpref{wxProcess::Exists}{wxprocessexists},\rtfsp
+\helpref{Exec sample}{sampleexec}
+
+\wxheading{Include files}
+
+<wx/utils.h>
+
+
+\membersection{::wxGetProcessId}\label{wxgetprocessid}
+
+\func{unsigned long}{wxGetProcessId}{\void}
+
+Returns the number uniquely identifying the current process in the system.
+
+If an error occurs, $0$ is returned.
+
+\wxheading{Include files}
+
+<wx/utils.h>
+
+
+\membersection{::wxShell}\label{wxshell}
+
+\func{bool}{wxShell}{\param{const wxString\& }{command = NULL}}
+
+Executes a command in an interactive shell window. If no command is
+specified, then just the shell is spawned.
+
+See also \helpref{wxExecute}{wxexecute}, \helpref{Exec sample}{sampleexec}.
+
+\wxheading{Include files}
+
+<wx/utils.h>
+
+
+\membersection{::wxShutdown}\label{wxshutdown}
+
+\func{bool}{wxShutdown}{\param{wxShutdownFlags}{flags}}
+
+This function shuts down or reboots the computer depending on the value of the
+{\it flags}. Please notice that doing this requires the corresponding access
+rights (superuser under Unix, {\tt SE\_SHUTDOWN} privelege under Windows NT)
+and that this function is only implemented under Unix and Win32.
+
+\wxheading{Parameters}
+
+\docparam{flags}{Either {\tt wxSHUTDOWN\_POWEROFF} or {\tt wxSHUTDOWN\_REBOOT}}
+
+\wxheading{Returns}
+
+{\tt true} on success, {\tt false} if an error occured.
+
+\wxheading{Include files}
+
+<wx/utils.h>
+
+
+
+\section{Thread functions}\label{threadfunctions}
+
+The functions and macros here mainly exist to make it writing the code which
+may be compiled in multi thread build ({\tt wxUSE\_THREADS} $= 1$) as well as
+in single thread configuration ({\tt wxUSE\_THREADS} $= 0$).
+
+For example, a static variable must be protected against simultaneous access by
+multiple threads in the former configuration but in the latter the extra
+overhead of using the critical section is not needed. To solve this problem,
+the \helpref{wxCRITICAL\_SECTION}{wxcriticalsectionmacro} macro may be used
+to create and use the critical section only when needed.
+
+\wxheading{Include files}
+
+<wx/thread.h>
+
+\wxheading{See also}
+
+\helpref{wxThread}{wxthread}, \helpref{wxMutex}{wxmutex}, \helpref{Multithreading overview}{wxthreadoverview}
+
+
+
+\membersection{wxCRIT\_SECT\_DECLARE}\label{wxcritsectdeclare}
+
+\func{}{wxCRIT\_SECT\_DECLARE}{\param{}{cs}}
+
+This macro declares a (static) critical section object named {\it cs} if
+{\tt wxUSE\_THREADS} is $1$ and does nothing if it is $0$.
+
+
+
+\membersection{wxCRIT\_SECT\_DECLARE\_MEMBER}\label{wxcritsectdeclaremember}
+
+\func{}{wxCRIT\_SECT\_DECLARE}{\param{}{cs}}
+
+This macro declares a critical section object named {\it cs} if
+{\tt wxUSE\_THREADS} is $1$ and does nothing if it is $0$. As it doesn't
+include the {\tt static} keyword (unlike
+\helpref{wxCRIT\_SECT\_DECLARE}{wxcritsectdeclare}), it can be used to declare
+a class or struct member which explains its name.
+
+
+
+\membersection{wxCRIT\_SECT\_LOCKER}\label{wxcritsectlocker}
+
+\func{}{wxCRIT\_SECT\_LOCKER}{\param{}{name}, \param{}{cs}}
+
+This macro creates a \helpref{critical section lock}{wxcriticalsectionlocker}
+object named {\it name} and associated with the critical section {\it cs} if
+{\tt wxUSE\_THREADS} is $1$ and does nothing if it is $0$.
+
+
+
+\membersection{wxCRITICAL\_SECTION}\label{wxcriticalsectionmacro}
+
+\func{}{wxCRITICAL\_SECTION}{\param{}{name}}
+
+This macro combines \helpref{wxCRIT\_SECT\_DECLARE}{wxcritsectdeclare} and
+\helpref{wxCRIT\_SECT\_LOCKER}{wxcritsectlocker}: it creates a static critical
+section object and also the lock object associated with it. Because of this, it
+can be only used inside a function, not at global scope. For example:
+
+\begin{verbatim}
+int IncCount()
+{
+ static int s_counter = 0;
+
+ wxCRITICAL_SECTION(counter);
+
+ return ++s_counter;
+}
+\end{verbatim}
+
+(note that we suppose that the function is called the first time from the main
+thread so that the critical section object is initialized correctly by the time
+other threads start calling it, if this is not the case this approach can
+{\bf not} be used and the critical section must be made a global instead).
+
+
+
+\membersection{wxENTER\_CRIT\_SECT}\label{wxentercritsect}
+
+\func{}{wxENTER\_CRIT\_SECT}{\param{wxCriticalSection\& }{cs}}
+
+This macro is equivalent to \helpref{cs.Enter()}{wxcriticalsectionenter} if
+{\tt wxUSE\_THREADS} is $1$ and does nothing if it is $0$.
+
+
+
+\membersection{::wxIsMainThread}\label{wxismainthread}
+
+\func{bool}{wxIsMainThread}{\void}
+
+Returns {\tt true} if this thread is the main one. Always returns {\tt true} if
+{\tt wxUSE\_THREADS} is $0$.
+
+
+
+\membersection{wxLEAVE\_CRIT\_SECT}\label{wxleavecritsect}
+
+\func{}{wxLEAVE\_CRIT\_SECT}{\param{wxCriticalSection\& }{cs}}
+
+This macro is equivalent to \helpref{cs.Leave()}{wxcriticalsectionleave} if
+{\tt wxUSE\_THREADS} is $1$ and does nothing if it is $0$.
+
+
+
+\membersection{::wxMutexGuiEnter}\label{wxmutexguienter}
+
+\func{void}{wxMutexGuiEnter}{\void}
+
+This function must be called when any thread other than the main GUI thread
+wants to get access to the GUI library. This function will block the execution
+of the calling thread until the main thread (or any other thread holding the
+main GUI lock) leaves the GUI library and no other thread will enter the GUI
+library until the calling thread calls \helpref{::wxMutexGuiLeave()}{wxmutexguileave}.
+
+Typically, these functions are used like this:
+
+\begin{verbatim}
+void MyThread::Foo(void)
+{
+ // before doing any GUI calls we must ensure that this thread is the only
+ // one doing it!
+
+ wxMutexGuiEnter();
+
+ // Call GUI here:
+ my_window->DrawSomething();
+
+ wxMutexGuiLeave();
+}
+\end{verbatim}
+
+Note that under GTK, no creation of top-level windows is allowed in any
+thread but the main one.
+
+This function is only defined on platforms which support preemptive
+threads.
+
+
+\membersection{::wxMutexGuiLeave}\label{wxmutexguileave}
+
+\func{void}{wxMutexGuiLeave}{\void}
+
+See \helpref{::wxMutexGuiEnter()}{wxmutexguienter}.
+
+This function is only defined on platforms which support preemptive
+threads.
+
+
projects / wxWidgets.git / blobdiff