Amebis/wxWidgets
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Implement wx-prefixed macros versions of DECLARE/IMPLEMENT_APP_* macros.

Browse Source 
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
This commit is contained in:
Francesco Montorsi
2010-06-09 13:23:13 +00:00
parent 7e2003703c
commit e4431849b4
11 changed files with 74 additions and 54 deletions
Download Patch File Download Diff File Expand all files Collapse all files

70
include/wx/app.h
View File

@@ -399,7 +399,7 @@ public:
const wxChar *msg); const wxChar *msg);
// check that the wxBuildOptions object (constructed in the application // 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 // options of the library and abort if it doesn't
static bool CheckBuildOptions(const char *optionsSignature, static bool CheckBuildOptions(const char *optionsSignature,
const char *componentName); const char *componentName);
@@ -728,7 +728,7 @@ protected:
// object of type wxApp // object of type wxApp
// //
// note that instead of using of wxTheApp in application code you should // 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) // 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 // the cast is safe as in GUI build we only use wxApp, not wxAppConsole, and in
@@ -773,11 +773,11 @@ public:
{ wxApp::SetInitializerFunction(fn); } { 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. // 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) \ int main(int argc, char **argv) \
{ \ { \
wxDISABLE_DEBUG_SUPPORT(); \ wxDISABLE_DEBUG_SUPPORT(); \
@@ -786,26 +786,26 @@ public:
} }
// port-specific header could have defined it already in some special way // port-specific header could have defined it already in some special way
#ifndef IMPLEMENT_WXWIN_MAIN #ifndef wxIMPLEMENT_WXWIN_MAIN
#define IMPLEMENT_WXWIN_MAIN IMPLEMENT_WXWIN_MAIN_CONSOLE #define wxIMPLEMENT_WXWIN_MAIN wxIMPLEMENT_WXWIN_MAIN_CONSOLE
#endif // defined(IMPLEMENT_WXWIN_MAIN) #endif // defined(wxIMPLEMENT_WXWIN_MAIN)
#ifdef __WXUNIVERSAL__ #ifdef __WXUNIVERSAL__
#include "wx/univ/theme.h" #include "wx/univ/theme.h"
#ifdef wxUNIV_DEFAULT_THEME #ifdef wxUNIV_DEFAULT_THEME
#define IMPLEMENT_WX_THEME_SUPPORT \ #define wxIMPLEMENT_WX_THEME_SUPPORT \
WX_USE_THEME(wxUNIV_DEFAULT_THEME); WX_USE_THEME(wxUNIV_DEFAULT_THEME);
#else #else
#define IMPLEMENT_WX_THEME_SUPPORT #define wxIMPLEMENT_WX_THEME_SUPPORT
#endif #endif
#else #else
#define IMPLEMENT_WX_THEME_SUPPORT #define wxIMPLEMENT_WX_THEME_SUPPORT
#endif #endif
// Use this macro if you want to define your own main() or WinMain() function // Use this macro if you want to define your own main() or WinMain() function
// and call wxEntry() from there. // and call wxEntry() from there.
#define IMPLEMENT_APP_NO_MAIN(appname) \ #define wxIMPLEMENT_APP_NO_MAIN(appname) \
wxAppConsole *wxCreateApp() \ wxAppConsole *wxCreateApp() \
{ \ { \
wxAppConsole::CheckBuildOptions(WX_BUILD_OPTIONS_SIGNATURE, \ wxAppConsole::CheckBuildOptions(WX_BUILD_OPTIONS_SIGNATURE, \
@@ -814,36 +814,54 @@ public:
} \ } \
wxAppInitializer \ wxAppInitializer \
wxTheAppInitializer((wxAppInitializerFunction) wxCreateApp); \ 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 // wxUniversal builds
#define IMPLEMENT_APP_NO_THEMES(appname) \ #define wxIMPLEMENT_APP_NO_THEMES(appname) \
IMPLEMENT_APP_NO_MAIN(appname) \ wxIMPLEMENT_WXWIN_MAIN \
IMPLEMENT_WXWIN_MAIN wxIMPLEMENT_APP_NO_MAIN(appname)
// Use this macro exactly once, the argument is the name of the wxApp-derived // Use this macro exactly once, the argument is the name of the wxApp-derived
// class which is the class of your application. // class which is the class of your application.
#define IMPLEMENT_APP(appname) \ #define wxIMPLEMENT_APP(appname) \
IMPLEMENT_APP_NO_THEMES(appname) \ wxIMPLEMENT_WX_THEME_SUPPORT \
IMPLEMENT_WX_THEME_SUPPORT wxIMPLEMENT_APP_NO_THEMES(appname)
// Same as IMPLEMENT_APP(), but for console applications. // Same as IMPLEMENT_APP(), but for console applications.
#define IMPLEMENT_APP_CONSOLE(appname) \ #define wxIMPLEMENT_APP_CONSOLE(appname) \
IMPLEMENT_APP_NO_MAIN(appname) \ wxIMPLEMENT_WXWIN_MAIN_CONSOLE \
IMPLEMENT_WXWIN_MAIN_CONSOLE wxIMPLEMENT_APP_NO_MAIN(appname)
// this macro can be used multiple times and just allows you to use wxGetApp() // this macro can be used multiple times and just allows you to use wxGetApp()
// function // 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 // anywhere else but at the very least it suppresses icc warnings about
// defining extern symbols without prior declaration, and it shouldn't do any // defining extern symbols without prior declaration, and it shouldn't do any
// harm // harm
extern wxAppConsole *wxCreateApp(); extern wxAppConsole *wxCreateApp();
extern wxAppInitializer wxTheAppInitializer; 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_ #endif // _WX_APP_H_BASE_

2
include/wx/build.h
View File

@@ -106,7 +106,7 @@
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
// Use this macro to check build options. Adding it to a file in DLL will // 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) \ #define WX_CHECK_BUILD_OPTIONS(libName) \
static struct wxBuildOptionsChecker \ static struct wxBuildOptionsChecker \
{ \ { \

2
include/wx/debug.h
View File

@@ -148,7 +148,7 @@ inline void wxDisableAsserts() { wxSetAssertHandler(NULL); }
/* /*
A macro which disables asserts for applications compiled in release build. 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. asserts in the applications compiled in the release build by calling this.
It does nothing if NDEBUG is not defined. It does nothing if NDEBUG is not defined.
*/ */

2
include/wx/init.h
View File

@@ -55,7 +55,7 @@ extern int WXDLLIMPEXP_BASE wxEntry(int& argc, char **argv);
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
// Using the library without (explicit) application object: you may avoid using // 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 // the program startup and termination
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------

2
include/wx/log.h
View File

@@ -1571,7 +1571,7 @@ wxSafeShowMessage(const wxString& title, const wxString& text);
#endif #endif
// macro which disables debug logging in release builds: this is done by // 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 #if defined(NDEBUG) && wxUSE_LOG_DEBUG
#define wxDISABLE_DEBUG_LOGGING_IN_RELEASE_BUILD() \ #define wxDISABLE_DEBUG_LOGGING_IN_RELEASE_BUILD() \
wxLog::SetLogLevel(wxLOG_Info) wxLog::SetLogLevel(wxLOG_Info)

12
include/wx/msw/app.h
View File

@@ -127,7 +127,7 @@ inline int wxApp::GetShell32Version()
#endif // __WXWINCE__ #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() // 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 // command line flag is used, the linker expects to find wWinMain instead
// of WinMain. This flag causes the compiler to define _UNICODE and // 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 // 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. // for both code compiled with and without -WU.
// See http://sourceforge.net/tracker/?func=detail&atid=309863&aid=1935997&group_id=9863 // See http://sourceforge.net/tracker/?func=detail&atid=309863&aid=1935997&group_id=9863
// for more details. // for more details.
#define IMPLEMENT_WXWIN_MAIN_BORLAND_NONSTANDARD \ #define wxIMPLEMENT_WXWIN_MAIN_BORLAND_NONSTANDARD \
extern "C" int WINAPI wWinMain(HINSTANCE hInstance, \ extern "C" int WINAPI wWinMain(HINSTANCE hInstance, \
HINSTANCE hPrevInstance, \ HINSTANCE hPrevInstance, \
wchar_t * WXUNUSED(lpCmdLine), \ wchar_t * WXUNUSED(lpCmdLine), \
@@ -182,10 +182,10 @@ extern WXDLLIMPEXP_CORE int
return wxEntry(hInstance, hPrevInstance, NULL, nCmdShow); \ return wxEntry(hInstance, hPrevInstance, NULL, nCmdShow); \
} }
#else #else
#define IMPLEMENT_WXWIN_MAIN_BORLAND_NONSTANDARD #define wxIMPLEMENT_WXWIN_MAIN_BORLAND_NONSTANDARD
#endif // defined(__BORLANDC__) && wxUSE_UNICODE #endif // defined(__BORLANDC__) && wxUSE_UNICODE
#define IMPLEMENT_WXWIN_MAIN \ #define wxIMPLEMENT_WXWIN_MAIN \
extern "C" int WINAPI WinMain(HINSTANCE hInstance, \ extern "C" int WINAPI WinMain(HINSTANCE hInstance, \
HINSTANCE hPrevInstance, \ HINSTANCE hPrevInstance, \
wxCmdLineArgType WXUNUSED(lpCmdLine), \ wxCmdLineArgType WXUNUSED(lpCmdLine), \
@@ -199,7 +199,7 @@ extern WXDLLIMPEXP_CORE int
/* wWinMain() above too. */ \ /* wWinMain() above too. */ \
return wxEntry(hInstance, hPrevInstance, NULL, nCmdShow); \ return wxEntry(hInstance, hPrevInstance, NULL, nCmdShow); \
} \ } \
IMPLEMENT_WXWIN_MAIN_BORLAND_NONSTANDARD wxIMPLEMENT_WXWIN_MAIN_BORLAND_NONSTANDARD
#endif // _WX_APP_H_ #endif // _WX_APP_H_

2
include/wx/palmos/app.h
View File

@@ -85,7 +85,7 @@ protected:
extern WXDLLIMPEXP_CORE int wxEntry(); extern WXDLLIMPEXP_CORE int wxEntry();
#define IMPLEMENT_WXWIN_MAIN \ #define wxIMPLEMENT_WXWIN_MAIN \
\ \
extern "C" { \ extern "C" { \
\ \

28
interface/wx/app.h
View File

@@ -24,11 +24,11 @@
objects in the application (see wxAppConsole::FilterEvent) objects in the application (see wxAppConsole::FilterEvent)
@li implement Apple-specific event handlers (see wxAppConsole::MacXXX functions) @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 implementation file to tell wxWidgets how to create an instance of your
application class. 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 (which returns a reference to your application object) to be visible to other
files. files.
@@ -856,35 +856,37 @@ public:
/** /**
This is used in headers to create a forward declaration of the ::wxGetApp() 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} @header{wx/app.h}
Example: Example:
@code @code
DECLARE_APP(MyApp) wxDECLARE_APP(MyApp);
@endcode @endcode
*/ */
#define DECLARE_APP( className ) #define wxDECLARE_APP( className )
/** /**
This is used in the application class implementation file to make the This is used in the application class implementation file to make the
application class known to wxWidgets for dynamic construction. application class known to wxWidgets for dynamic construction.
Note that this macro requires a final semicolon.
@header{wx/app.h} @header{wx/app.h}
Example: Example:
@code @code
IMPLEMENT_APP(MyApp) wxIMPLEMENT_APP(MyApp);
@endcode @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 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 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 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 ::wxTheApp pointer is that the latter is of type wxApp* and so wouldn't
@@ -1060,11 +1062,11 @@ void wxExit();
@def wxDISABLE_DEBUG_SUPPORT() @def wxDISABLE_DEBUG_SUPPORT()
Use this macro to disable all debugging code in release build when not 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 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 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 don't use this macro but initialize wxWidgets directly (e.g. calls
wxEntry() or wxEntryStart() itself). wxEntry() or wxEntryStart() itself).

4
interface/wx/debug.h
View File

@@ -249,10 +249,10 @@ void wxDisableAsserts();
@def wxDISABLE_ASSERTS_IN_RELEASE_BUILD @def wxDISABLE_ASSERTS_IN_RELEASE_BUILD
Use this macro to disable asserts in release build when not using 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 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 because your application initializes wxWidgets directly (e.g. calls
wxEntry() or wxEntryStart() itself) but still want to suppress assert wxEntry() or wxEntryStart() itself) but still want to suppress assert
notifications in release build you need to use this macro directly. notifications in release build you need to use this macro directly.

2
interface/wx/init.h
View File

@@ -90,7 +90,7 @@ void wxEntryCleanup();
Initialize the library (may be called as many times as needed, but each Initialize the library (may be called as many times as needed, but each
call to wxInitialize() must be matched by wxUninitialize()). 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 and use wxInitialize() and wxUninitialize() dynamically in the
program startup and termination. program startup and termination.

2
interface/wx/log.h
View File

@@ -1415,7 +1415,7 @@ void wxVLogSysError(const char* formatString, va_list argPtr);
@def wxDISABLE_DEBUG_LOGGING_IN_RELEASE_BUILD() @def wxDISABLE_DEBUG_LOGGING_IN_RELEASE_BUILD()
Use this macro to disable logging at debug and trace levels in release 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(), @see wxDISABLE_DEBUG_SUPPORT(),
wxDISABLE_ASSERTS_IN_RELEASE_BUILD(), wxDISABLE_ASSERTS_IN_RELEASE_BUILD(),