From e4431849b4f2097edf0e01c5d50bf0ed947befa9 Mon Sep 17 00:00:00 2001 From: Francesco Montorsi Date: Wed, 9 Jun 2010 13:23:13 +0000 Subject: [PATCH] Implement wx-prefixed macros versions of DECLARE/IMPLEMENT_APP_* macros. Implement compatibility aliases for non-prefixed macro names. Require a final semicolon where possible. git-svn-id: https://svn.wxwidgets.org/svn/wx/wxWidgets/trunk@64531 c3d73ce0-8a6f-49c7-b76d-6d57e0e08775 --- include/wx/app.h | 70 ++++++++++++++++++++++++++--------------- include/wx/build.h | 2 +- include/wx/debug.h | 2 +- include/wx/init.h | 2 +- include/wx/log.h | 2 +- include/wx/msw/app.h | 12 +++---- include/wx/palmos/app.h | 2 +- interface/wx/app.h | 28 +++++++++-------- interface/wx/debug.h | 4 +-- interface/wx/init.h | 2 +- interface/wx/log.h | 2 +- 11 files changed, 74 insertions(+), 54 deletions(-) diff --git a/include/wx/app.h b/include/wx/app.h index 965ffaf723..89df53f419 100644 --- a/include/wx/app.h +++ b/include/wx/app.h @@ -399,7 +399,7 @@ public: 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); @@ -728,7 +728,7 @@ protected: // 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 @@ -773,11 +773,11 @@ public: { 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(); \ @@ -786,26 +786,26 @@ public: } // 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, \ @@ -814,36 +814,54 @@ public: } \ wxAppInitializer \ wxTheAppInitializer((wxAppInitializerFunction) wxCreateApp); \ - DECLARE_APP(appname) \ - appname& wxGetApp() { return *static_cast(wxApp::GetInstance()); } + appname& wxGetApp() { return *static_cast(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_ diff --git a/include/wx/build.h b/include/wx/build.h index d3e60f1c3d..4d5b5421c4 100644 --- a/include/wx/build.h +++ b/include/wx/build.h @@ -106,7 +106,7 @@ // ---------------------------------------------------------------------------- // 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 \ { \ diff --git a/include/wx/debug.h b/include/wx/debug.h index 70e164d6e9..3d49a9e523 100644 --- a/include/wx/debug.h +++ b/include/wx/debug.h @@ -148,7 +148,7 @@ inline void wxDisableAsserts() { wxSetAssertHandler(NULL); } /* 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. */ diff --git a/include/wx/init.h b/include/wx/init.h index 3ea8957cc3..90304ef918 100644 --- a/include/wx/init.h +++ b/include/wx/init.h @@ -55,7 +55,7 @@ extern int WXDLLIMPEXP_BASE wxEntry(int& argc, char **argv); // ---------------------------------------------------------------------------- // 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 // ---------------------------------------------------------------------------- diff --git a/include/wx/log.h b/include/wx/log.h index 41933e8534..7190314658 100644 --- a/include/wx/log.h +++ b/include/wx/log.h @@ -1571,7 +1571,7 @@ wxSafeShowMessage(const wxString& title, const wxString& text); #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) diff --git a/include/wx/msw/app.h b/include/wx/msw/app.h index 73e01be938..ab41124fab 100644 --- a/include/wx/msw/app.h +++ b/include/wx/msw/app.h @@ -127,7 +127,7 @@ inline int wxApp::GetShell32Version() #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() @@ -164,11 +164,11 @@ extern WXDLLIMPEXP_CORE int // 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), \ @@ -182,10 +182,10 @@ extern WXDLLIMPEXP_CORE int 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), \ @@ -199,7 +199,7 @@ extern WXDLLIMPEXP_CORE int /* wWinMain() above too. */ \ return wxEntry(hInstance, hPrevInstance, NULL, nCmdShow); \ } \ - IMPLEMENT_WXWIN_MAIN_BORLAND_NONSTANDARD + wxIMPLEMENT_WXWIN_MAIN_BORLAND_NONSTANDARD #endif // _WX_APP_H_ diff --git a/include/wx/palmos/app.h b/include/wx/palmos/app.h index 0590f5e589..d542947164 100644 --- a/include/wx/palmos/app.h +++ b/include/wx/palmos/app.h @@ -85,7 +85,7 @@ protected: extern WXDLLIMPEXP_CORE int wxEntry(); -#define IMPLEMENT_WXWIN_MAIN \ +#define wxIMPLEMENT_WXWIN_MAIN \ \ extern "C" { \ \ diff --git a/interface/wx/app.h b/interface/wx/app.h index 701fda8b5b..4e8be1de06 100644 --- a/interface/wx/app.h +++ b/interface/wx/app.h @@ -24,11 +24,11 @@ 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. @@ -856,35 +856,37 @@ public: /** 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 className& wxGetApp(). + It creates the declaration className& wxGetApp() + (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 ) //@} @@ -904,10 +906,10 @@ wxApp *wxTheApp; /** 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 @@ -1060,11 +1062,11 @@ void wxExit(); @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). diff --git a/interface/wx/debug.h b/interface/wx/debug.h index d805f21e52..e3d2ef717f 100644 --- a/interface/wx/debug.h +++ b/interface/wx/debug.h @@ -249,10 +249,10 @@ void wxDisableAsserts(); @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. diff --git a/interface/wx/init.h b/interface/wx/init.h index d5d6a0fb6c..cb74acc8a2 100644 --- a/interface/wx/init.h +++ b/interface/wx/init.h @@ -90,7 +90,7 @@ void wxEntryCleanup(); 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. diff --git a/interface/wx/log.h b/interface/wx/log.h index 04f57638d4..434ef3547a 100644 --- a/interface/wx/log.h +++ b/interface/wx/log.h @@ -1415,7 +1415,7 @@ void wxVLogSysError(const char* formatString, va_list argPtr); @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(), -- 2.47.2