]> git.saurik.com Git - wxWidgets.git/blame_incremental - include/wx/app.h
don't draw borders for bitmap buttons with wxBORDER_NONE style
[wxWidgets.git] / include / wx / app.h
... / ...
CommitLineData
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
26class WXDLLIMPEXP_FWD_BASE wxAppConsole;
27class WXDLLIMPEXP_FWD_BASE wxAppTraits;
28class WXDLLIMPEXP_FWD_BASE wxCmdLineParser;
29class WXDLLIMPEXP_FWD_BASE wxEventLoopBase;
30class WXDLLIMPEXP_FWD_BASE wxLog;
31class 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
43typedef wxAppConsole* (*wxAppInitializerFunction)();
44
45// ----------------------------------------------------------------------------
46// constants
47// ----------------------------------------------------------------------------
48
49enum
50{
51 wxPRINT_WINDOWS = 1,
52 wxPRINT_POSTSCRIPT = 2
53};
54
55// ----------------------------------------------------------------------------
56// wxAppConsoleBase: wxApp for non-GUI applications
57// ----------------------------------------------------------------------------
58
59class WXDLLIMPEXP_BASE wxAppConsoleBase : public wxEvtHandler
60{
61public:
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 // pending events
281 // --------------
282
283 // IMPORTANT: all these methods conceptually belong to wxEventLoopBase
284 // but for many reasons we need to allow queuing of events
285 // even when there's no event loop (e.g. in wxApp::OnInit);
286 // this feature is used e.g. to queue events on secondary threads
287 // or in wxPython to use wx.CallAfter before the GUI is initialized
288
289 // process all events in the m_handlersWithPendingEvents list -- it is necessary
290 // to call this function to process posted events. This happens during each
291 // event loop iteration in GUI mode but if there is no main loop, it may be
292 // also called directly.
293 virtual void ProcessPendingEvents();
294
295 // check if there are pending events on global pending event list
296 bool HasPendingEvents() const;
297
298 // temporary suspends processing of the pending events
299 void SuspendProcessingOfPendingEvents();
300
301 // resume processing of the pending events previously stopped because of a
302 // call to SuspendProcessingOfPendingEvents()
303 void ResumeProcessingOfPendingEvents();
304
305 // called by ~wxEvtHandler to (eventually) remove the handler from the list of
306 // the handlers with pending events
307 void RemovePendingEventHandler(wxEvtHandler* toRemove);
308
309 // adds an event handler to the list of the handlers with pending events
310 void AppendPendingEventHandler(wxEvtHandler* toAppend);
311
312 // moves the event handler from the list of the handlers with pending events
313 //to the list of the handlers with _delayed_ pending events
314 void DelayPendingEventHandler(wxEvtHandler* toDelay);
315
316 // deletes the current pending events
317 void DeletePendingEvents();
318
319
320 // wxEventLoop redirections
321 // ------------------------
322
323 virtual bool Pending();
324 virtual bool Dispatch();
325
326 virtual int MainLoop();
327 virtual void ExitMainLoop();
328
329 bool Yield(bool onlyIfNeeded = false);
330
331 virtual void WakeUpIdle();
332 virtual bool ProcessIdle();
333
334
335 // debugging support
336 // -----------------
337
338 // this function is called when an assert failure occurs, the base class
339 // version does the normal processing (i.e. shows the usual assert failure
340 // dialog box)
341 //
342 // the arguments are the location of the failed assert (func may be empty
343 // if the compiler doesn't support C99 __FUNCTION__), the text of the
344 // assert itself and the user-specified message
345 virtual void OnAssertFailure(const wxChar *file,
346 int line,
347 const wxChar *func,
348 const wxChar *cond,
349 const wxChar *msg);
350
351 // old version of the function without func parameter, for compatibility
352 // only, override OnAssertFailure() in the new code
353 virtual void OnAssert(const wxChar *file,
354 int line,
355 const wxChar *cond,
356 const wxChar *msg);
357
358 // check that the wxBuildOptions object (constructed in the application
359 // itself, usually the one from IMPLEMENT_APP() macro) matches the build
360 // options of the library and abort if it doesn't
361 static bool CheckBuildOptions(const char *optionsSignature,
362 const char *componentName);
363
364 // implementation only from now on
365 // -------------------------------
366
367 // helpers for dynamic wxApp construction
368 static void SetInitializerFunction(wxAppInitializerFunction fn)
369 { ms_appInitFn = fn; }
370 static wxAppInitializerFunction GetInitializerFunction()
371 { return ms_appInitFn; }
372
373 // accessors for ms_appInstance field (external code might wish to modify
374 // it, this is why we provide a setter here as well, but you should really
375 // know what you're doing if you call it), wxTheApp is usually used instead
376 // of GetInstance()
377 static wxAppConsole *GetInstance() { return ms_appInstance; }
378 static void SetInstance(wxAppConsole *app) { ms_appInstance = app; }
379
380
381 // command line arguments (public for backwards compatibility)
382 int argc;
383
384 // this object is implicitly convertible to either "char**" (traditional
385 // type of argv parameter of main()) or to "wchar_t **" (for compatibility
386 // with Unicode build in previous wx versions and because the command line
387 // can, in pr
388#if wxUSE_UNICODE
389 wxCmdLineArgsArray argv;
390#else
391 char **argv;
392#endif
393
394protected:
395 // the function which creates the traits object when GetTraits() needs it
396 // for the first time
397 virtual wxAppTraits *CreateTraits();
398
399 // function used for dynamic wxApp creation
400 static wxAppInitializerFunction ms_appInitFn;
401
402 // the one and only global application object
403 static wxAppConsole *ms_appInstance;
404
405 // create main loop from AppTraits or return NULL if
406 // there is no main loop implementation
407 wxEventLoopBase *CreateMainLoop();
408
409 // application info (must be set from the user code)
410 wxString m_vendorName, // vendor name ("acme")
411 m_vendorDisplayName, // vendor display name (e.g. "ACME Inc")
412 m_appName, // app name ("myapp")
413 m_appDisplayName, // app display name ("My Application")
414 m_className; // class name
415
416 // the class defining the application behaviour, NULL initially and created
417 // by GetTraits() when first needed
418 wxAppTraits *m_traits;
419
420 // the main event loop of the application (may be NULL if the loop hasn't
421 // been started yet or has already terminated)
422 wxEventLoopBase *m_mainLoop;
423
424
425 // pending events management vars:
426
427 // the array of the handlers with pending events which needs to be processed
428 // inside ProcessPendingEvents()
429 wxEvtHandlerArray m_handlersWithPendingEvents;
430
431 // helper array used by ProcessPendingEvents() to store the event handlers
432 // which have pending events but of these events none can be processed right now
433 // (because of a call to wxEventLoop::YieldFor() which asked to selectively process
434 // pending events)
435 wxEvtHandlerArray m_handlersWithPendingDelayedEvents;
436
437#if wxUSE_THREADS
438 // this critical section protects both the lists above
439 wxCriticalSection m_handlersWithPendingEventsLocker;
440#endif
441
442 // flag modified by Suspend/ResumeProcessingOfPendingEvents()
443 bool m_bDoPendingEventProcessing;
444
445 friend class WXDLLIMPEXP_FWD_BASE wxEvtHandler;
446
447 // the application object is a singleton anyhow, there is no sense in
448 // copying it
449 wxDECLARE_NO_COPY_CLASS(wxAppConsoleBase);
450};
451
452#if defined(__UNIX__)
453 #include "wx/unix/app.h"
454#else
455 // this has to be a class and not a typedef as we forward declare it
456 class wxAppConsole : public wxAppConsoleBase { };
457#endif
458
459// ----------------------------------------------------------------------------
460// wxAppBase: the common part of wxApp implementations for all platforms
461// ----------------------------------------------------------------------------
462
463#if wxUSE_GUI
464
465class WXDLLIMPEXP_CORE wxAppBase : public wxAppConsole
466{
467public:
468 wxAppBase();
469 virtual ~wxAppBase();
470
471 // the virtual functions which may/must be overridden in the derived class
472 // -----------------------------------------------------------------------
473
474 // very first initialization function
475 //
476 // Override: very rarely
477 virtual bool Initialize(int& argc, wxChar **argv);
478
479 // a platform-dependent version of OnInit(): the code here is likely to
480 // depend on the toolkit. default version does nothing.
481 //
482 // Override: rarely.
483 virtual bool OnInitGui();
484
485 // called to start program execution - the default version just enters
486 // the main GUI loop in which events are received and processed until
487 // the last window is not deleted (if GetExitOnFrameDelete) or
488 // ExitMainLoop() is called. In console mode programs, the execution
489 // of the program really starts here
490 //
491 // Override: rarely in GUI applications, always in console ones.
492 virtual int OnRun();
493
494 // a matching function for OnInit()
495 virtual int OnExit();
496
497 // very last clean up function
498 //
499 // Override: very rarely
500 virtual void CleanUp();
501
502
503 // the worker functions - usually not used directly by the user code
504 // -----------------------------------------------------------------
505
506 // safer alternatives to Yield(), using wxWindowDisabler
507 virtual bool SafeYield(wxWindow *win, bool onlyIfNeeded);
508 virtual bool SafeYieldFor(wxWindow *win, long eventsToProcess);
509
510 // this virtual function is called in the GUI mode when the application
511 // becomes idle and normally just sends wxIdleEvent to all interested
512 // parties
513 //
514 // it should return true if more idle events are needed, false if not
515 virtual bool ProcessIdle();
516
517 // Send idle event to window and all subwindows
518 // Returns true if more idle time is requested.
519 virtual bool SendIdleEvents(wxWindow* win, wxIdleEvent& event);
520
521
522 // top level window functions
523 // --------------------------
524
525 // return true if our app has focus
526 virtual bool IsActive() const { return m_isActive; }
527
528 // set the "main" top level window
529 void SetTopWindow(wxWindow *win) { m_topWindow = win; }
530
531 // return the "main" top level window (if it hadn't been set previously
532 // with SetTopWindow(), will return just some top level window and, if
533 // there are none, will return NULL)
534 virtual wxWindow *GetTopWindow() const;
535
536 // control the exit behaviour: by default, the program will exit the
537 // main loop (and so, usually, terminate) when the last top-level
538 // program window is deleted. Beware that if you disable this behaviour
539 // (with SetExitOnFrameDelete(false)), you'll have to call
540 // ExitMainLoop() explicitly from somewhere.
541 void SetExitOnFrameDelete(bool flag)
542 { m_exitOnFrameDelete = flag ? Yes : No; }
543 bool GetExitOnFrameDelete() const
544 { return m_exitOnFrameDelete == Yes; }
545
546
547 // display mode, visual, printing mode, ...
548 // ------------------------------------------------------------------------
549
550 // Get display mode that is used use. This is only used in framebuffer
551 // wxWin ports (such as wxMGL or wxDFB).
552 virtual wxVideoMode GetDisplayMode() const;
553 // Set display mode to use. This is only used in framebuffer wxWin
554 // ports (such as wxMGL or wxDFB). This method should be called from
555 // wxApp::OnInitGui
556 virtual bool SetDisplayMode(const wxVideoMode& WXUNUSED(info)) { return true; }
557
558 // set use of best visual flag (see below)
559 void SetUseBestVisual( bool flag, bool forceTrueColour = false )
560 { m_useBestVisual = flag; m_forceTrueColour = forceTrueColour; }
561 bool GetUseBestVisual() const { return m_useBestVisual; }
562
563 // set/get printing mode: see wxPRINT_XXX constants.
564 //
565 // default behaviour is the normal one for Unix: always use PostScript
566 // printing.
567 virtual void SetPrintMode(int WXUNUSED(mode)) { }
568 int GetPrintMode() const { return wxPRINT_POSTSCRIPT; }
569
570 // Return the layout direction for the current locale or wxLayout_Default
571 // if it's unknown
572 virtual wxLayoutDirection GetLayoutDirection() const;
573
574 // Change the theme used by the application, return true on success.
575 virtual bool SetNativeTheme(const wxString& WXUNUSED(theme)) { return false; }
576
577
578 // command line parsing (GUI-specific)
579 // ------------------------------------------------------------------------
580
581#if wxUSE_CMDLINE_PARSER
582 virtual bool OnCmdLineParsed(wxCmdLineParser& parser);
583 virtual void OnInitCmdLine(wxCmdLineParser& parser);
584#endif
585
586 // miscellaneous other stuff
587 // ------------------------------------------------------------------------
588
589 // called by toolkit-specific code to set the app status: active (we have
590 // focus) or not and also the last window which had focus before we were
591 // deactivated
592 virtual void SetActive(bool isActive, wxWindow *lastFocus);
593
594#if WXWIN_COMPATIBILITY_2_6
595 // OBSOLETE: don't use, always returns true
596 //
597 // returns true if the program is successfully initialized
598 wxDEPRECATED( bool Initialized() );
599#endif // WXWIN_COMPATIBILITY_2_6
600
601protected:
602 // delete all objects in wxPendingDelete list
603 void DeletePendingObjects();
604
605 // override base class method to use GUI traits
606 virtual wxAppTraits *CreateTraits();
607
608
609 // the main top level window (may be NULL)
610 wxWindow *m_topWindow;
611
612 // if Yes, exit the main loop when the last top level window is deleted, if
613 // No don't do it and if Later -- only do it once we reach our OnRun()
614 //
615 // the explanation for using this strange scheme is given in appcmn.cpp
616 enum
617 {
618 Later = -1,
619 No,
620 Yes
621 } m_exitOnFrameDelete;
622
623 // true if the app wants to use the best visual on systems where
624 // more than one are available (Sun, SGI, XFree86 4.0 ?)
625 bool m_useBestVisual;
626 // force TrueColour just in case "best" isn't TrueColour
627 bool m_forceTrueColour;
628
629 // does any of our windows have focus?
630 bool m_isActive;
631
632 wxDECLARE_NO_COPY_CLASS(wxAppBase);
633};
634
635#if WXWIN_COMPATIBILITY_2_6
636 inline bool wxAppBase::Initialized() { return true; }
637#endif // WXWIN_COMPATIBILITY_2_6
638
639// ----------------------------------------------------------------------------
640// now include the declaration of the real class
641// ----------------------------------------------------------------------------
642
643#if defined(__WXPALMOS__)
644 #include "wx/palmos/app.h"
645#elif defined(__WXMSW__)
646 #include "wx/msw/app.h"
647#elif defined(__WXMOTIF__)
648 #include "wx/motif/app.h"
649#elif defined(__WXMGL__)
650 #include "wx/mgl/app.h"
651#elif defined(__WXDFB__)
652 #include "wx/dfb/app.h"
653#elif defined(__WXGTK20__)
654 #include "wx/gtk/app.h"
655#elif defined(__WXGTK__)
656 #include "wx/gtk1/app.h"
657#elif defined(__WXX11__)
658 #include "wx/x11/app.h"
659#elif defined(__WXMAC__)
660 #include "wx/osx/app.h"
661#elif defined(__WXCOCOA__)
662 #include "wx/cocoa/app.h"
663#elif defined(__WXPM__)
664 #include "wx/os2/app.h"
665#endif
666
667#else // !GUI
668
669// wxApp is defined in core and we cannot define another one in wxBase,
670// so use the preprocessor to allow using wxApp in console programs too
671#define wxApp wxAppConsole
672
673#endif // GUI/!GUI
674
675// ----------------------------------------------------------------------------
676// the global data
677// ----------------------------------------------------------------------------
678
679// for compatibility, we define this macro to access the global application
680// object of type wxApp
681//
682// note that instead of using of wxTheApp in application code you should
683// consider using DECLARE_APP() after which you may call wxGetApp() which will
684// return the object of the correct type (i.e. MyApp and not wxApp)
685//
686// the cast is safe as in GUI build we only use wxApp, not wxAppConsole, and in
687// console mode it does nothing at all
688#define wxTheApp static_cast<wxApp*>(wxApp::GetInstance())
689
690// ----------------------------------------------------------------------------
691// global functions
692// ----------------------------------------------------------------------------
693
694// event loop related functions only work in GUI programs
695// ------------------------------------------------------
696
697// Force an exit from main loop
698WXDLLIMPEXP_BASE void wxExit();
699
700// avoid redeclaring this function here if it had been already declared by
701// wx/utils.h, this results in warnings from g++ with -Wredundant-decls
702#ifndef wx_YIELD_DECLARED
703#define wx_YIELD_DECLARED
704
705// Yield to other apps/messages
706WXDLLIMPEXP_CORE bool wxYield();
707
708#endif // wx_YIELD_DECLARED
709
710// Yield to other apps/messages
711WXDLLIMPEXP_BASE void wxWakeUpIdle();
712
713// ----------------------------------------------------------------------------
714// macros for dynamic creation of the application object
715// ----------------------------------------------------------------------------
716
717// Having a global instance of this class allows wxApp to be aware of the app
718// creator function. wxApp can then call this function to create a new app
719// object. Convoluted, but necessary.
720
721class WXDLLIMPEXP_BASE wxAppInitializer
722{
723public:
724 wxAppInitializer(wxAppInitializerFunction fn)
725 { wxApp::SetInitializerFunction(fn); }
726};
727
728// the code below defines a IMPLEMENT_WXWIN_MAIN macro which you can use if
729// your compiler really, really wants main() to be in your main program (e.g.
730// hello.cpp). Now IMPLEMENT_APP should add this code if required.
731
732#define IMPLEMENT_WXWIN_MAIN_CONSOLE \
733 int main(int argc, char **argv) { return wxEntry(argc, argv); }
734
735// port-specific header could have defined it already in some special way
736#ifndef IMPLEMENT_WXWIN_MAIN
737 #define IMPLEMENT_WXWIN_MAIN IMPLEMENT_WXWIN_MAIN_CONSOLE
738#endif // defined(IMPLEMENT_WXWIN_MAIN)
739
740#ifdef __WXUNIVERSAL__
741 #include "wx/univ/theme.h"
742
743 #ifdef wxUNIV_DEFAULT_THEME
744 #define IMPLEMENT_WX_THEME_SUPPORT \
745 WX_USE_THEME(wxUNIV_DEFAULT_THEME);
746 #else
747 #define IMPLEMENT_WX_THEME_SUPPORT
748 #endif
749#else
750 #define IMPLEMENT_WX_THEME_SUPPORT
751#endif
752
753// Use this macro if you want to define your own main() or WinMain() function
754// and call wxEntry() from there.
755#define IMPLEMENT_APP_NO_MAIN(appname) \
756 wxAppConsole *wxCreateApp() \
757 { \
758 wxAppConsole::CheckBuildOptions(WX_BUILD_OPTIONS_SIGNATURE, \
759 "your program"); \
760 return new appname; \
761 } \
762 wxAppInitializer \
763 wxTheAppInitializer((wxAppInitializerFunction) wxCreateApp); \
764 DECLARE_APP(appname) \
765 appname& wxGetApp() { return *static_cast<appname*>(wxApp::GetInstance()); }
766
767// Same as IMPLEMENT_APP() normally but doesn't include themes support in
768// wxUniversal builds
769#define IMPLEMENT_APP_NO_THEMES(appname) \
770 IMPLEMENT_APP_NO_MAIN(appname) \
771 IMPLEMENT_WXWIN_MAIN
772
773// Use this macro exactly once, the argument is the name of the wxApp-derived
774// class which is the class of your application.
775#define IMPLEMENT_APP(appname) \
776 IMPLEMENT_APP_NO_THEMES(appname) \
777 IMPLEMENT_WX_THEME_SUPPORT
778
779// Same as IMPLEMENT_APP(), but for console applications.
780#define IMPLEMENT_APP_CONSOLE(appname) \
781 IMPLEMENT_APP_NO_MAIN(appname) \
782 IMPLEMENT_WXWIN_MAIN_CONSOLE
783
784// this macro can be used multiple times and just allows you to use wxGetApp()
785// function
786#define DECLARE_APP(appname) extern appname& wxGetApp();
787
788
789// declare the stuff defined by IMPLEMENT_APP() macro, it's not really needed
790// anywhere else but at the very least it suppresses icc warnings about
791// defining extern symbols without prior declaration, and it shouldn't do any
792// harm
793extern wxAppConsole *wxCreateApp();
794extern wxAppInitializer wxTheAppInitializer;
795
796#endif // _WX_APP_H_BASE_