class WXDLLIMPEXP_BASE wxLog;
class WXDLLIMPEXP_BASE wxMessageOutput;
+// wxUSE_EVTLOOP_IN_APP is a temporary hack needed until all ports are updated
+// to use wxEventLoop, otherwise we get linking errors on wxMac, it's going to
+// disappear a.s.a.p.
+#ifdef __WXMAC__
+ #define wxUSE_EVTLOOP_IN_APP 0
+#else
+ #define wxUSE_EVTLOOP_IN_APP 1
+ class WXDLLEXPORT wxEventLoop;
+#endif
+
// ----------------------------------------------------------------------------
// typedefs
// ----------------------------------------------------------------------------
};
#endif // wxUSE_GUI
+
// ----------------------------------------------------------------------------
// wxAppConsole: wxApp for non-GUI applications
// ----------------------------------------------------------------------------
// crash.
virtual void OnFatalException() { }
+#if wxUSE_EXCEPTIONS
+ // Called when an unhandled C++ exception occurs inside OnRun(): note that
+ // the exception type is lost by now, so if you really want to handle the
+ // exception you should override OnRun() and put a try/catch around
+ // MainLoop() call there
+ virtual void OnUnhandledException() { }
+#endif // wxUSE_EXCEPTIONS
+
// Called from wxExit() function, should terminate the application a.s.a.p.
virtual void Exit();
#if wxUSE_CMDLINE_PARSER
// this one is called from OnInit() to add all supported options
- // to the given parser
+ // to the given parser (don't forget to call the base class version if you
+ // override it!)
virtual void OnInitCmdLine(wxCmdLineParser& parser);
// called after successfully parsing the command line, return TRUE
- // to continue and FALSE to exit
+ // to continue and FALSE to exit (don't forget to call the base class
+ // version if you override it!)
virtual bool OnCmdLineParsed(wxCmdLineParser& parser);
// called if "--help" option was specified, return TRUE to continue
// had been already processed or won't be processed at all, respectively
virtual int FilterEvent(wxEvent& event);
+#if wxUSE_EXCEPTIONS
+ // call the specified handler on the given object with the given event
+ //
+ // this method only exists to allow catching the exceptions thrown by any
+ // event handler, it would lead to an extra (useless) virtual function call
+ // if the exceptions were not used, so it doesn't even exist in that case
+ virtual void HandleEvent(wxEvtHandler *handler,
+ wxEventFunction func,
+ wxEvent& event) const;
+#endif // wxUSE_EXCEPTIONS
+
// process all events in the wxPendingEvents list -- it is necessary to
// call this function to process posted events. This happens during each
// event loop iteration in GUI mode but if there is no main loop, it may be
// check that the wxBuildOptions object (constructed in the application
// itself, usually the one from IMPLEMENT_APP() macro) matches the build
// options of the library and abort if it doesn't
- static bool CheckBuildOptions(const wxBuildOptions& buildOptions);
-
+ static bool CheckBuildOptions(const char *optionsSignature,
+ const char *componentName);
+#if WXWIN_COMPATIBILITY_2_4
+ static bool CheckBuildOptions(const wxBuildOptions& buildOptions)
+ {
+ return CheckBuildOptions(buildOptions.m_signature, "your program");
+ }
+#endif
// implementation only from now on
// -------------------------------
static wxAppInitializerFunction GetInitializerFunction()
{ return ms_appInitFn; }
+ // accessors for ms_appInstance field (external code might wish to modify
+ // it, this is why we provide a setter here as well, but you should really
+ // know what you're doing if you call it), wxTheApp is usually used instead
+ // of GetInstance()
+ static wxAppConsole *GetInstance() { return ms_appInstance; }
+ static void SetInstance(wxAppConsole *app) { ms_appInstance = app; }
+
// command line arguments (public for backwards compatibility)
int argc;
// function used for dynamic wxApp creation
static wxAppInitializerFunction ms_appInitFn;
+ // the one and only global application object
+ static wxAppConsole *ms_appInstance;
+
+
// application info (must be set from the user code)
wxString m_vendorName, // vendor name (ACME Inc)
m_appName, // app name
// Override: rarely in GUI applications, always in console ones.
virtual int OnRun();
+ // a matching function for OnInit()
+ virtual int OnExit();
+
// very last clean up function
//
// Override: very rarely
// -----------------------------------------------------------------
// execute the main GUI loop, the function returns when the loop ends
- virtual int MainLoop() = 0;
+ virtual int MainLoop();
// exit the main loop thus terminating the application
virtual void Exit();
// exit the main GUI loop during the next iteration (i.e. it does not
// stop the program immediately!)
- virtual void ExitMainLoop() = 0;
+ virtual void ExitMainLoop();
- // returns TRUE if the program is initialized
+ // returns true if the program is initialized, i.e. OnInit() has been
+ // completed successfully
virtual bool Initialized() = 0;
// returns TRUE if there are unprocessed events in the event queue
- virtual bool Pending() = 0;
+ virtual bool Pending();
// process the first event in the event queue (blocks until an event
- // apperas if there are none currently)
- virtual void Dispatch() = 0;
+ // appears if there are none currently, use Pending() if this is not
+ // wanted), returns false if the event loop should stop and true
+ // otherwise
+ virtual bool Dispatch();
// process all currently pending events right now
//
// parties
//
// it should return TRUE if more idle events are needed, FALSE if not
- virtual bool ProcessIdle() ;
+ virtual bool ProcessIdle();
// Send idle event to window and all subwindows
// Returns TRUE if more idle time is requested.
int GetPrintMode() const { return wxPRINT_POSTSCRIPT; }
+ // command line parsing (GUI-specific)
+ // ------------------------------------------------------------------------
+
+#if wxUSE_CMDLINE_PARSER
+ virtual bool OnCmdLineParsed(wxCmdLineParser& parser);
+ virtual void OnInitCmdLine(wxCmdLineParser& parser);
+#endif
+
// miscellaneous other stuff
// ------------------------------------------------------------------------
virtual wxAppTraits *CreateTraits();
+#if wxUSE_EVTLOOP_IN_APP
+ // the main event loop of the application (may be NULL if the loop hasn't
+ // been started yet or has already terminated)
+ wxEventLoop *m_mainLoop;
+#endif // wxUSE_EVTLOOP_IN_APP
+
// the main top level window (may be NULL)
wxWindow *m_topWindow;
#include "wx/os2/app.h"
#endif
#else // !GUI
+ // allow using just wxApp (instead of wxAppConsole) in console programs
typedef wxAppConsole wxApp;
#endif // GUI/!GUI
// the global data
// ----------------------------------------------------------------------------
-// the one and only application object - use of wxTheApp in application code
-// is discouraged, consider using DECLARE_APP() after which you may call
-// wxGetApp() which will return the object of the correct type (i.e. MyApp and
-// not wxApp)
-WXDLLIMPEXP_DATA_BASE(extern wxApp*) wxTheApp;
+// for compatibility, we define this macro to access the global application
+// 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
+// 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
+// console mode it does nothing at all
+#define wxTheApp ((wxApp *)wxApp::GetInstance())
// ----------------------------------------------------------------------------
// global functions
// 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) { return wxEntry(argc, argv); }
+
#if !wxUSE_GUI || !defined(__WXMSW__)
#define IMPLEMENT_WXWIN_MAIN \
- int main(int argc, char **argv) { return wxEntry(argc, argv); }
-#elif defined(__WXMSW__) && defined(WXUSINGDLL)
+ IMPLEMENT_WXWIN_MAIN_CONSOLE
+#elif defined(__WXMSW__)
// we need HINSTANCE declaration to define WinMain()
- #include <windows.h>
- #include "wx/msw/winundef.h"
+ #include "wx/msw/wrapwin.h"
+
+ #ifdef SW_SHOWNORMAL
+ #define wxSW_SHOWNORMAL SW_SHOWNORMAL
+ #else
+ #define wxSW_SHOWNORMAL 0
+ #endif
#define IMPLEMENT_WXWIN_MAIN \
extern int wxEntry(HINSTANCE hInstance, \
HINSTANCE hPrevInstance = NULL, \
char *pCmdLine = NULL, \
- int nCmdShow = SW_NORMAL); \
+ int nCmdShow = wxSW_SHOWNORMAL); \
extern "C" int WINAPI WinMain(HINSTANCE hInstance, \
HINSTANCE hPrevInstance, \
char *lpCmdLine, \
#define IMPLEMENT_APP_NO_MAIN(appname) \
wxAppConsole *wxCreateApp() \
{ \
- wxAppConsole::CheckBuildOptions(wxBuildOptions()); \
+ wxAppConsole::CheckBuildOptions(WX_BUILD_OPTIONS_SIGNATURE, \
+ "your program"); \
return new appname; \
} \
wxAppInitializer \
IMPLEMENT_APP_NO_THEMES(appname) \
IMPLEMENT_WX_THEME_SUPPORT
+// Same as IMPLEMENT_APP(), but for console applications.
+#define IMPLEMENT_APP_CONSOLE(appname) \
+ IMPLEMENT_APP_NO_MAIN(appname) \
+ IMPLEMENT_WXWIN_MAIN_CONSOLE
+
// this macro can be used multiple times and just allows you to use wxGetApp()
// function
#define DECLARE_APP(appname) extern appname& wxGetApp();