1 /////////////////////////////////////////////////////////////////////////////
3 // Purpose: wxAppBase class and macros used for declaration of wxApp
4 // derived class in the user code
5 // Author: Julian Smart
9 // Copyright: (c) Julian Smart
10 // Licence: wxWindows licence
11 /////////////////////////////////////////////////////////////////////////////
13 #ifndef _WX_APP_H_BASE_
14 #define _WX_APP_H_BASE_
16 // ----------------------------------------------------------------------------
17 // headers we have to include here
18 // ----------------------------------------------------------------------------
20 #include "wx/event.h" // for the base class
22 #include "wx/init.h" // we must declare wxEntry()
23 #include "wx/intl.h" // for wxLayoutDirection
25 class WXDLLIMPEXP_FWD_BASE wxAppConsole
;
26 class WXDLLIMPEXP_FWD_BASE wxAppTraits
;
27 class WXDLLIMPEXP_FWD_BASE wxCmdLineParser
;
28 class WXDLLIMPEXP_FWD_BASE wxEventLoopBase
;
29 class WXDLLIMPEXP_FWD_BASE wxLog
;
30 class WXDLLIMPEXP_FWD_BASE wxMessageOutput
;
33 struct WXDLLIMPEXP_FWD_CORE wxVideoMode
;
36 // ----------------------------------------------------------------------------
38 // ----------------------------------------------------------------------------
40 // the type of the function used to create a wxApp object on program start up
41 typedef wxAppConsole
* (*wxAppInitializerFunction
)();
43 // ----------------------------------------------------------------------------
45 // ----------------------------------------------------------------------------
50 wxPRINT_POSTSCRIPT
= 2
53 // ----------------------------------------------------------------------------
54 // wxAppConsoleBase: wxApp for non-GUI applications
55 // ----------------------------------------------------------------------------
57 class WXDLLIMPEXP_BASE wxAppConsoleBase
: public wxEvtHandler
62 virtual ~wxAppConsoleBase();
65 // the virtual functions which may/must be overridden in the derived class
66 // -----------------------------------------------------------------------
68 // This is the very first function called for a newly created wxApp object,
69 // it is used by the library to do the global initialization. If, for some
70 // reason, you must override it (instead of just overriding OnInit(), as
71 // usual, for app-specific initializations), do not forget to call the base
73 virtual bool Initialize(int& argc
, wxChar
**argv
);
75 // This gives wxCocoa a chance to call OnInit() with a memory pool in place
76 virtual bool CallOnInit() { return OnInit(); }
78 // Called before OnRun(), this is a good place to do initialization -- if
79 // anything fails, return false from here to prevent the program from
80 // continuing. The command line is normally parsed here, call the base
81 // class OnInit() to do it.
82 virtual bool OnInit();
84 // this is here only temporary hopefully (FIXME)
85 virtual bool OnInitGui() { return true; }
87 // This is the replacement for the normal main(): all program work should
88 // be done here. When OnRun() returns, the programs starts shutting down.
91 // This is only called if OnInit() returned true so it's a good place to do
92 // any cleanup matching the initializations done there.
95 // This is the very last function called on wxApp object before it is
96 // destroyed. If you override it (instead of overriding OnExit() as usual)
97 // do not forget to call the base class version!
98 virtual void CleanUp();
100 // Called when a fatal exception occurs, this function should take care not
101 // to do anything which might provoke a nested exception! It may be
102 // overridden if you wish to react somehow in non-default way (core dump
103 // under Unix, application crash under Windows) to fatal program errors,
104 // however extreme care should be taken if you don't want this function to
106 virtual void OnFatalException() { }
108 // Called from wxExit() function, should terminate the application a.s.a.p.
112 // application info: name, description, vendor
113 // -------------------------------------------
115 // NB: all these should be set by the application itself, there are no
116 // reasonable default except for the application name which is taken to
119 // set/get the application name
120 wxString
GetAppName() const
122 return m_appName
.empty() ? m_className
: m_appName
;
124 void SetAppName(const wxString
& name
) { m_appName
= name
; }
126 // set/get the app class name
127 wxString
GetClassName() const { return m_className
; }
128 void SetClassName(const wxString
& name
) { m_className
= name
; }
130 // set/get the vendor name
131 const wxString
& GetVendorName() const { return m_vendorName
; }
132 void SetVendorName(const wxString
& name
) { m_vendorName
= name
; }
135 // cmd line parsing stuff
136 // ----------------------
138 // all of these methods may be overridden in the derived class to
139 // customize the command line parsing (by default only a few standard
140 // options are handled)
142 // you also need to call wxApp::OnInit() from YourApp::OnInit() for all
145 #if wxUSE_CMDLINE_PARSER
146 // this one is called from OnInit() to add all supported options
147 // to the given parser (don't forget to call the base class version if you
149 virtual void OnInitCmdLine(wxCmdLineParser
& parser
);
151 // called after successfully parsing the command line, return true
152 // to continue and false to exit (don't forget to call the base class
153 // version if you override it!)
154 virtual bool OnCmdLineParsed(wxCmdLineParser
& parser
);
156 // called if "--help" option was specified, return true to continue
158 virtual bool OnCmdLineHelp(wxCmdLineParser
& parser
);
160 // called if incorrect command line options were given, return
161 // false to abort and true to continue
162 virtual bool OnCmdLineError(wxCmdLineParser
& parser
);
163 #endif // wxUSE_CMDLINE_PARSER
166 // miscellaneous customization functions
167 // -------------------------------------
169 // create the app traits object to which we delegate for everything which
170 // either should be configurable by the user (then he can change the
171 // default behaviour simply by overriding CreateTraits() and returning his
172 // own traits object) or which is GUI/console dependent as then wxAppTraits
173 // allows us to abstract the differences behind the common fa�de
174 wxAppTraits
*GetTraits();
177 // event processing functions
178 // --------------------------
180 // this method allows to filter all the events processed by the program, so
181 // you should try to return quickly from it to avoid slowing down the
182 // program to the crawl
184 // return value should be -1 to continue with the normal event processing,
185 // or TRUE or FALSE to stop further processing and pretend that the event
186 // had been already processed or won't be processed at all, respectively
187 virtual int FilterEvent(wxEvent
& event
);
190 // call the specified handler on the given object with the given event
192 // this method only exists to allow catching the exceptions thrown by any
193 // event handler, it would lead to an extra (useless) virtual function call
194 // if the exceptions were not used, so it doesn't even exist in that case
195 virtual void HandleEvent(wxEvtHandler
*handler
,
196 wxEventFunction func
,
197 wxEvent
& event
) const;
199 // Called when an unhandled C++ exception occurs inside OnRun(): note that
200 // the main event loop has already terminated by now and the program will
201 // exit, if you need to really handle the exceptions you need to override
202 // OnExceptionInMainLoop()
203 virtual void OnUnhandledException();
204 #endif // wxUSE_EXCEPTIONS
206 // event processing functions
207 // --------------------------
209 // return true if we're running event loop, i.e. if the events can
210 // (already) be dispatched
211 static bool IsMainLoopRunning();
213 // process all events in the wxPendingEvents list -- it is necessary to
214 // call this function to process posted events. This happens during each
215 // event loop iteration in GUI mode but if there is no main loop, it may be
216 // also called directly.
217 virtual void ProcessPendingEvents();
219 // check if there are pending events on global pending event list
220 bool HasPendingEvents() const;
222 // doesn't do anything in this class, just a hook for GUI wxApp
223 virtual bool Yield(bool WXUNUSED(onlyIfNeeded
) = false) { return true; }
225 // make sure that idle events are sent again
226 virtual void WakeUpIdle();
228 // execute the main GUI loop, the function returns when the loop ends
229 virtual int MainLoop();
231 // exit the main GUI loop during the next iteration (i.e. it does not
232 // stop the program immediately!)
233 virtual void ExitMainLoop();
235 // returns true if there are unprocessed events in the event queue
236 virtual bool Pending();
238 // process the first event in the event queue (blocks until an event
239 // appears if there are none currently, use Pending() if this is not
240 // wanted), returns false if the event loop should stop and true
242 virtual bool Dispatch();
244 // this virtual function is called when the application
245 // becomes idle and normally just sends wxIdleEvent to all interested
248 // it should return true if more idle events are needed, false if not
249 virtual bool ProcessIdle();
252 // Function called if an uncaught exception is caught inside the main
253 // event loop: it may return true to continue running the event loop or
254 // false to stop it (in the latter case it may rethrow the exception as
256 virtual bool OnExceptionInMainLoop();
257 #endif // wxUSE_EXCEPTIONS
263 // this function is called when an assert failure occurs, the base class
264 // version does the normal processing (i.e. shows the usual assert failure
267 // the arguments are the location of the failed assert (func may be empty
268 // if the compiler doesn't support C99 __FUNCTION__), the text of the
269 // assert itself and the user-specified message
270 virtual void OnAssertFailure(const wxChar
*file
,
276 // old version of the function without func parameter, for compatibility
277 // only, override OnAssertFailure() in the new code
278 virtual void OnAssert(const wxChar
*file
,
282 #endif // __WXDEBUG__
284 // check that the wxBuildOptions object (constructed in the application
285 // itself, usually the one from IMPLEMENT_APP() macro) matches the build
286 // options of the library and abort if it doesn't
287 static bool CheckBuildOptions(const char *optionsSignature
,
288 const char *componentName
);
290 // implementation only from now on
291 // -------------------------------
293 // helpers for dynamic wxApp construction
294 static void SetInitializerFunction(wxAppInitializerFunction fn
)
295 { ms_appInitFn
= fn
; }
296 static wxAppInitializerFunction
GetInitializerFunction()
297 { return ms_appInitFn
; }
299 // accessors for ms_appInstance field (external code might wish to modify
300 // it, this is why we provide a setter here as well, but you should really
301 // know what you're doing if you call it), wxTheApp is usually used instead
303 static wxAppConsole
*GetInstance() { return ms_appInstance
; }
304 static void SetInstance(wxAppConsole
*app
) { ms_appInstance
= app
; }
307 // command line arguments (public for backwards compatibility)
312 // the function which creates the traits object when GetTraits() needs it
313 // for the first time
314 virtual wxAppTraits
*CreateTraits();
317 // function used for dynamic wxApp creation
318 static wxAppInitializerFunction ms_appInitFn
;
320 // the one and only global application object
321 static wxAppConsole
*ms_appInstance
;
323 // create main loop from AppTraits or return NULL if
324 // there is no main loop implementation
325 wxEventLoopBase
*CreateMainLoop();
327 // application info (must be set from the user code)
328 wxString m_vendorName
, // vendor name (ACME Inc)
329 m_appName
, // app name
330 m_className
; // class name
332 // the class defining the application behaviour, NULL initially and created
333 // by GetTraits() when first needed
334 wxAppTraits
*m_traits
;
336 // the main event loop of the application (may be NULL if the loop hasn't
337 // been started yet or has already terminated)
338 wxEventLoopBase
*m_mainLoop
;
340 // the application object is a singleton anyhow, there is no sense in
342 DECLARE_NO_COPY_CLASS(wxAppConsoleBase
)
345 #if defined(__UNIX__)
346 #include "wx/unix/app.h"
348 // this has to be a class and not a typedef as we forward declare it
349 class wxAppConsole
: public wxAppConsoleBase
{ };
352 // ----------------------------------------------------------------------------
353 // wxAppBase: the common part of wxApp implementations for all platforms
354 // ----------------------------------------------------------------------------
358 class WXDLLIMPEXP_CORE wxAppBase
: public wxAppConsole
362 virtual ~wxAppBase();
364 // the virtual functions which may/must be overridden in the derived class
365 // -----------------------------------------------------------------------
367 // very first initialization function
369 // Override: very rarely
370 virtual bool Initialize(int& argc
, wxChar
**argv
);
372 // a platform-dependent version of OnInit(): the code here is likely to
373 // depend on the toolkit. default version does nothing.
376 virtual bool OnInitGui();
378 // called to start program execution - the default version just enters
379 // the main GUI loop in which events are received and processed until
380 // the last window is not deleted (if GetExitOnFrameDelete) or
381 // ExitMainLoop() is called. In console mode programs, the execution
382 // of the program really starts here
384 // Override: rarely in GUI applications, always in console ones.
387 // a matching function for OnInit()
388 virtual int OnExit();
390 // very last clean up function
392 // Override: very rarely
393 virtual void CleanUp();
396 // the worker functions - usually not used directly by the user code
397 // -----------------------------------------------------------------
401 // process all currently pending events right now
403 // it is an error to call Yield() recursively unless the value of
404 // onlyIfNeeded is true
406 // WARNING: this function is dangerous as it can lead to unexpected
407 // reentrancies (i.e. when called from an event handler it
408 // may result in calling the same event handler again), use
409 // with _extreme_ care or, better, don't use at all!
410 virtual bool Yield(bool onlyIfNeeded
= false) = 0;
412 // this virtual function is called in the GUI mode when the application
413 // becomes idle and normally just sends wxIdleEvent to all interested
416 // it should return true if more idle events are needed, false if not
417 virtual bool ProcessIdle();
419 // Send idle event to window and all subwindows
420 // Returns true if more idle time is requested.
421 virtual bool SendIdleEvents(wxWindow
* win
, wxIdleEvent
& event
);
424 // top level window functions
425 // --------------------------
427 // return true if our app has focus
428 virtual bool IsActive() const { return m_isActive
; }
430 // set the "main" top level window
431 void SetTopWindow(wxWindow
*win
) { m_topWindow
= win
; }
433 // return the "main" top level window (if it hadn't been set previously
434 // with SetTopWindow(), will return just some top level window and, if
435 // there are none, will return NULL)
436 virtual wxWindow
*GetTopWindow() const;
438 // control the exit behaviour: by default, the program will exit the
439 // main loop (and so, usually, terminate) when the last top-level
440 // program window is deleted. Beware that if you disable this behaviour
441 // (with SetExitOnFrameDelete(false)), you'll have to call
442 // ExitMainLoop() explicitly from somewhere.
443 void SetExitOnFrameDelete(bool flag
)
444 { m_exitOnFrameDelete
= flag
? Yes
: No
; }
445 bool GetExitOnFrameDelete() const
446 { return m_exitOnFrameDelete
== Yes
; }
449 // display mode, visual, printing mode, ...
450 // ------------------------------------------------------------------------
452 // Get display mode that is used use. This is only used in framebuffer
453 // wxWin ports (such as wxMGL or wxDFB).
454 virtual wxVideoMode
GetDisplayMode() const;
455 // Set display mode to use. This is only used in framebuffer wxWin
456 // ports (such as wxMGL or wxDFB). This method should be called from
458 virtual bool SetDisplayMode(const wxVideoMode
& WXUNUSED(info
)) { return true; }
460 // set use of best visual flag (see below)
461 void SetUseBestVisual( bool flag
, bool forceTrueColour
= false )
462 { m_useBestVisual
= flag
; m_forceTrueColour
= forceTrueColour
; }
463 bool GetUseBestVisual() const { return m_useBestVisual
; }
465 // set/get printing mode: see wxPRINT_XXX constants.
467 // default behaviour is the normal one for Unix: always use PostScript
469 virtual void SetPrintMode(int WXUNUSED(mode
)) { }
470 int GetPrintMode() const { return wxPRINT_POSTSCRIPT
; }
472 // Return the layout direction for the current locale or wxLayout_Default
474 virtual wxLayoutDirection
GetLayoutDirection() const;
477 // command line parsing (GUI-specific)
478 // ------------------------------------------------------------------------
480 #if wxUSE_CMDLINE_PARSER
481 virtual bool OnCmdLineParsed(wxCmdLineParser
& parser
);
482 virtual void OnInitCmdLine(wxCmdLineParser
& parser
);
485 // miscellaneous other stuff
486 // ------------------------------------------------------------------------
488 // called by toolkit-specific code to set the app status: active (we have
489 // focus) or not and also the last window which had focus before we were
491 virtual void SetActive(bool isActive
, wxWindow
*lastFocus
);
493 #if WXWIN_COMPATIBILITY_2_6
494 // OBSOLETE: don't use, always returns true
496 // returns true if the program is successfully initialized
497 wxDEPRECATED( bool Initialized() );
498 #endif // WXWIN_COMPATIBILITY_2_6
501 // delete all objects in wxPendingDelete list
502 void DeletePendingObjects();
504 // override base class method to use GUI traits
505 virtual wxAppTraits
*CreateTraits();
508 // the main top level window (may be NULL)
509 wxWindow
*m_topWindow
;
511 // if Yes, exit the main loop when the last top level window is deleted, if
512 // No don't do it and if Later -- only do it once we reach our OnRun()
514 // the explanation for using this strange scheme is given in appcmn.cpp
520 } m_exitOnFrameDelete
;
522 // true if the app wants to use the best visual on systems where
523 // more than one are available (Sun, SGI, XFree86 4.0 ?)
524 bool m_useBestVisual
;
525 // force TrueColour just in case "best" isn't TrueColour
526 bool m_forceTrueColour
;
528 // does any of our windows have focus?
532 DECLARE_NO_COPY_CLASS(wxAppBase
)
535 #if WXWIN_COMPATIBILITY_2_6
536 inline bool wxAppBase::Initialized() { return true; }
537 #endif // WXWIN_COMPATIBILITY_2_6
539 // ----------------------------------------------------------------------------
540 // now include the declaration of the real class
541 // ----------------------------------------------------------------------------
543 #if defined(__WXPALMOS__)
544 #include "wx/palmos/app.h"
545 #elif defined(__WXMSW__)
546 #include "wx/msw/app.h"
547 #elif defined(__WXMOTIF__)
548 #include "wx/motif/app.h"
549 #elif defined(__WXMGL__)
550 #include "wx/mgl/app.h"
551 #elif defined(__WXDFB__)
552 #include "wx/dfb/app.h"
553 #elif defined(__WXGTK20__)
554 #include "wx/gtk/app.h"
555 #elif defined(__WXGTK__)
556 #include "wx/gtk1/app.h"
557 #elif defined(__WXX11__)
558 #include "wx/x11/app.h"
559 #elif defined(__WXMAC__)
560 #include "wx/mac/app.h"
561 #elif defined(__WXCOCOA__)
562 #include "wx/cocoa/app.h"
563 #elif defined(__WXPM__)
564 #include "wx/os2/app.h"
569 // wxApp is defined in core and we cannot define another one in wxBase,
570 // so use the preprocessor to allow using wxApp in console programs too
571 #define wxApp wxAppConsole
575 // ----------------------------------------------------------------------------
577 // ----------------------------------------------------------------------------
579 // for compatibility, we define this macro to access the global application
580 // object of type wxApp
582 // note that instead of using of wxTheApp in application code you should
583 // consider using DECLARE_APP() after which you may call wxGetApp() which will
584 // return the object of the correct type (i.e. MyApp and not wxApp)
586 // the cast is safe as in GUI build we only use wxApp, not wxAppConsole, and in
587 // console mode it does nothing at all
588 #define wxTheApp wx_static_cast(wxApp*, wxApp::GetInstance())
590 // ----------------------------------------------------------------------------
592 // ----------------------------------------------------------------------------
594 // event loop related functions only work in GUI programs
595 // ------------------------------------------------------
597 // Force an exit from main loop
598 extern void WXDLLIMPEXP_BASE
wxExit();
600 // Yield to other apps/messages
601 extern bool WXDLLIMPEXP_BASE
wxYield();
603 // Yield to other apps/messages
604 extern void WXDLLIMPEXP_BASE
wxWakeUpIdle();
606 // ----------------------------------------------------------------------------
607 // macros for dynamic creation of the application object
608 // ----------------------------------------------------------------------------
610 // Having a global instance of this class allows wxApp to be aware of the app
611 // creator function. wxApp can then call this function to create a new app
612 // object. Convoluted, but necessary.
614 class WXDLLIMPEXP_BASE wxAppInitializer
617 wxAppInitializer(wxAppInitializerFunction fn
)
618 { wxApp::SetInitializerFunction(fn
); }
621 // the code below defines a IMPLEMENT_WXWIN_MAIN macro which you can use if
622 // your compiler really, really wants main() to be in your main program (e.g.
623 // hello.cpp). Now IMPLEMENT_APP should add this code if required.
625 #define IMPLEMENT_WXWIN_MAIN_CONSOLE \
626 int main(int argc, char **argv) { return wxEntry(argc, argv); }
628 // port-specific header could have defined it already in some special way
629 #ifndef IMPLEMENT_WXWIN_MAIN
630 #define IMPLEMENT_WXWIN_MAIN IMPLEMENT_WXWIN_MAIN_CONSOLE
631 #endif // defined(IMPLEMENT_WXWIN_MAIN)
633 #ifdef __WXUNIVERSAL__
634 #include "wx/univ/theme.h"
636 #ifdef wxUNIV_DEFAULT_THEME
637 #define IMPLEMENT_WX_THEME_SUPPORT \
638 WX_USE_THEME(wxUNIV_DEFAULT_THEME);
640 #define IMPLEMENT_WX_THEME_SUPPORT
643 #define IMPLEMENT_WX_THEME_SUPPORT
646 // Use this macro if you want to define your own main() or WinMain() function
647 // and call wxEntry() from there.
648 #define IMPLEMENT_APP_NO_MAIN(appname) \
649 wxAppConsole *wxCreateApp() \
651 wxAppConsole::CheckBuildOptions(WX_BUILD_OPTIONS_SIGNATURE, \
653 return new appname; \
656 wxTheAppInitializer((wxAppInitializerFunction) wxCreateApp); \
657 DECLARE_APP(appname) \
658 appname& wxGetApp() { return *wx_static_cast(appname*, wxApp::GetInstance()); }
660 // Same as IMPLEMENT_APP() normally but doesn't include themes support in
661 // wxUniversal builds
662 #define IMPLEMENT_APP_NO_THEMES(appname) \
663 IMPLEMENT_APP_NO_MAIN(appname) \
666 // Use this macro exactly once, the argument is the name of the wxApp-derived
667 // class which is the class of your application.
668 #define IMPLEMENT_APP(appname) \
669 IMPLEMENT_APP_NO_THEMES(appname) \
670 IMPLEMENT_WX_THEME_SUPPORT
672 // Same as IMPLEMENT_APP(), but for console applications.
673 #define IMPLEMENT_APP_CONSOLE(appname) \
674 IMPLEMENT_APP_NO_MAIN(appname) \
675 IMPLEMENT_WXWIN_MAIN_CONSOLE
677 // this macro can be used multiple times and just allows you to use wxGetApp()
679 #define DECLARE_APP(appname) extern appname& wxGetApp();
682 // declare the stuff defined by IMPLEMENT_APP() macro, it's not really needed
683 // anywhere else but at the very least it suppresses icc warnings about
684 // defining extern symbols without prior declaration, and it shouldn't do any
686 extern wxAppConsole
*wxCreateApp();
687 extern wxAppInitializer wxTheAppInitializer
;
689 #endif // _WX_APP_H_BASE_