1
/////////////////////////////////////////////////////////////////////////////
3
// Purpose: wxAppBase class and macros used for declaration of wxApp
4
// derived class in the user code
5
// Author: Julian Smart
8
// Copyright: (c) Julian Smart
9
// Licence: wxWindows licence
10
/////////////////////////////////////////////////////////////////////////////
12
#ifndef _WX_APP_H_BASE_
13
#define _WX_APP_H_BASE_
15
// ----------------------------------------------------------------------------
16
// headers we have to include here
17
// ----------------------------------------------------------------------------
19
#include "wx/event.h" // for the base class
20
#include "wx/eventfilter.h" // (and another one)
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()
27
class WXDLLIMPEXP_FWD_BASE wxAppConsole;
28
class WXDLLIMPEXP_FWD_BASE wxAppTraits;
29
class WXDLLIMPEXP_FWD_BASE wxCmdLineParser;
30
class WXDLLIMPEXP_FWD_BASE wxEventLoopBase;
31
class WXDLLIMPEXP_FWD_BASE wxMessageOutput;
34
struct WXDLLIMPEXP_FWD_CORE wxVideoMode;
35
class WXDLLIMPEXP_FWD_CORE wxWindow;
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()
43
// ----------------------------------------------------------------------------
45
// ----------------------------------------------------------------------------
47
// the type of the function used to create a wxApp object on program start up
48
typedef wxAppConsole* (*wxAppInitializerFunction)();
50
// ----------------------------------------------------------------------------
52
// ----------------------------------------------------------------------------
57
wxPRINT_POSTSCRIPT = 2
60
// ----------------------------------------------------------------------------
62
// ----------------------------------------------------------------------------
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
67
extern WXDLLIMPEXP_DATA_BASE(wxList) wxPendingDelete;
69
// ----------------------------------------------------------------------------
70
// wxAppConsoleBase: wxApp for non-GUI applications
71
// ----------------------------------------------------------------------------
73
class WXDLLIMPEXP_BASE wxAppConsoleBase : public wxEvtHandler,
79
virtual ~wxAppConsoleBase();
82
// the virtual functions which may/must be overridden in the derived class
83
// -----------------------------------------------------------------------
85
// This is the very first function called for a newly created wxApp object,
86
// it is used by the library to do the global initialization. If, for some
87
// reason, you must override it (instead of just overriding OnInit(), as
88
// usual, for app-specific initializations), do not forget to call the base
90
virtual bool Initialize(int& argc, wxChar **argv);
92
// This gives wxCocoa a chance to call OnInit() with a memory pool in place
93
virtual bool CallOnInit() { return OnInit(); }
95
// Called before OnRun(), this is a good place to do initialization -- if
96
// anything fails, return false from here to prevent the program from
97
// continuing. The command line is normally parsed here, call the base
98
// class OnInit() to do it.
99
virtual bool OnInit();
101
// This is the replacement for the normal main(): all program work should
102
// be done here. When OnRun() returns, the programs starts shutting down.
105
// Called before the first events are handled, called from within MainLoop()
106
virtual void OnLaunched();
108
// This is called by wxEventLoopBase::SetActive(): you should put the code
109
// which needs an active event loop here.
110
// Note that this function is called whenever an event loop is activated;
111
// you may want to use wxEventLoopBase::IsMain() to perform initialization
112
// specific for the app's main event loop.
113
virtual void OnEventLoopEnter(wxEventLoopBase* WXUNUSED(loop)) {}
115
// This is only called if OnInit() returned true so it's a good place to do
116
// any cleanup matching the initializations done there.
117
virtual int OnExit();
119
// This is called by wxEventLoopBase::OnExit() for each event loop which
121
virtual void OnEventLoopExit(wxEventLoopBase* WXUNUSED(loop)) {}
123
// This is the very last function called on wxApp object before it is
124
// destroyed. If you override it (instead of overriding OnExit() as usual)
125
// do not forget to call the base class version!
126
virtual void CleanUp();
128
// Called when a fatal exception occurs, this function should take care not
129
// to do anything which might provoke a nested exception! It may be
130
// overridden if you wish to react somehow in non-default way (core dump
131
// under Unix, application crash under Windows) to fatal program errors,
132
// however extreme care should be taken if you don't want this function to
134
virtual void OnFatalException() { }
136
// Called from wxExit() function, should terminate the application a.s.a.p.
140
// application info: name, description, vendor
141
// -------------------------------------------
143
// NB: all these should be set by the application itself, there are no
144
// reasonable default except for the application name which is taken to
147
// set/get the application name
148
wxString GetAppName() const;
149
void SetAppName(const wxString& name) { m_appName = name; }
151
// set/get the application display name: the display name is the name
152
// shown to the user in titles, reports, etc while the app name is
153
// used for paths, config, and other places the user doesn't see
155
// by default the display name is the same as app name or a capitalized
156
// version of the program if app name was not set neither but it's
157
// usually better to set it explicitly to something nicer
158
wxString GetAppDisplayName() const;
160
void SetAppDisplayName(const wxString& name) { m_appDisplayName = name; }
162
// set/get the app class name
163
wxString GetClassName() const { return m_className; }
164
void SetClassName(const wxString& name) { m_className = name; }
166
// set/get the vendor name
167
const wxString& GetVendorName() const { return m_vendorName; }
168
void SetVendorName(const wxString& name) { m_vendorName = name; }
170
// set/get the vendor display name: the display name is shown
171
// in titles/reports/dialogs to the user, while the vendor name
172
// is used in some areas such as wxConfig, wxStandardPaths, etc
173
const wxString& GetVendorDisplayName() const
175
return m_vendorDisplayName.empty() ? GetVendorName()
176
: m_vendorDisplayName;
178
void SetVendorDisplayName(const wxString& name)
180
m_vendorDisplayName = name;
184
// cmd line parsing stuff
185
// ----------------------
187
// all of these methods may be overridden in the derived class to
188
// customize the command line parsing (by default only a few standard
189
// options are handled)
191
// you also need to call wxApp::OnInit() from YourApp::OnInit() for all
194
#if wxUSE_CMDLINE_PARSER
195
// this one is called from OnInit() to add all supported options
196
// to the given parser (don't forget to call the base class version if you
198
virtual void OnInitCmdLine(wxCmdLineParser& parser);
200
// called after successfully parsing the command line, return true
201
// to continue and false to exit (don't forget to call the base class
202
// version if you override it!)
203
virtual bool OnCmdLineParsed(wxCmdLineParser& parser);
205
// called if "--help" option was specified, return true to continue
207
virtual bool OnCmdLineHelp(wxCmdLineParser& parser);
209
// called if incorrect command line options were given, return
210
// false to abort and true to continue
211
virtual bool OnCmdLineError(wxCmdLineParser& parser);
212
#endif // wxUSE_CMDLINE_PARSER
215
// miscellaneous customization functions
216
// -------------------------------------
218
// create the app traits object to which we delegate for everything which
219
// either should be configurable by the user (then he can change the
220
// default behaviour simply by overriding CreateTraits() and returning his
221
// own traits object) or which is GUI/console dependent as then wxAppTraits
222
// allows us to abstract the differences behind the common facade
223
wxAppTraits *GetTraits();
225
// this function provides safer access to traits object than
226
// wxTheApp->GetTraits() during startup or termination when the global
227
// application object itself may be unavailable
229
// of course, it still returns NULL in this case and the caller must check
231
static wxAppTraits *GetTraitsIfExists();
233
// Return some valid traits object.
235
// This method checks if we have wxTheApp and returns its traits if it does
236
// exist and the traits are non-NULL, similarly to GetTraitsIfExists(), but
237
// falls back to wxConsoleAppTraits to ensure that it always returns
239
static wxAppTraits& GetValidTraits();
241
// returns the main event loop instance, i.e. the event loop which is started
242
// by OnRun() and which dispatches all events sent from the native toolkit
243
// to the application (except when new event loops are temporarily set-up).
244
// The returned value maybe NULL. Put initialization code which needs a
245
// non-NULL main event loop into OnEventLoopEnter().
246
wxEventLoopBase* GetMainLoop() const
247
{ return m_mainLoop; }
249
// This function sets the C locale to the default locale for the current
250
// environment. It is advised to call this to ensure that the underlying
251
// toolkit uses the locale in which the numbers and monetary amounts are
252
// shown in the format expected by user and so on.
254
// Notice that this does _not_ change the global C++ locale, you need to do
255
// it explicitly if you want.
257
// Finally, notice that while this function is virtual, it is not supposed
258
// to be overridden outside of the library itself.
259
virtual void SetCLocale();
262
// event processing functions
263
// --------------------------
265
// Implement the inherited wxEventFilter method but just return -1 from it
266
// to indicate that default processing should take place.
267
virtual int FilterEvent(wxEvent& event);
269
// return true if we're running event loop, i.e. if the events can
270
// (already) be dispatched
271
static bool IsMainLoopRunning();
274
// execute the functor to handle the given event
276
// this is a generalization of HandleEvent() below and the base class
277
// implementation of CallEventHandler() still calls HandleEvent() for
278
// compatibility for functors which are just wxEventFunctions (i.e. methods
280
virtual void CallEventHandler(wxEvtHandler *handler,
281
wxEventFunctor& functor,
282
wxEvent& event) const;
284
// call the specified handler on the given object with the given event
286
// this method only exists to allow catching the exceptions thrown by any
287
// event handler, it would lead to an extra (useless) virtual function call
288
// if the exceptions were not used, so it doesn't even exist in that case
289
virtual void HandleEvent(wxEvtHandler *handler,
290
wxEventFunction func,
291
wxEvent& event) const;
293
// Called when an unhandled C++ exception occurs inside OnRun(): note that
294
// the main event loop has already terminated by now and the program will
295
// exit, if you need to really handle the exceptions you need to override
296
// OnExceptionInMainLoop()
297
virtual void OnUnhandledException();
299
// Function called if an uncaught exception is caught inside the main
300
// event loop: it may return true to continue running the event loop or
301
// false to stop it (in the latter case it may rethrow the exception as
303
virtual bool OnExceptionInMainLoop();
305
#endif // wxUSE_EXCEPTIONS
311
// IMPORTANT: all these methods conceptually belong to wxEventLoopBase
312
// but for many reasons we need to allow queuing of events
313
// even when there's no event loop (e.g. in wxApp::OnInit);
314
// this feature is used e.g. to queue events on secondary threads
315
// or in wxPython to use wx.CallAfter before the GUI is initialized
317
// process all events in the m_handlersWithPendingEvents list -- it is necessary
318
// to call this function to process posted events. This happens during each
319
// event loop iteration in GUI mode but if there is no main loop, it may be
320
// also called directly.
321
virtual void ProcessPendingEvents();
323
// check if there are pending events on global pending event list
324
bool HasPendingEvents() const;
326
// temporary suspends processing of the pending events
327
void SuspendProcessingOfPendingEvents();
329
// resume processing of the pending events previously stopped because of a
330
// call to SuspendProcessingOfPendingEvents()
331
void ResumeProcessingOfPendingEvents();
333
// called by ~wxEvtHandler to (eventually) remove the handler from the list of
334
// the handlers with pending events
335
void RemovePendingEventHandler(wxEvtHandler* toRemove);
337
// adds an event handler to the list of the handlers with pending events
338
void AppendPendingEventHandler(wxEvtHandler* toAppend);
340
// moves the event handler from the list of the handlers with pending events
341
//to the list of the handlers with _delayed_ pending events
342
void DelayPendingEventHandler(wxEvtHandler* toDelay);
344
// deletes the current pending events
345
void DeletePendingEvents();
348
// delayed destruction
349
// -------------------
351
// If an object may have pending events for it, it shouldn't be deleted
352
// immediately as this would result in a crash when trying to handle these
353
// events: instead, it should be scheduled for destruction and really
354
// destroyed only after processing all pending events.
356
// Notice that this is only possible if we have a running event loop,
357
// otherwise the object is just deleted directly by ScheduleForDestruction()
358
// and IsScheduledForDestruction() always returns false.
360
// schedule the object for destruction in the near future
361
void ScheduleForDestruction(wxObject *object);
363
// return true if the object is scheduled for destruction
364
bool IsScheduledForDestruction(wxObject *object) const;
367
// wxEventLoop-related methods
368
// ---------------------------
370
// all these functions are forwarded to the corresponding methods of the
371
// currently active event loop -- and do nothing if there is none
372
virtual bool Pending();
373
virtual bool Dispatch();
375
virtual int MainLoop();
376
virtual void ExitMainLoop();
378
bool Yield(bool onlyIfNeeded = false);
380
virtual void WakeUpIdle();
382
// this method is called by the active event loop when there are no events
385
// by default it generates the idle events and if you override it in your
386
// derived class you should call the base class version to ensure that idle
387
// events are still sent out
388
virtual bool ProcessIdle();
390
// this virtual function is overridden in GUI wxApp to always return true
391
// as GUI applications always have an event loop -- but console ones may
392
// have it or not, so it simply returns true if already have an event loop
393
// running but false otherwise
394
virtual bool UsesEventLoop() const;
400
// this function is called when an assert failure occurs, the base class
401
// version does the normal processing (i.e. shows the usual assert failure
404
// the arguments are the location of the failed assert (func may be empty
405
// if the compiler doesn't support C99 __FUNCTION__), the text of the
406
// assert itself and the user-specified message
407
virtual void OnAssertFailure(const wxChar *file,
413
// old version of the function without func parameter, for compatibility
414
// only, override OnAssertFailure() in the new code
415
virtual void OnAssert(const wxChar *file,
420
// check that the wxBuildOptions object (constructed in the application
421
// itself, usually the one from wxIMPLEMENT_APP() macro) matches the build
422
// options of the library and abort if it doesn't
423
static bool CheckBuildOptions(const char *optionsSignature,
424
const char *componentName);
426
// implementation only from now on
427
// -------------------------------
429
// helpers for dynamic wxApp construction
430
static void SetInitializerFunction(wxAppInitializerFunction fn)
431
{ ms_appInitFn = fn; }
432
static wxAppInitializerFunction GetInitializerFunction()
433
{ return ms_appInitFn; }
435
// accessors for ms_appInstance field (external code might wish to modify
436
// it, this is why we provide a setter here as well, but you should really
437
// know what you're doing if you call it), wxTheApp is usually used instead
439
static wxAppConsole *GetInstance() { return ms_appInstance; }
440
static void SetInstance(wxAppConsole *app) { ms_appInstance = app; }
443
// command line arguments (public for backwards compatibility)
446
// this object is implicitly convertible to either "char**" (traditional
447
// type of argv parameter of main()) or to "wchar_t **" (for compatibility
448
// with Unicode build in previous wx versions and because the command line
451
wxCmdLineArgsArray argv;
457
// delete all objects in wxPendingDelete list
459
// called from ProcessPendingEvents()
460
void DeletePendingObjects();
462
// the function which creates the traits object when GetTraits() needs it
463
// for the first time
464
virtual wxAppTraits *CreateTraits();
466
// function used for dynamic wxApp creation
467
static wxAppInitializerFunction ms_appInitFn;
469
// the one and only global application object
470
static wxAppConsole *ms_appInstance;
472
// create main loop from AppTraits or return NULL if
473
// there is no main loop implementation
474
wxEventLoopBase *CreateMainLoop();
476
// application info (must be set from the user code)
477
wxString m_vendorName, // vendor name ("acme")
478
m_vendorDisplayName, // vendor display name (e.g. "ACME Inc")
479
m_appName, // app name ("myapp")
480
m_appDisplayName, // app display name ("My Application")
481
m_className; // class name
483
// the class defining the application behaviour, NULL initially and created
484
// by GetTraits() when first needed
485
wxAppTraits *m_traits;
487
// the main event loop of the application (may be NULL if the loop hasn't
488
// been started yet or has already terminated)
489
wxEventLoopBase *m_mainLoop;
492
// pending events management vars:
494
// the array of the handlers with pending events which needs to be processed
495
// inside ProcessPendingEvents()
496
wxEvtHandlerArray m_handlersWithPendingEvents;
498
// helper array used by ProcessPendingEvents() to store the event handlers
499
// which have pending events but of these events none can be processed right now
500
// (because of a call to wxEventLoop::YieldFor() which asked to selectively process
502
wxEvtHandlerArray m_handlersWithPendingDelayedEvents;
505
// this critical section protects both the lists above
506
wxCriticalSection m_handlersWithPendingEventsLocker;
509
// flag modified by Suspend/ResumeProcessingOfPendingEvents()
510
bool m_bDoPendingEventProcessing;
512
friend class WXDLLIMPEXP_FWD_BASE wxEvtHandler;
514
// the application object is a singleton anyhow, there is no sense in
516
wxDECLARE_NO_COPY_CLASS(wxAppConsoleBase);
519
#if defined(__UNIX__) && !defined(__WXMSW__)
520
#include "wx/unix/app.h"
522
// this has to be a class and not a typedef as we forward declare it
523
class wxAppConsole : public wxAppConsoleBase { };
526
// ----------------------------------------------------------------------------
527
// wxAppBase: the common part of wxApp implementations for all platforms
528
// ----------------------------------------------------------------------------
532
class WXDLLIMPEXP_CORE wxAppBase : public wxAppConsole
536
virtual ~wxAppBase();
538
// the virtual functions which may/must be overridden in the derived class
539
// -----------------------------------------------------------------------
541
// very first initialization function
543
// Override: very rarely
544
virtual bool Initialize(int& argc, wxChar **argv);
546
// a platform-dependent version of OnInit(): the code here is likely to
547
// depend on the toolkit. default version does nothing.
550
virtual bool OnInitGui();
552
// called to start program execution - the default version just enters
553
// the main GUI loop in which events are received and processed until
554
// the last window is not deleted (if GetExitOnFrameDelete) or
555
// ExitMainLoop() is called. In console mode programs, the execution
556
// of the program really starts here
558
// Override: rarely in GUI applications, always in console ones.
561
// a matching function for OnInit()
562
virtual int OnExit();
564
// very last clean up function
566
// Override: very rarely
567
virtual void CleanUp();
570
// the worker functions - usually not used directly by the user code
571
// -----------------------------------------------------------------
573
// safer alternatives to Yield(), using wxWindowDisabler
574
virtual bool SafeYield(wxWindow *win, bool onlyIfNeeded);
575
virtual bool SafeYieldFor(wxWindow *win, long eventsToProcess);
577
// this virtual function is called in the GUI mode when the application
578
// becomes idle and normally just sends wxIdleEvent to all interested
581
// it should return true if more idle events are needed, false if not
582
virtual bool ProcessIdle();
584
// override base class version: GUI apps always use an event loop
585
virtual bool UsesEventLoop() const { return true; }
588
// top level window functions
589
// --------------------------
591
// return true if our app has focus
592
virtual bool IsActive() const { return m_isActive; }
594
// set the "main" top level window
595
void SetTopWindow(wxWindow *win) { m_topWindow = win; }
597
// return the "main" top level window (if it hadn't been set previously
598
// with SetTopWindow(), will return just some top level window and, if
599
// there are none, will return NULL)
600
virtual wxWindow *GetTopWindow() const;
602
// control the exit behaviour: by default, the program will exit the
603
// main loop (and so, usually, terminate) when the last top-level
604
// program window is deleted. Beware that if you disable this behaviour
605
// (with SetExitOnFrameDelete(false)), you'll have to call
606
// ExitMainLoop() explicitly from somewhere.
607
void SetExitOnFrameDelete(bool flag)
608
{ m_exitOnFrameDelete = flag ? Yes : No; }
609
bool GetExitOnFrameDelete() const
610
{ return m_exitOnFrameDelete == Yes; }
613
// display mode, visual, printing mode, ...
614
// ------------------------------------------------------------------------
616
// Get display mode that is used use. This is only used in framebuffer
617
// wxWin ports such as wxDFB.
618
virtual wxVideoMode GetDisplayMode() const;
619
// Set display mode to use. This is only used in framebuffer wxWin
620
// ports such as wxDFB. This method should be called from
622
virtual bool SetDisplayMode(const wxVideoMode& WXUNUSED(info)) { return true; }
624
// set use of best visual flag (see below)
625
void SetUseBestVisual( bool flag, bool forceTrueColour = false )
626
{ m_useBestVisual = flag; m_forceTrueColour = forceTrueColour; }
627
bool GetUseBestVisual() const { return m_useBestVisual; }
629
// set/get printing mode: see wxPRINT_XXX constants.
631
// default behaviour is the normal one for Unix: always use PostScript
633
virtual void SetPrintMode(int WXUNUSED(mode)) { }
634
int GetPrintMode() const { return wxPRINT_POSTSCRIPT; }
636
// Return the layout direction for the current locale or wxLayout_Default
638
virtual wxLayoutDirection GetLayoutDirection() const;
640
// Change the theme used by the application, return true on success.
641
virtual bool SetNativeTheme(const wxString& WXUNUSED(theme)) { return false; }
644
// command line parsing (GUI-specific)
645
// ------------------------------------------------------------------------
647
#if wxUSE_CMDLINE_PARSER
648
virtual bool OnCmdLineParsed(wxCmdLineParser& parser);
649
virtual void OnInitCmdLine(wxCmdLineParser& parser);
652
// miscellaneous other stuff
653
// ------------------------------------------------------------------------
655
// called by toolkit-specific code to set the app status: active (we have
656
// focus) or not and also the last window which had focus before we were
658
virtual void SetActive(bool isActive, wxWindow *lastFocus);
660
#if WXWIN_COMPATIBILITY_2_6
661
// returns true if the program is successfully initialized
662
wxDEPRECATED_MSG("always returns true now, don't call")
664
#endif // WXWIN_COMPATIBILITY_2_6
667
// override base class method to use GUI traits
668
virtual wxAppTraits *CreateTraits();
671
// the main top level window (may be NULL)
672
wxWindow *m_topWindow;
674
// if Yes, exit the main loop when the last top level window is deleted, if
675
// No don't do it and if Later -- only do it once we reach our OnRun()
677
// the explanation for using this strange scheme is given in appcmn.cpp
683
} m_exitOnFrameDelete;
685
// true if the app wants to use the best visual on systems where
686
// more than one are available (Sun, SGI, XFree86 4.0 ?)
687
bool m_useBestVisual;
688
// force TrueColour just in case "best" isn't TrueColour
689
bool m_forceTrueColour;
691
// does any of our windows have focus?
694
wxDECLARE_NO_COPY_CLASS(wxAppBase);
697
#if WXWIN_COMPATIBILITY_2_6
698
inline bool wxAppBase::Initialized() { return true; }
699
#endif // WXWIN_COMPATIBILITY_2_6
701
// ----------------------------------------------------------------------------
702
// now include the declaration of the real class
703
// ----------------------------------------------------------------------------
705
#if defined(__WXMSW__)
706
#include "wx/msw/app.h"
707
#elif defined(__WXMOTIF__)
708
#include "wx/motif/app.h"
709
#elif defined(__WXDFB__)
710
#include "wx/dfb/app.h"
711
#elif defined(__WXGTK20__)
712
#include "wx/gtk/app.h"
713
#elif defined(__WXGTK__)
714
#include "wx/gtk1/app.h"
715
#elif defined(__WXX11__)
716
#include "wx/x11/app.h"
717
#elif defined(__WXMAC__)
718
#include "wx/osx/app.h"
719
#elif defined(__WXCOCOA__)
720
#include "wx/cocoa/app.h"
721
#elif defined(__WXPM__)
722
#include "wx/os2/app.h"
727
// wxApp is defined in core and we cannot define another one in wxBase,
728
// so use the preprocessor to allow using wxApp in console programs too
729
#define wxApp wxAppConsole
733
// ----------------------------------------------------------------------------
735
// ----------------------------------------------------------------------------
737
// for compatibility, we define this macro to access the global application
738
// object of type wxApp
740
// note that instead of using of wxTheApp in application code you should
741
// consider using wxDECLARE_APP() after which you may call wxGetApp() which will
742
// return the object of the correct type (i.e. MyApp and not wxApp)
744
// the cast is safe as in GUI build we only use wxApp, not wxAppConsole, and in
745
// console mode it does nothing at all
746
#define wxTheApp static_cast<wxApp*>(wxApp::GetInstance())
748
// ----------------------------------------------------------------------------
750
// ----------------------------------------------------------------------------
752
// event loop related functions only work in GUI programs
753
// ------------------------------------------------------
755
// Force an exit from main loop
756
WXDLLIMPEXP_BASE void wxExit();
758
// avoid redeclaring this function here if it had been already declared by
759
// wx/utils.h, this results in warnings from g++ with -Wredundant-decls
760
#ifndef wx_YIELD_DECLARED
761
#define wx_YIELD_DECLARED
763
// Yield to other apps/messages
764
WXDLLIMPEXP_CORE bool wxYield();
766
#endif // wx_YIELD_DECLARED
768
// Yield to other apps/messages
769
WXDLLIMPEXP_BASE void wxWakeUpIdle();
771
// ----------------------------------------------------------------------------
772
// macros for dynamic creation of the application object
773
// ----------------------------------------------------------------------------
775
// Having a global instance of this class allows wxApp to be aware of the app
776
// creator function. wxApp can then call this function to create a new app
777
// object. Convoluted, but necessary.
779
class WXDLLIMPEXP_BASE wxAppInitializer
782
wxAppInitializer(wxAppInitializerFunction fn)
783
{ wxApp::SetInitializerFunction(fn); }
786
// the code below defines a wxIMPLEMENT_WXWIN_MAIN macro which you can use if
787
// your compiler really, really wants main() to be in your main program (e.g.
788
// hello.cpp). Now wxIMPLEMENT_APP should add this code if required.
790
// For compilers that support it, prefer to use wmain() as this ensures any
791
// Unicode strings can be passed as command line parameters and not just those
792
// representable in the current locale.
793
#if wxUSE_UNICODE && defined(__VISUALC__)
794
#define wxIMPLEMENT_WXWIN_MAIN_CONSOLE \
795
int wmain(int argc, wchar_t **argv) \
797
wxDISABLE_DEBUG_SUPPORT(); \
799
return wxEntry(argc, argv); \
801
#else // Use standard main()
802
#define wxIMPLEMENT_WXWIN_MAIN_CONSOLE \
803
int main(int argc, char **argv) \
805
wxDISABLE_DEBUG_SUPPORT(); \
807
return wxEntry(argc, argv); \
811
// port-specific header could have defined it already in some special way
812
#ifndef wxIMPLEMENT_WXWIN_MAIN
813
#define wxIMPLEMENT_WXWIN_MAIN wxIMPLEMENT_WXWIN_MAIN_CONSOLE
814
#endif // defined(wxIMPLEMENT_WXWIN_MAIN)
816
#ifdef __WXUNIVERSAL__
817
#include "wx/univ/theme.h"
819
#ifdef wxUNIV_DEFAULT_THEME
820
#define wxIMPLEMENT_WX_THEME_SUPPORT \
821
WX_USE_THEME(wxUNIV_DEFAULT_THEME);
823
#define wxIMPLEMENT_WX_THEME_SUPPORT
826
#define wxIMPLEMENT_WX_THEME_SUPPORT
829
// Use this macro if you want to define your own main() or WinMain() function
830
// and call wxEntry() from there.
831
#define wxIMPLEMENT_APP_NO_MAIN(appname) \
832
appname& wxGetApp() { return *static_cast<appname*>(wxApp::GetInstance()); } \
833
wxAppConsole *wxCreateApp() \
835
wxAppConsole::CheckBuildOptions(WX_BUILD_OPTIONS_SIGNATURE, \
837
return new appname; \
840
wxTheAppInitializer((wxAppInitializerFunction) wxCreateApp)
842
// Same as wxIMPLEMENT_APP() normally but doesn't include themes support in
843
// wxUniversal builds
844
#define wxIMPLEMENT_APP_NO_THEMES(appname) \
845
wxIMPLEMENT_WXWIN_MAIN \
846
wxIMPLEMENT_APP_NO_MAIN(appname)
848
// Use this macro exactly once, the argument is the name of the wxApp-derived
849
// class which is the class of your application.
850
#define wxIMPLEMENT_APP(appname) \
851
wxIMPLEMENT_WX_THEME_SUPPORT \
852
wxIMPLEMENT_APP_NO_THEMES(appname)
854
// Same as IMPLEMENT_APP(), but for console applications.
855
#define wxIMPLEMENT_APP_CONSOLE(appname) \
856
wxIMPLEMENT_WXWIN_MAIN_CONSOLE \
857
wxIMPLEMENT_APP_NO_MAIN(appname)
859
// this macro can be used multiple times and just allows you to use wxGetApp()
861
#define wxDECLARE_APP(appname) \
862
extern appname& wxGetApp()
865
// declare the stuff defined by wxIMPLEMENT_APP() macro, it's not really needed
866
// anywhere else but at the very least it suppresses icc warnings about
867
// defining extern symbols without prior declaration, and it shouldn't do any
869
extern wxAppConsole *wxCreateApp();
870
extern wxAppInitializer wxTheAppInitializer;
872
// ----------------------------------------------------------------------------
873
// Compatibility macro aliases
874
// ----------------------------------------------------------------------------
876
// deprecated variants _not_ requiring a semicolon after them
877
// (note that also some wx-prefixed macro do _not_ require a semicolon because
878
// it's not always possible to force the compire to require it)
880
#define IMPLEMENT_WXWIN_MAIN_CONSOLE wxIMPLEMENT_WXWIN_MAIN_CONSOLE
881
#define IMPLEMENT_WXWIN_MAIN wxIMPLEMENT_WXWIN_MAIN
882
#define IMPLEMENT_WX_THEME_SUPPORT wxIMPLEMENT_WX_THEME_SUPPORT
883
#define IMPLEMENT_APP_NO_MAIN(app) wxIMPLEMENT_APP_NO_MAIN(app);
884
#define IMPLEMENT_APP_NO_THEMES(app) wxIMPLEMENT_APP_NO_THEMES(app);
885
#define IMPLEMENT_APP(app) wxIMPLEMENT_APP(app);
886
#define IMPLEMENT_APP_CONSOLE(app) wxIMPLEMENT_APP_CONSOLE(app);
887
#define DECLARE_APP(app) wxDECLARE_APP(app);
889
#endif // _WX_APP_H_BASE_
added
removed
Externals/wxWidgets3/include/wx/app.h
