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