// ----------------------------------------------------------------------------
#include "wx/event.h" // for the base class
+#include "wx/eventfilter.h" // (and another one)
#include "wx/build.h"
#include "wx/cmdargs.h" // for wxCmdLineArgsArray used by wxApp::argv
#include "wx/init.h" // we must declare wxEntry()
// wxAppConsoleBase: wxApp for non-GUI applications
// ----------------------------------------------------------------------------
-class WXDLLIMPEXP_BASE wxAppConsoleBase : public wxEvtHandler
+class WXDLLIMPEXP_BASE wxAppConsoleBase : public wxEvtHandler,
+ public wxEventFilter
{
public:
// ctor and dtor
wxEventLoopBase* GetMainLoop() const
{ return m_mainLoop; }
+ // This function sets the C locale to the default locale for the current
+ // environment. It is advised to call this to ensure that the underlying
+ // toolkit uses the locale in which the numbers and monetary amounts are
+ // shown in the format expected by user and so on.
+ //
+ // Notice that this does _not_ change the global C++ locale, you need to do
+ // it explicitly if you want.
+ //
+ // Finally, notice that while this function is virtual, it is not supposed
+ // to be overridden outside of the library itself.
+ virtual void SetCLocale();
+
// event processing functions
// --------------------------
- // this method allows to filter all the events processed by the program, so
- // you should try to return quickly from it to avoid slowing down the
- // program to the crawl
- //
- // return value should be -1 to continue with the normal event processing,
- // or TRUE or FALSE to stop further processing and pretend that the event
- // had been already processed or won't be processed at all, respectively
+ // Implement the inherited wxEventFilter method but just return -1 from it
+ // to indicate that default processing should take place.
virtual int FilterEvent(wxEvent& event);
// return true if we're running event loop, i.e. if the events can
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);
wxDECLARE_NO_COPY_CLASS(wxAppConsoleBase);
};
-#if defined(__UNIX__)
+#if defined(__UNIX__) && !defined(__WXMSW__)
#include "wx/unix/app.h"
#else
// this has to be a class and not a typedef as we forward declare it
// it should return true if more idle events are needed, false if not
virtual bool ProcessIdle();
- // Send idle event to window and all subwindows
- // Returns true if more idle time is requested.
- virtual bool SendIdleEvents(wxWindow* win, wxIdleEvent& event);
-
// override base class version: GUI apps always use an event loop
virtual bool UsesEventLoop() const { return true; }
// ------------------------------------------------------------------------
// Get display mode that is used use. This is only used in framebuffer
- // wxWin ports (such as wxMGL or wxDFB).
+ // wxWin ports such as wxDFB.
virtual wxVideoMode GetDisplayMode() const;
// Set display mode to use. This is only used in framebuffer wxWin
- // ports (such as wxMGL or wxDFB). This method should be called from
+ // ports such as wxDFB. This method should be called from
// wxApp::OnInitGui
virtual bool SetDisplayMode(const wxVideoMode& WXUNUSED(info)) { return true; }
// now include the declaration of the real class
// ----------------------------------------------------------------------------
-#if defined(__WXPALMOS__)
- #include "wx/palmos/app.h"
-#elif defined(__WXMSW__)
+#if defined(__WXMSW__)
#include "wx/msw/app.h"
#elif defined(__WXMOTIF__)
#include "wx/motif/app.h"
-#elif defined(__WXMGL__)
- #include "wx/mgl/app.h"
#elif defined(__WXDFB__)
#include "wx/dfb/app.h"
#elif defined(__WXGTK20__)
// 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.
-
-#define IMPLEMENT_WXWIN_MAIN_CONSOLE \
- int main(int argc, char **argv) \
- { \
- wxDISABLE_DEBUG_SUPPORT(); \
+// hello.cpp). Now wxIMPLEMENT_APP should add this code if required.
+
+// For compilers that support it, prefer to use wmain() as this ensures any
+// Unicode strings can be passed as command line parameters and not just those
+// representable in the current locale.
+#if wxUSE_UNICODE && defined(__VISUALC__)
+ #define wxIMPLEMENT_WXWIN_MAIN_CONSOLE \
+ int wmain(int argc, wchar_t **argv) \
+ { \
+ wxDISABLE_DEBUG_SUPPORT(); \
\
- return wxEntry(argc, argv); \
- }
+ return wxEntry(argc, argv); \
+ }
+#else // Use standard main()
+ #define wxIMPLEMENT_WXWIN_MAIN_CONSOLE \
+ int main(int argc, char **argv) \
+ { \
+ wxDISABLE_DEBUG_SUPPORT(); \
+ \
+ return wxEntry(argc, argv); \
+ }
+#endif
// 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) \
+ appname& wxGetApp() { return *static_cast<appname*>(wxApp::GetInstance()); } \
wxAppConsole *wxCreateApp() \
{ \
wxAppConsole::CheckBuildOptions(WX_BUILD_OPTIONS_SIGNATURE, \
return new appname; \
} \
wxAppInitializer \
- wxTheAppInitializer((wxAppInitializerFunction) wxCreateApp); \
- DECLARE_APP(appname) \
- appname& wxGetApp() { return *static_cast<appname*>(wxApp::GetInstance()); }
+ wxTheAppInitializer((wxAppInitializerFunction) wxCreateApp)
-// 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_
projects / wxWidgets.git / blobdiff