const wxChar *msg);
// check that the wxBuildOptions object (constructed in the application
- // itself, usually the one from IMPLEMENT_APP() macro) matches the build
+ // itself, usually the one from wxIMPLEMENT_APP() macro) matches the build
// options of the library and abort if it doesn't
static bool CheckBuildOptions(const char *optionsSignature,
const char *componentName);
// object of type wxApp
//
// note that instead of using of wxTheApp in application code you should
-// consider using DECLARE_APP() after which you may call wxGetApp() which will
+// consider using wxDECLARE_APP() after which you may call wxGetApp() which will
// return the object of the correct type (i.e. MyApp and not wxApp)
//
// the cast is safe as in GUI build we only use wxApp, not wxAppConsole, and in
{ wxApp::SetInitializerFunction(fn); }
};
-// the code below defines a IMPLEMENT_WXWIN_MAIN macro which you can use if
+// the code below defines a wxIMPLEMENT_WXWIN_MAIN macro which you can use if
// your compiler really, really wants main() to be in your main program (e.g.
-// hello.cpp). Now IMPLEMENT_APP should add this code if required.
+// hello.cpp). Now wxIMPLEMENT_APP should add this code if required.
-#define IMPLEMENT_WXWIN_MAIN_CONSOLE \
+#define wxIMPLEMENT_WXWIN_MAIN_CONSOLE \
int main(int argc, char **argv) \
{ \
wxDISABLE_DEBUG_SUPPORT(); \
}
// port-specific header could have defined it already in some special way
-#ifndef IMPLEMENT_WXWIN_MAIN
- #define IMPLEMENT_WXWIN_MAIN IMPLEMENT_WXWIN_MAIN_CONSOLE
-#endif // defined(IMPLEMENT_WXWIN_MAIN)
+#ifndef wxIMPLEMENT_WXWIN_MAIN
+ #define wxIMPLEMENT_WXWIN_MAIN wxIMPLEMENT_WXWIN_MAIN_CONSOLE
+#endif // defined(wxIMPLEMENT_WXWIN_MAIN)
#ifdef __WXUNIVERSAL__
#include "wx/univ/theme.h"
#ifdef wxUNIV_DEFAULT_THEME
- #define IMPLEMENT_WX_THEME_SUPPORT \
+ #define wxIMPLEMENT_WX_THEME_SUPPORT \
WX_USE_THEME(wxUNIV_DEFAULT_THEME);
#else
- #define IMPLEMENT_WX_THEME_SUPPORT
+ #define wxIMPLEMENT_WX_THEME_SUPPORT
#endif
#else
- #define IMPLEMENT_WX_THEME_SUPPORT
+ #define wxIMPLEMENT_WX_THEME_SUPPORT
#endif
// Use this macro if you want to define your own main() or WinMain() function
// and call wxEntry() from there.
-#define IMPLEMENT_APP_NO_MAIN(appname) \
+#define wxIMPLEMENT_APP_NO_MAIN(appname) \
wxAppConsole *wxCreateApp() \
{ \
wxAppConsole::CheckBuildOptions(WX_BUILD_OPTIONS_SIGNATURE, \
} \
wxAppInitializer \
wxTheAppInitializer((wxAppInitializerFunction) wxCreateApp); \
- DECLARE_APP(appname) \
- appname& wxGetApp() { return *static_cast<appname*>(wxApp::GetInstance()); }
+ appname& wxGetApp() { return *static_cast<appname*>(wxApp::GetInstance()); } \
+ wxDECLARE_APP(appname)
-// Same as IMPLEMENT_APP() normally but doesn't include themes support in
+// Same as wxIMPLEMENT_APP() normally but doesn't include themes support in
// wxUniversal builds
-#define IMPLEMENT_APP_NO_THEMES(appname) \
- IMPLEMENT_APP_NO_MAIN(appname) \
- IMPLEMENT_WXWIN_MAIN
+#define wxIMPLEMENT_APP_NO_THEMES(appname) \
+ wxIMPLEMENT_WXWIN_MAIN \
+ wxIMPLEMENT_APP_NO_MAIN(appname)
// Use this macro exactly once, the argument is the name of the wxApp-derived
// class which is the class of your application.
-#define IMPLEMENT_APP(appname) \
- IMPLEMENT_APP_NO_THEMES(appname) \
- IMPLEMENT_WX_THEME_SUPPORT
+#define wxIMPLEMENT_APP(appname) \
+ wxIMPLEMENT_WX_THEME_SUPPORT \
+ wxIMPLEMENT_APP_NO_THEMES(appname)
// Same as IMPLEMENT_APP(), but for console applications.
-#define IMPLEMENT_APP_CONSOLE(appname) \
- IMPLEMENT_APP_NO_MAIN(appname) \
- IMPLEMENT_WXWIN_MAIN_CONSOLE
+#define wxIMPLEMENT_APP_CONSOLE(appname) \
+ wxIMPLEMENT_WXWIN_MAIN_CONSOLE \
+ wxIMPLEMENT_APP_NO_MAIN(appname)
// this macro can be used multiple times and just allows you to use wxGetApp()
// function
-#define DECLARE_APP(appname) extern appname& wxGetApp();
+#define wxDECLARE_APP(appname) \
+ extern appname& wxGetApp()
-// declare the stuff defined by IMPLEMENT_APP() macro, it's not really needed
+// declare the stuff defined by wxIMPLEMENT_APP() macro, it's not really needed
// anywhere else but at the very least it suppresses icc warnings about
// defining extern symbols without prior declaration, and it shouldn't do any
// harm
extern wxAppConsole *wxCreateApp();
extern wxAppInitializer wxTheAppInitializer;
+// ----------------------------------------------------------------------------
+// Compatibility macro aliases
+// ----------------------------------------------------------------------------
+
+// deprecated variants _not_ requiring a semicolon after them
+// (note that also some wx-prefixed macro do _not_ require a semicolon because
+// it's not always possible to force the compire to require it)
+
+#define IMPLEMENT_WXWIN_MAIN_CONSOLE wxIMPLEMENT_WXWIN_MAIN_CONSOLE
+#define IMPLEMENT_WXWIN_MAIN wxIMPLEMENT_WXWIN_MAIN
+#define IMPLEMENT_WX_THEME_SUPPORT wxIMPLEMENT_WX_THEME_SUPPORT
+#define IMPLEMENT_APP_NO_MAIN(app) wxIMPLEMENT_APP_NO_MAIN(app);
+#define IMPLEMENT_APP_NO_THEMES(app) wxIMPLEMENT_APP_NO_THEMES(app);
+#define IMPLEMENT_APP(app) wxIMPLEMENT_APP(app);
+#define IMPLEMENT_APP_CONSOLE(app) wxIMPLEMENT_APP_CONSOLE(app);
+#define DECLARE_APP(app) wxDECLARE_APP(app);
+
#endif // _WX_APP_H_BASE_
// ----------------------------------------------------------------------------
// Use this macro to check build options. Adding it to a file in DLL will
-// ensure that the DLL checks build options in same way IMPLEMENT_APP() does.
+// ensure that the DLL checks build options in same way wxIMPLEMENT_APP() does.
#define WX_CHECK_BUILD_OPTIONS(libName) \
static struct wxBuildOptionsChecker \
{ \
/*
A macro which disables asserts for applications compiled in release build.
- By default, IMPLEMENT_APP (or rather IMPLEMENT_WXWIN_MAIN) disable the
+ By default, wxIMPLEMENT_APP (or rather wxIMPLEMENT_WXWIN_MAIN) disable the
asserts in the applications compiled in the release build by calling this.
It does nothing if NDEBUG is not defined.
*/
// ----------------------------------------------------------------------------
// Using the library without (explicit) application object: you may avoid using
-// DECLARE_APP and IMPLEMENT_APP macros and call the functions below instead at
+// wxDECLARE_APP and wxIMPLEMENT_APP macros and call the functions below instead at
// the program startup and termination
// ----------------------------------------------------------------------------
#endif
// macro which disables debug logging in release builds: this is done by
-// default by IMPLEMENT_APP() so usually it doesn't need to be used explicitly
+// default by wxIMPLEMENT_APP() so usually it doesn't need to be used explicitly
#if defined(NDEBUG) && wxUSE_LOG_DEBUG
#define wxDISABLE_DEBUG_LOGGING_IN_RELEASE_BUILD() \
wxLog::SetLogLevel(wxLOG_Info)
#endif // __WXWINCE__
// ----------------------------------------------------------------------------
-// MSW-specific wxEntry() overload and IMPLEMENT_WXWIN_MAIN definition
+// MSW-specific wxEntry() overload and wxIMPLEMENT_WXWIN_MAIN definition
// ----------------------------------------------------------------------------
// we need HINSTANCE declaration to define WinMain()
// command line flag is used, the linker expects to find wWinMain instead
// of WinMain. This flag causes the compiler to define _UNICODE and
// UNICODE symbols and there's no way to detect its use, so we have to
- // define both WinMain and wWinMain so that IMPLEMENT_WXWIN_MAIN works
+ // define both WinMain and wWinMain so that wxIMPLEMENT_WXWIN_MAIN works
// for both code compiled with and without -WU.
// See http://sourceforge.net/tracker/?func=detail&atid=309863&aid=1935997&group_id=9863
// for more details.
- #define IMPLEMENT_WXWIN_MAIN_BORLAND_NONSTANDARD \
+ #define wxIMPLEMENT_WXWIN_MAIN_BORLAND_NONSTANDARD \
extern "C" int WINAPI wWinMain(HINSTANCE hInstance, \
HINSTANCE hPrevInstance, \
wchar_t * WXUNUSED(lpCmdLine), \
return wxEntry(hInstance, hPrevInstance, NULL, nCmdShow); \
}
#else
- #define IMPLEMENT_WXWIN_MAIN_BORLAND_NONSTANDARD
+ #define wxIMPLEMENT_WXWIN_MAIN_BORLAND_NONSTANDARD
#endif // defined(__BORLANDC__) && wxUSE_UNICODE
-#define IMPLEMENT_WXWIN_MAIN \
+#define wxIMPLEMENT_WXWIN_MAIN \
extern "C" int WINAPI WinMain(HINSTANCE hInstance, \
HINSTANCE hPrevInstance, \
wxCmdLineArgType WXUNUSED(lpCmdLine), \
/* wWinMain() above too. */ \
return wxEntry(hInstance, hPrevInstance, NULL, nCmdShow); \
} \
- IMPLEMENT_WXWIN_MAIN_BORLAND_NONSTANDARD
+ wxIMPLEMENT_WXWIN_MAIN_BORLAND_NONSTANDARD
#endif // _WX_APP_H_
extern WXDLLIMPEXP_CORE int wxEntry();
-#define IMPLEMENT_WXWIN_MAIN \
+#define wxIMPLEMENT_WXWIN_MAIN \
\
extern "C" { \
\
objects in the application (see wxAppConsole::FilterEvent)
@li implement Apple-specific event handlers (see wxAppConsole::MacXXX functions)
- You should use the macro IMPLEMENT_APP(appClass) in your application
+ You should use the macro wxIMPLEMENT_APP(appClass) in your application
implementation file to tell wxWidgets how to create an instance of your
application class.
- Use DECLARE_APP(appClass) in a header file if you want the ::wxGetApp() function
+ Use wxDECLARE_APP(appClass) in a header file if you want the ::wxGetApp() function
(which returns a reference to your application object) to be visible to other
files.
/**
This is used in headers to create a forward declaration of the ::wxGetApp()
- function implemented by IMPLEMENT_APP().
+ function implemented by wxIMPLEMENT_APP().
- It creates the declaration <tt>className& wxGetApp()</tt>.
+ It creates the declaration <tt>className& wxGetApp()</tt>
+ (requires a final semicolon).
@header{wx/app.h}
Example:
@code
- DECLARE_APP(MyApp)
+ wxDECLARE_APP(MyApp);
@endcode
*/
-#define DECLARE_APP( className )
+#define wxDECLARE_APP( className )
/**
This is used in the application class implementation file to make the
application class known to wxWidgets for dynamic construction.
+ Note that this macro requires a final semicolon.
@header{wx/app.h}
Example:
@code
- IMPLEMENT_APP(MyApp)
+ wxIMPLEMENT_APP(MyApp);
@endcode
- @see DECLARE_APP().
+ @see wxDECLARE_APP()
*/
-#define IMPLEMENT_APP( className )
+#define wxIMPLEMENT_APP( className )
//@}
/**
This function doesn't exist in wxWidgets but it is created by using the
- IMPLEMENT_APP() macro.
+ wxIMPLEMENT_APP() macro.
Thus, before using it anywhere but in the same module where this macro is
- used, you must make it available using DECLARE_APP().
+ used, you must make it available using wxDECLARE_APP().
The advantage of using this function compared to directly using the global
::wxTheApp pointer is that the latter is of type wxApp* and so wouldn't
@def wxDISABLE_DEBUG_SUPPORT()
Use this macro to disable all debugging code in release build when not
- using IMPLEMENT_APP().
+ using wxIMPLEMENT_APP().
Currently this macro disables assert checking and debug and trace level
logging messages in release build (i.e. when @c NDEBUG is defined). It is
- used by IMPLEMENT_APP() macro so you only need to use it explicitly if you
+ used by wxIMPLEMENT_APP() macro so you only need to use it explicitly if you
don't use this macro but initialize wxWidgets directly (e.g. calls
wxEntry() or wxEntryStart() itself).
@def wxDISABLE_ASSERTS_IN_RELEASE_BUILD
Use this macro to disable asserts in release build when not using
- IMPLEMENT_APP().
+ wxIMPLEMENT_APP().
By default, assert message boxes are suppressed in release build by
- IMPLEMENT_APP() which uses this macro. If you don't use IMPLEMENT_APP()
+ wxIMPLEMENT_APP() which uses this macro. If you don't use wxIMPLEMENT_APP()
because your application initializes wxWidgets directly (e.g. calls
wxEntry() or wxEntryStart() itself) but still want to suppress assert
notifications in release build you need to use this macro directly.
Initialize the library (may be called as many times as needed, but each
call to wxInitialize() must be matched by wxUninitialize()).
- With this function you may avoid DECLARE_APP() and IMPLEMENT_APP() macros
+ With this function you may avoid wxDECLARE_APP() and wxIMPLEMENT_APP() macros
and use wxInitialize() and wxUninitialize() dynamically in the
program startup and termination.
@def wxDISABLE_DEBUG_LOGGING_IN_RELEASE_BUILD()
Use this macro to disable logging at debug and trace levels in release
- build when not using IMPLEMENT_APP().
+ build when not using wxIMPLEMENT_APP().
@see wxDISABLE_DEBUG_SUPPORT(),
wxDISABLE_ASSERTS_IN_RELEASE_BUILD(),
projects / wxWidgets.git / commitdiff
