add wxAppConsoleBase::OnEventLoopEnter/Exit callbacks; add wxEventLoopBase::IsMain...
[wxWidgets.git] / include / wx / app.h
1 /////////////////////////////////////////////////////////////////////////////
2 // Name: wx/app.h
3 // Purpose: wxAppBase class and macros used for declaration of wxApp
4 // derived class in the user code
5 // Author: Julian Smart
6 // Modified by:
7 // Created: 01/02/97
8 // RCS-ID: $Id$
9 // Copyright: (c) Julian Smart
10 // Licence: wxWindows licence
11 /////////////////////////////////////////////////////////////////////////////
12
13 #ifndef _WX_APP_H_BASE_
14 #define _WX_APP_H_BASE_
15
16 // ----------------------------------------------------------------------------
17 // headers we have to include here
18 // ----------------------------------------------------------------------------
19
20 #include "wx/event.h" // for the base class
21 #include "wx/build.h"
22 #include "wx/cmdargs.h" // for wxCmdLineArgsArray used by wxApp::argv
23 #include "wx/init.h" // we must declare wxEntry()
24 #include "wx/intl.h" // for wxLayoutDirection
25
26 class WXDLLIMPEXP_FWD_BASE wxAppConsole;
27 class WXDLLIMPEXP_FWD_BASE wxAppTraits;
28 class WXDLLIMPEXP_FWD_BASE wxCmdLineParser;
29 class WXDLLIMPEXP_FWD_BASE wxEventLoopBase;
30 class WXDLLIMPEXP_FWD_BASE wxLog;
31 class WXDLLIMPEXP_FWD_BASE wxMessageOutput;
32
33 #if wxUSE_GUI
34 struct WXDLLIMPEXP_FWD_CORE wxVideoMode;
35 class WXDLLIMPEXP_FWD_CORE wxWindow;
36 #endif
37
38 // ----------------------------------------------------------------------------
39 // typedefs
40 // ----------------------------------------------------------------------------
41
42 // the type of the function used to create a wxApp object on program start up
43 typedef wxAppConsole* (*wxAppInitializerFunction)();
44
45 // ----------------------------------------------------------------------------
46 // constants
47 // ----------------------------------------------------------------------------
48
49 enum
50 {
51 wxPRINT_WINDOWS = 1,
52 wxPRINT_POSTSCRIPT = 2
53 };
54
55 // ----------------------------------------------------------------------------
56 // wxAppConsoleBase: wxApp for non-GUI applications
57 // ----------------------------------------------------------------------------
58
59 class WXDLLIMPEXP_BASE wxAppConsoleBase : public wxEvtHandler
60 {
61 public:
62 // ctor and dtor
63 wxAppConsoleBase();
64 virtual ~wxAppConsoleBase();
65
66
67 // the virtual functions which may/must be overridden in the derived class
68 // -----------------------------------------------------------------------
69
70 // This is the very first function called for a newly created wxApp object,
71 // it is used by the library to do the global initialization. If, for some
72 // reason, you must override it (instead of just overriding OnInit(), as
73 // usual, for app-specific initializations), do not forget to call the base
74 // class version!
75 virtual bool Initialize(int& argc, wxChar **argv);
76
77 // This gives wxCocoa a chance to call OnInit() with a memory pool in place
78 virtual bool CallOnInit() { return OnInit(); }
79
80 // Called before OnRun(), this is a good place to do initialization -- if
81 // anything fails, return false from here to prevent the program from
82 // continuing. The command line is normally parsed here, call the base
83 // class OnInit() to do it.
84 virtual bool OnInit();
85
86 // This is the replacement for the normal main(): all program work should
87 // be done here. When OnRun() returns, the programs starts shutting down.
88 virtual int OnRun();
89
90 // This is called by wxEventLoopBase::SetActive(): you should put the code
91 // which needs an active event loop here.
92 // Note that this function is called whenever an event loop is activated;
93 // you may want to use wxEventLoopBase::IsMain() to perform initialization
94 // specific for the app's main event loop.
95 virtual void OnEventLoopEnter(wxEventLoopBase* WXUNUSED(loop)) {}
96
97 // This is only called if OnInit() returned true so it's a good place to do
98 // any cleanup matching the initializations done there.
99 virtual int OnExit();
100
101 // This is called by wxEventLoopBase::OnExit() for each event loop which
102 // is exited.
103 virtual void OnEventLoopExit(wxEventLoopBase* WXUNUSED(loop)) {}
104
105 // This is the very last function called on wxApp object before it is
106 // destroyed. If you override it (instead of overriding OnExit() as usual)
107 // do not forget to call the base class version!
108 virtual void CleanUp();
109
110 // Called when a fatal exception occurs, this function should take care not
111 // to do anything which might provoke a nested exception! It may be
112 // overridden if you wish to react somehow in non-default way (core dump
113 // under Unix, application crash under Windows) to fatal program errors,
114 // however extreme care should be taken if you don't want this function to
115 // crash.
116 virtual void OnFatalException() { }
117
118 // Called from wxExit() function, should terminate the application a.s.a.p.
119 virtual void Exit();
120
121
122 // application info: name, description, vendor
123 // -------------------------------------------
124
125 // NB: all these should be set by the application itself, there are no
126 // reasonable default except for the application name which is taken to
127 // be argv[0]
128
129 // set/get the application name
130 wxString GetAppName() const
131 {
132 return m_appName.empty() ? m_className : m_appName;
133 }
134 void SetAppName(const wxString& name) { m_appName = name; }
135
136 // set/get the application display name: the display name is the name
137 // shown to the user in titles, reports, etc while the app name is
138 // used for paths, config, and other places the user doesn't see
139 //
140 // so the app name could be myapp while display name could be "My App"
141 wxString GetAppDisplayName() const
142 {
143 return m_appDisplayName.empty() ? GetAppName().Capitalize()
144 : m_appDisplayName;
145 }
146
147 void SetAppDisplayName(const wxString& name) { m_appDisplayName = name; }
148
149 // set/get the app class name
150 wxString GetClassName() const { return m_className; }
151 void SetClassName(const wxString& name) { m_className = name; }
152
153 // set/get the vendor name
154 const wxString& GetVendorName() const { return m_vendorName; }
155 void SetVendorName(const wxString& name) { m_vendorName = name; }
156
157 // set/get the vendor display name: the display name is shown
158 // in titles/reports/dialogs to the user, while the vendor name
159 // is used in some areas such as wxConfig, wxStandardPaths, etc
160 const wxString& GetVendorDisplayName() const
161 {
162 return m_vendorDisplayName.empty() ? GetVendorName()
163 : m_vendorDisplayName;
164 }
165 void SetVendorDisplayName(const wxString& name)
166 {
167 m_vendorDisplayName = name;
168 }
169
170
171 // cmd line parsing stuff
172 // ----------------------
173
174 // all of these methods may be overridden in the derived class to
175 // customize the command line parsing (by default only a few standard
176 // options are handled)
177 //
178 // you also need to call wxApp::OnInit() from YourApp::OnInit() for all
179 // this to work
180
181 #if wxUSE_CMDLINE_PARSER
182 // this one is called from OnInit() to add all supported options
183 // to the given parser (don't forget to call the base class version if you
184 // override it!)
185 virtual void OnInitCmdLine(wxCmdLineParser& parser);
186
187 // called after successfully parsing the command line, return true
188 // to continue and false to exit (don't forget to call the base class
189 // version if you override it!)
190 virtual bool OnCmdLineParsed(wxCmdLineParser& parser);
191
192 // called if "--help" option was specified, return true to continue
193 // and false to exit
194 virtual bool OnCmdLineHelp(wxCmdLineParser& parser);
195
196 // called if incorrect command line options were given, return
197 // false to abort and true to continue
198 virtual bool OnCmdLineError(wxCmdLineParser& parser);
199 #endif // wxUSE_CMDLINE_PARSER
200
201
202 // miscellaneous customization functions
203 // -------------------------------------
204
205 // create the app traits object to which we delegate for everything which
206 // either should be configurable by the user (then he can change the
207 // default behaviour simply by overriding CreateTraits() and returning his
208 // own traits object) or which is GUI/console dependent as then wxAppTraits
209 // allows us to abstract the differences behind the common facade
210 wxAppTraits *GetTraits();
211
212 // this function provides safer access to traits object than
213 // wxTheApp->GetTraits() during startup or termination when the global
214 // application object itself may be unavailable
215 //
216 // of course, it still returns NULL in this case and the caller must check
217 // for it
218 static wxAppTraits *GetTraitsIfExists();
219
220 // returns the main event loop instance, i.e. the event loop which is started
221 // by OnRun() and which dispatches all events sent from the native toolkit
222 // to the application (except when new event loops are temporarily set-up).
223 // The returned value maybe NULL. Put initialization code which needs a
224 // non-NULL main event loop into OnEventLoopEnter().
225 wxEventLoopBase* GetMainLoop() const
226 { return m_mainLoop; }
227
228
229 // event processing functions
230 // --------------------------
231
232 // this method allows to filter all the events processed by the program, so
233 // you should try to return quickly from it to avoid slowing down the
234 // program to the crawl
235 //
236 // return value should be -1 to continue with the normal event processing,
237 // or TRUE or FALSE to stop further processing and pretend that the event
238 // had been already processed or won't be processed at all, respectively
239 virtual int FilterEvent(wxEvent& event);
240
241 // return true if we're running event loop, i.e. if the events can
242 // (already) be dispatched
243 static bool IsMainLoopRunning();
244
245 #if wxUSE_EXCEPTIONS
246 // execute the functor to handle the given event
247 //
248 // this is a generalization of HandleEvent() below and the base class
249 // implementation of CallEventHandler() still calls HandleEvent() for
250 // compatibility for functors which are just wxEventFunctions (i.e. methods
251 // of wxEvtHandler)
252 virtual void CallEventHandler(wxEvtHandler *handler,
253 wxEventFunctor& functor,
254 wxEvent& event) const;
255
256 // call the specified handler on the given object with the given event
257 //
258 // this method only exists to allow catching the exceptions thrown by any
259 // event handler, it would lead to an extra (useless) virtual function call
260 // if the exceptions were not used, so it doesn't even exist in that case
261 virtual void HandleEvent(wxEvtHandler *handler,
262 wxEventFunction func,
263 wxEvent& event) const;
264
265 // Called when an unhandled C++ exception occurs inside OnRun(): note that
266 // the main event loop has already terminated by now and the program will
267 // exit, if you need to really handle the exceptions you need to override
268 // OnExceptionInMainLoop()
269 virtual void OnUnhandledException();
270
271 // Function called if an uncaught exception is caught inside the main
272 // event loop: it may return true to continue running the event loop or
273 // false to stop it (in the latter case it may rethrow the exception as
274 // well)
275 virtual bool OnExceptionInMainLoop();
276
277 #endif // wxUSE_EXCEPTIONS
278
279
280 // wxEventLoop redirections
281 // ------------------------
282
283 virtual void SuspendProcessingOfPendingEvents();
284 virtual void ResumeProcessingOfPendingEvents();
285 virtual void ProcessPendingEvents();
286 bool HasPendingEvents() const;
287
288 virtual bool Pending();
289 virtual bool Dispatch();
290
291 virtual int MainLoop();
292 virtual void ExitMainLoop();
293
294 bool Yield(bool onlyIfNeeded = false);
295
296 virtual void WakeUpIdle();
297 virtual bool ProcessIdle();
298
299
300 // debugging support
301 // -----------------
302
303 #ifdef __WXDEBUG__
304 // this function is called when an assert failure occurs, the base class
305 // version does the normal processing (i.e. shows the usual assert failure
306 // dialog box)
307 //
308 // the arguments are the location of the failed assert (func may be empty
309 // if the compiler doesn't support C99 __FUNCTION__), the text of the
310 // assert itself and the user-specified message
311 virtual void OnAssertFailure(const wxChar *file,
312 int line,
313 const wxChar *func,
314 const wxChar *cond,
315 const wxChar *msg);
316
317 // old version of the function without func parameter, for compatibility
318 // only, override OnAssertFailure() in the new code
319 virtual void OnAssert(const wxChar *file,
320 int line,
321 const wxChar *cond,
322 const wxChar *msg);
323 #endif // __WXDEBUG__
324
325 // check that the wxBuildOptions object (constructed in the application
326 // itself, usually the one from IMPLEMENT_APP() macro) matches the build
327 // options of the library and abort if it doesn't
328 static bool CheckBuildOptions(const char *optionsSignature,
329 const char *componentName);
330
331 // implementation only from now on
332 // -------------------------------
333
334 // helpers for dynamic wxApp construction
335 static void SetInitializerFunction(wxAppInitializerFunction fn)
336 { ms_appInitFn = fn; }
337 static wxAppInitializerFunction GetInitializerFunction()
338 { return ms_appInitFn; }
339
340 // accessors for ms_appInstance field (external code might wish to modify
341 // it, this is why we provide a setter here as well, but you should really
342 // know what you're doing if you call it), wxTheApp is usually used instead
343 // of GetInstance()
344 static wxAppConsole *GetInstance() { return ms_appInstance; }
345 static void SetInstance(wxAppConsole *app) { ms_appInstance = app; }
346
347
348 // command line arguments (public for backwards compatibility)
349 int argc;
350
351 // this object is implicitly convertible to either "char**" (traditional
352 // type of argv parameter of main()) or to "wchar_t **" (for compatibility
353 // with Unicode build in previous wx versions and because the command line
354 // can, in pr
355 #if wxUSE_UNICODE
356 wxCmdLineArgsArray argv;
357 #else
358 char **argv;
359 #endif
360
361 protected:
362 // the function which creates the traits object when GetTraits() needs it
363 // for the first time
364 virtual wxAppTraits *CreateTraits();
365
366 // function used for dynamic wxApp creation
367 static wxAppInitializerFunction ms_appInitFn;
368
369 // the one and only global application object
370 static wxAppConsole *ms_appInstance;
371
372 // create main loop from AppTraits or return NULL if
373 // there is no main loop implementation
374 wxEventLoopBase *CreateMainLoop();
375
376 // application info (must be set from the user code)
377 wxString m_vendorName, // vendor name ("acme")
378 m_vendorDisplayName, // vendor display name (e.g. "ACME Inc")
379 m_appName, // app name ("myapp")
380 m_appDisplayName, // app display name ("My Application")
381 m_className; // class name
382
383 // the class defining the application behaviour, NULL initially and created
384 // by GetTraits() when first needed
385 wxAppTraits *m_traits;
386
387 // the main event loop of the application (may be NULL if the loop hasn't
388 // been started yet or has already terminated)
389 wxEventLoopBase *m_mainLoop;
390
391 friend class WXDLLIMPEXP_FWD_BASE wxEvtHandler;
392
393 // the application object is a singleton anyhow, there is no sense in
394 // copying it
395 wxDECLARE_NO_COPY_CLASS(wxAppConsoleBase);
396 };
397
398 #if defined(__UNIX__)
399 #include "wx/unix/app.h"
400 #else
401 // this has to be a class and not a typedef as we forward declare it
402 class wxAppConsole : public wxAppConsoleBase { };
403 #endif
404
405 // ----------------------------------------------------------------------------
406 // wxAppBase: the common part of wxApp implementations for all platforms
407 // ----------------------------------------------------------------------------
408
409 #if wxUSE_GUI
410
411 class WXDLLIMPEXP_CORE wxAppBase : public wxAppConsole
412 {
413 public:
414 wxAppBase();
415 virtual ~wxAppBase();
416
417 // the virtual functions which may/must be overridden in the derived class
418 // -----------------------------------------------------------------------
419
420 // very first initialization function
421 //
422 // Override: very rarely
423 virtual bool Initialize(int& argc, wxChar **argv);
424
425 // a platform-dependent version of OnInit(): the code here is likely to
426 // depend on the toolkit. default version does nothing.
427 //
428 // Override: rarely.
429 virtual bool OnInitGui();
430
431 // called to start program execution - the default version just enters
432 // the main GUI loop in which events are received and processed until
433 // the last window is not deleted (if GetExitOnFrameDelete) or
434 // ExitMainLoop() is called. In console mode programs, the execution
435 // of the program really starts here
436 //
437 // Override: rarely in GUI applications, always in console ones.
438 virtual int OnRun();
439
440 // a matching function for OnInit()
441 virtual int OnExit();
442
443 // very last clean up function
444 //
445 // Override: very rarely
446 virtual void CleanUp();
447
448
449 // the worker functions - usually not used directly by the user code
450 // -----------------------------------------------------------------
451
452 // safer alternatives to Yield(), using wxWindowDisabler
453 virtual bool SafeYield(wxWindow *win, bool onlyIfNeeded);
454 virtual bool SafeYieldFor(wxWindow *win, long eventsToProcess);
455
456 // this virtual function is called in the GUI mode when the application
457 // becomes idle and normally just sends wxIdleEvent to all interested
458 // parties
459 //
460 // it should return true if more idle events are needed, false if not
461 virtual bool ProcessIdle();
462
463 // Send idle event to window and all subwindows
464 // Returns true if more idle time is requested.
465 virtual bool SendIdleEvents(wxWindow* win, wxIdleEvent& event);
466
467
468 // top level window functions
469 // --------------------------
470
471 // return true if our app has focus
472 virtual bool IsActive() const { return m_isActive; }
473
474 // set the "main" top level window
475 void SetTopWindow(wxWindow *win) { m_topWindow = win; }
476
477 // return the "main" top level window (if it hadn't been set previously
478 // with SetTopWindow(), will return just some top level window and, if
479 // there are none, will return NULL)
480 virtual wxWindow *GetTopWindow() const;
481
482 // control the exit behaviour: by default, the program will exit the
483 // main loop (and so, usually, terminate) when the last top-level
484 // program window is deleted. Beware that if you disable this behaviour
485 // (with SetExitOnFrameDelete(false)), you'll have to call
486 // ExitMainLoop() explicitly from somewhere.
487 void SetExitOnFrameDelete(bool flag)
488 { m_exitOnFrameDelete = flag ? Yes : No; }
489 bool GetExitOnFrameDelete() const
490 { return m_exitOnFrameDelete == Yes; }
491
492
493 // display mode, visual, printing mode, ...
494 // ------------------------------------------------------------------------
495
496 // Get display mode that is used use. This is only used in framebuffer
497 // wxWin ports (such as wxMGL or wxDFB).
498 virtual wxVideoMode GetDisplayMode() const;
499 // Set display mode to use. This is only used in framebuffer wxWin
500 // ports (such as wxMGL or wxDFB). This method should be called from
501 // wxApp::OnInitGui
502 virtual bool SetDisplayMode(const wxVideoMode& WXUNUSED(info)) { return true; }
503
504 // set use of best visual flag (see below)
505 void SetUseBestVisual( bool flag, bool forceTrueColour = false )
506 { m_useBestVisual = flag; m_forceTrueColour = forceTrueColour; }
507 bool GetUseBestVisual() const { return m_useBestVisual; }
508
509 // set/get printing mode: see wxPRINT_XXX constants.
510 //
511 // default behaviour is the normal one for Unix: always use PostScript
512 // printing.
513 virtual void SetPrintMode(int WXUNUSED(mode)) { }
514 int GetPrintMode() const { return wxPRINT_POSTSCRIPT; }
515
516 // Return the layout direction for the current locale or wxLayout_Default
517 // if it's unknown
518 virtual wxLayoutDirection GetLayoutDirection() const;
519
520 // Change the theme used by the application, return true on success.
521 virtual bool SetNativeTheme(const wxString& WXUNUSED(theme)) { return false; }
522
523
524 // command line parsing (GUI-specific)
525 // ------------------------------------------------------------------------
526
527 #if wxUSE_CMDLINE_PARSER
528 virtual bool OnCmdLineParsed(wxCmdLineParser& parser);
529 virtual void OnInitCmdLine(wxCmdLineParser& parser);
530 #endif
531
532 // miscellaneous other stuff
533 // ------------------------------------------------------------------------
534
535 // called by toolkit-specific code to set the app status: active (we have
536 // focus) or not and also the last window which had focus before we were
537 // deactivated
538 virtual void SetActive(bool isActive, wxWindow *lastFocus);
539
540 #if WXWIN_COMPATIBILITY_2_6
541 // OBSOLETE: don't use, always returns true
542 //
543 // returns true if the program is successfully initialized
544 wxDEPRECATED( bool Initialized() );
545 #endif // WXWIN_COMPATIBILITY_2_6
546
547 protected:
548 // delete all objects in wxPendingDelete list
549 void DeletePendingObjects();
550
551 // override base class method to use GUI traits
552 virtual wxAppTraits *CreateTraits();
553
554
555 // the main top level window (may be NULL)
556 wxWindow *m_topWindow;
557
558 // if Yes, exit the main loop when the last top level window is deleted, if
559 // No don't do it and if Later -- only do it once we reach our OnRun()
560 //
561 // the explanation for using this strange scheme is given in appcmn.cpp
562 enum
563 {
564 Later = -1,
565 No,
566 Yes
567 } m_exitOnFrameDelete;
568
569 // true if the app wants to use the best visual on systems where
570 // more than one are available (Sun, SGI, XFree86 4.0 ?)
571 bool m_useBestVisual;
572 // force TrueColour just in case "best" isn't TrueColour
573 bool m_forceTrueColour;
574
575 // does any of our windows have focus?
576 bool m_isActive;
577
578 wxDECLARE_NO_COPY_CLASS(wxAppBase);
579 };
580
581 #if WXWIN_COMPATIBILITY_2_6
582 inline bool wxAppBase::Initialized() { return true; }
583 #endif // WXWIN_COMPATIBILITY_2_6
584
585 // ----------------------------------------------------------------------------
586 // now include the declaration of the real class
587 // ----------------------------------------------------------------------------
588
589 #if defined(__WXPALMOS__)
590 #include "wx/palmos/app.h"
591 #elif defined(__WXMSW__)
592 #include "wx/msw/app.h"
593 #elif defined(__WXMOTIF__)
594 #include "wx/motif/app.h"
595 #elif defined(__WXMGL__)
596 #include "wx/mgl/app.h"
597 #elif defined(__WXDFB__)
598 #include "wx/dfb/app.h"
599 #elif defined(__WXGTK20__)
600 #include "wx/gtk/app.h"
601 #elif defined(__WXGTK__)
602 #include "wx/gtk1/app.h"
603 #elif defined(__WXX11__)
604 #include "wx/x11/app.h"
605 #elif defined(__WXMAC__)
606 #include "wx/osx/app.h"
607 #elif defined(__WXCOCOA__)
608 #include "wx/cocoa/app.h"
609 #elif defined(__WXPM__)
610 #include "wx/os2/app.h"
611 #endif
612
613 #else // !GUI
614
615 // wxApp is defined in core and we cannot define another one in wxBase,
616 // so use the preprocessor to allow using wxApp in console programs too
617 #define wxApp wxAppConsole
618
619 #endif // GUI/!GUI
620
621 // ----------------------------------------------------------------------------
622 // the global data
623 // ----------------------------------------------------------------------------
624
625 // for compatibility, we define this macro to access the global application
626 // object of type wxApp
627 //
628 // note that instead of using of wxTheApp in application code you should
629 // consider using DECLARE_APP() after which you may call wxGetApp() which will
630 // return the object of the correct type (i.e. MyApp and not wxApp)
631 //
632 // the cast is safe as in GUI build we only use wxApp, not wxAppConsole, and in
633 // console mode it does nothing at all
634 #define wxTheApp static_cast<wxApp*>(wxApp::GetInstance())
635
636 // ----------------------------------------------------------------------------
637 // global functions
638 // ----------------------------------------------------------------------------
639
640 // event loop related functions only work in GUI programs
641 // ------------------------------------------------------
642
643 // Force an exit from main loop
644 WXDLLIMPEXP_BASE void wxExit();
645
646 // avoid redeclaring this function here if it had been already declared by
647 // wx/utils.h, this results in warnings from g++ with -Wredundant-decls
648 #ifndef wx_YIELD_DECLARED
649 #define wx_YIELD_DECLARED
650
651 // Yield to other apps/messages
652 WXDLLIMPEXP_CORE bool wxYield();
653
654 #endif // wx_YIELD_DECLARED
655
656 // Yield to other apps/messages
657 WXDLLIMPEXP_BASE void wxWakeUpIdle();
658
659 // ----------------------------------------------------------------------------
660 // macros for dynamic creation of the application object
661 // ----------------------------------------------------------------------------
662
663 // Having a global instance of this class allows wxApp to be aware of the app
664 // creator function. wxApp can then call this function to create a new app
665 // object. Convoluted, but necessary.
666
667 class WXDLLIMPEXP_BASE wxAppInitializer
668 {
669 public:
670 wxAppInitializer(wxAppInitializerFunction fn)
671 { wxApp::SetInitializerFunction(fn); }
672 };
673
674 // the code below defines a IMPLEMENT_WXWIN_MAIN macro which you can use if
675 // your compiler really, really wants main() to be in your main program (e.g.
676 // hello.cpp). Now IMPLEMENT_APP should add this code if required.
677
678 #define IMPLEMENT_WXWIN_MAIN_CONSOLE \
679 int main(int argc, char **argv) { return wxEntry(argc, argv); }
680
681 // port-specific header could have defined it already in some special way
682 #ifndef IMPLEMENT_WXWIN_MAIN
683 #define IMPLEMENT_WXWIN_MAIN IMPLEMENT_WXWIN_MAIN_CONSOLE
684 #endif // defined(IMPLEMENT_WXWIN_MAIN)
685
686 #ifdef __WXUNIVERSAL__
687 #include "wx/univ/theme.h"
688
689 #ifdef wxUNIV_DEFAULT_THEME
690 #define IMPLEMENT_WX_THEME_SUPPORT \
691 WX_USE_THEME(wxUNIV_DEFAULT_THEME);
692 #else
693 #define IMPLEMENT_WX_THEME_SUPPORT
694 #endif
695 #else
696 #define IMPLEMENT_WX_THEME_SUPPORT
697 #endif
698
699 // Use this macro if you want to define your own main() or WinMain() function
700 // and call wxEntry() from there.
701 #define IMPLEMENT_APP_NO_MAIN(appname) \
702 wxAppConsole *wxCreateApp() \
703 { \
704 wxAppConsole::CheckBuildOptions(WX_BUILD_OPTIONS_SIGNATURE, \
705 "your program"); \
706 return new appname; \
707 } \
708 wxAppInitializer \
709 wxTheAppInitializer((wxAppInitializerFunction) wxCreateApp); \
710 DECLARE_APP(appname) \
711 appname& wxGetApp() { return *static_cast<appname*>(wxApp::GetInstance()); }
712
713 // Same as IMPLEMENT_APP() normally but doesn't include themes support in
714 // wxUniversal builds
715 #define IMPLEMENT_APP_NO_THEMES(appname) \
716 IMPLEMENT_APP_NO_MAIN(appname) \
717 IMPLEMENT_WXWIN_MAIN
718
719 // Use this macro exactly once, the argument is the name of the wxApp-derived
720 // class which is the class of your application.
721 #define IMPLEMENT_APP(appname) \
722 IMPLEMENT_APP_NO_THEMES(appname) \
723 IMPLEMENT_WX_THEME_SUPPORT
724
725 // Same as IMPLEMENT_APP(), but for console applications.
726 #define IMPLEMENT_APP_CONSOLE(appname) \
727 IMPLEMENT_APP_NO_MAIN(appname) \
728 IMPLEMENT_WXWIN_MAIN_CONSOLE
729
730 // this macro can be used multiple times and just allows you to use wxGetApp()
731 // function
732 #define DECLARE_APP(appname) extern appname& wxGetApp();
733
734
735 // declare the stuff defined by IMPLEMENT_APP() macro, it's not really needed
736 // anywhere else but at the very least it suppresses icc warnings about
737 // defining extern symbols without prior declaration, and it shouldn't do any
738 // harm
739 extern wxAppConsole *wxCreateApp();
740 extern wxAppInitializer wxTheAppInitializer;
741
742 #endif // _WX_APP_H_BASE_