]> git.saurik.com Git - wxWidgets.git/blame - include/wx/app.h
Return old, not new, selection from wxMSW wxNotebook::ChangeSelection().
[wxWidgets.git] / include / wx / app.h
CommitLineData
c801d85f 1/////////////////////////////////////////////////////////////////////////////
090a6d7a 2// Name: wx/app.h
094637f6
VZ
3// Purpose: wxAppBase class and macros used for declaration of wxApp
4// derived class in the user code
c801d85f
KB
5// Author: Julian Smart
6// Modified by:
7// Created: 01/02/97
8// RCS-ID: $Id$
371a5b4e 9// Copyright: (c) Julian Smart
65571936 10// Licence: wxWindows licence
c801d85f
KB
11/////////////////////////////////////////////////////////////////////////////
12
34138703
JS
13#ifndef _WX_APP_H_BASE_
14#define _WX_APP_H_BASE_
c801d85f 15
23280650
VZ
16// ----------------------------------------------------------------------------
17// headers we have to include here
18// ----------------------------------------------------------------------------
19
20#include "wx/event.h" // for the base class
090a6d7a 21#include "wx/build.h"
541ea80f 22#include "wx/cmdargs.h" // for wxCmdLineArgsArray used by wxApp::argv
0fcbaf23 23#include "wx/init.h" // we must declare wxEntry()
5ff14574 24#include "wx/intl.h" // for wxLayoutDirection
7d9550df 25#include "wx/log.h" // for wxDISABLE_DEBUG_LOGGING_IN_RELEASE_BUILD()
090a6d7a 26
b5dbe15d
VS
27class WXDLLIMPEXP_FWD_BASE wxAppConsole;
28class WXDLLIMPEXP_FWD_BASE wxAppTraits;
29class WXDLLIMPEXP_FWD_BASE wxCmdLineParser;
30class WXDLLIMPEXP_FWD_BASE wxEventLoopBase;
b5dbe15d 31class WXDLLIMPEXP_FWD_BASE wxMessageOutput;
a69be60b 32
4d90072c 33#if wxUSE_GUI
4ec80a59 34 struct WXDLLIMPEXP_FWD_CORE wxVideoMode;
d48b06bd 35 class WXDLLIMPEXP_FWD_CORE wxWindow;
fb761cd5 36#endif
1bf77ee5 37
7d9550df
VZ
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
53c9228e
VZ
43// ----------------------------------------------------------------------------
44// typedefs
45// ----------------------------------------------------------------------------
46
47// the type of the function used to create a wxApp object on program start up
e8e1149b 48typedef wxAppConsole* (*wxAppInitializerFunction)();
53c9228e 49
094637f6
VZ
50// ----------------------------------------------------------------------------
51// constants
52// ----------------------------------------------------------------------------
53
e2478fde
VZ
54enum
55{
56 wxPRINT_WINDOWS = 1,
57 wxPRINT_POSTSCRIPT = 2
58};
094637f6 59
3185abc2
VZ
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
094637f6 69// ----------------------------------------------------------------------------
e0954e72 70// wxAppConsoleBase: wxApp for non-GUI applications
094637f6
VZ
71// ----------------------------------------------------------------------------
72
e0954e72 73class WXDLLIMPEXP_BASE wxAppConsoleBase : public wxEvtHandler
094637f6
VZ
74{
75public:
e2478fde 76 // ctor and dtor
e0954e72
VZ
77 wxAppConsoleBase();
78 virtual ~wxAppConsoleBase();
e2478fde 79
1e6feb95 80
094637f6
VZ
81 // the virtual functions which may/must be overridden in the derived class
82 // -----------------------------------------------------------------------
bf188f1a 83
94826170
VZ
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!
05e2b077 89 virtual bool Initialize(int& argc, wxChar **argv);
94826170 90
7fbc89bb
DE
91 // This gives wxCocoa a chance to call OnInit() with a memory pool in place
92 virtual bool CallOnInit() { return OnInit(); }
93
e2478fde
VZ
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.
bf188f1a 98 virtual bool OnInit();
094637f6 99
e2478fde
VZ
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.
b46b1d59 102 virtual int OnRun();
094637f6 103
ec38d07d
FM
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
e2478fde
VZ
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.
7beba2fc 113 virtual int OnExit();
094637f6 114
ec38d07d
FM
115 // This is called by wxEventLoopBase::OnExit() for each event loop which
116 // is exited.
117 virtual void OnEventLoopExit(wxEventLoopBase* WXUNUSED(loop)) {}
118
94826170
VZ
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
e2478fde
VZ
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.
094637f6
VZ
130 virtual void OnFatalException() { }
131
e2478fde
VZ
132 // Called from wxExit() function, should terminate the application a.s.a.p.
133 virtual void Exit();
b137e493 134
094637f6
VZ
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
f432e677 144 wxString GetAppName() const;
094637f6
VZ
145 void SetAppName(const wxString& name) { m_appName = name; }
146
9cf3d218
VZ
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 //
f432e677
VZ
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;
328fafa1 155
9cf3d218
VZ
156 void SetAppDisplayName(const wxString& name) { m_appDisplayName = name; }
157
094637f6
VZ
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
180b5b48
VZ
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
e90c1d2a 179
bf188f1a
VZ
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
b913d3ed
VZ
192 // to the given parser (don't forget to call the base class version if you
193 // override it!)
bf188f1a
VZ
194 virtual void OnInitCmdLine(wxCmdLineParser& parser);
195
4629016d
WS
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
b913d3ed 198 // version if you override it!)
bf188f1a
VZ
199 virtual bool OnCmdLineParsed(wxCmdLineParser& parser);
200
4629016d
WS
201 // called if "--help" option was specified, return true to continue
202 // and false to exit
bf188f1a
VZ
203 virtual bool OnCmdLineHelp(wxCmdLineParser& parser);
204
205 // called if incorrect command line options were given, return
4629016d 206 // false to abort and true to continue
bf188f1a
VZ
207 virtual bool OnCmdLineError(wxCmdLineParser& parser);
208#endif // wxUSE_CMDLINE_PARSER
209
e2478fde 210
094637f6
VZ
211 // miscellaneous customization functions
212 // -------------------------------------
213
e2478fde
VZ
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
9d55bfef 218 // allows us to abstract the differences behind the common facade
e2478fde
VZ
219 wxAppTraits *GetTraits();
220
96b2cbe8
VZ
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();
75acb532 228
ec38d07d
FM
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
e2478fde
VZ
238 // event processing functions
239 // --------------------------
094637f6 240
9154d8cf
VZ
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
dde19c21
FM
250 // return true if we're running event loop, i.e. if the events can
251 // (already) be dispatched
252 static bool IsMainLoopRunning();
253
883117d1 254#if wxUSE_EXCEPTIONS
3c778901
VZ
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
883117d1
VZ
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;
2dc62891
VZ
273
274 // Called when an unhandled C++ exception occurs inside OnRun(): note that
1663c655
VZ
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();
dde19c21
FM
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
883117d1
VZ
286#endif // wxUSE_EXCEPTIONS
287
b46b1d59 288
8e40ed85
FM
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.
e2478fde 302 virtual void ProcessPendingEvents();
8e40ed85
FM
303
304 // check if there are pending events on global pending event list
b46b1d59
VZ
305 bool HasPendingEvents() const;
306
8e40ed85
FM
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
cae9e7b1
FM
325 // deletes the current pending events
326 void DeletePendingEvents();
327
8e40ed85 328
3185abc2
VZ
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 // ---------------------------
8e40ed85 350
a758f601
VZ
351 // all these functions are forwarded to the corresponding methods of the
352 // currently active event loop -- and do nothing if there is none
dde19c21
FM
353 virtual bool Pending();
354 virtual bool Dispatch();
b46b1d59 355
b46b1d59 356 virtual int MainLoop();
b46b1d59
VZ
357 virtual void ExitMainLoop();
358
dde19c21 359 bool Yield(bool onlyIfNeeded = false);
e2478fde 360
dde19c21 361 virtual void WakeUpIdle();
a758f601
VZ
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
b46b1d59
VZ
369 virtual bool ProcessIdle();
370
3185abc2
VZ
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
d48b06bd 377
a5f1fd3e
VZ
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)
aad65f13 384 //
3ec4a23f
VZ
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
aad65f13 387 // assert itself and the user-specified message
3ec4a23f
VZ
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
aad65f13
VZ
396 virtual void OnAssert(const wxChar *file,
397 int line,
398 const wxChar *cond,
399 const wxChar *msg);
8030d606 400
090a6d7a
VZ
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
2a7c7605
VS
404 static bool CheckBuildOptions(const char *optionsSignature,
405 const char *componentName);
73deed44 406
094637f6
VZ
407 // implementation only from now on
408 // -------------------------------
409
410 // helpers for dynamic wxApp construction
411 static void SetInitializerFunction(wxAppInitializerFunction fn)
e2478fde 412 { ms_appInitFn = fn; }
094637f6 413 static wxAppInitializerFunction GetInitializerFunction()
e2478fde 414 { return ms_appInitFn; }
094637f6 415
a80e5f9e
VZ
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
72cdf4c9 423
e2478fde 424 // command line arguments (public for backwards compatibility)
541ea80f
VZ
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
094637f6 436
094637f6 437protected:
3185abc2
VZ
438 // delete all objects in wxPendingDelete list
439 //
440 // called from ProcessPendingEvents()
441 void DeletePendingObjects();
442
e2478fde
VZ
443 // the function which creates the traits object when GetTraits() needs it
444 // for the first time
445 virtual wxAppTraits *CreateTraits();
446
094637f6 447 // function used for dynamic wxApp creation
e2478fde 448 static wxAppInitializerFunction ms_appInitFn;
094637f6 449
a80e5f9e
VZ
450 // the one and only global application object
451 static wxAppConsole *ms_appInstance;
452
b46b1d59
VZ
453 // create main loop from AppTraits or return NULL if
454 // there is no main loop implementation
2ddff00c 455 wxEventLoopBase *CreateMainLoop();
7cafd224 456
094637f6 457 // application info (must be set from the user code)
180b5b48
VZ
458 wxString m_vendorName, // vendor name ("acme")
459 m_vendorDisplayName, // vendor display name (e.g. "ACME Inc")
9cf3d218
VZ
460 m_appName, // app name ("myapp")
461 m_appDisplayName, // app display name ("My Application")
462 m_className; // class name
a69be60b 463
e2478fde
VZ
464 // the class defining the application behaviour, NULL initially and created
465 // by GetTraits() when first needed
466 wxAppTraits *m_traits;
467
b46b1d59
VZ
468 // the main event loop of the application (may be NULL if the loop hasn't
469 // been started yet or has already terminated)
2ddff00c 470 wxEventLoopBase *m_mainLoop;
e2478fde 471
cae9e7b1
FM
472
473 // pending events management vars:
474
8e40ed85
FM
475 // the array of the handlers with pending events which needs to be processed
476 // inside ProcessPendingEvents()
477 wxEvtHandlerArray m_handlersWithPendingEvents;
478
cae9e7b1
FM
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)
8e40ed85
FM
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
cae9e7b1
FM
490 // flag modified by Suspend/ResumeProcessingOfPendingEvents()
491 bool m_bDoPendingEventProcessing;
492
e799e8d7 493 friend class WXDLLIMPEXP_FWD_BASE wxEvtHandler;
d48b06bd 494
e2478fde
VZ
495 // the application object is a singleton anyhow, there is no sense in
496 // copying it
c0c133e1 497 wxDECLARE_NO_COPY_CLASS(wxAppConsoleBase);
e2478fde
VZ
498};
499
e0954e72
VZ
500#if defined(__UNIX__)
501 #include "wx/unix/app.h"
502#else
4c2a8d89
VZ
503 // this has to be a class and not a typedef as we forward declare it
504 class wxAppConsole : public wxAppConsoleBase { };
e0954e72
VZ
505#endif
506
e2478fde
VZ
507// ----------------------------------------------------------------------------
508// wxAppBase: the common part of wxApp implementations for all platforms
509// ----------------------------------------------------------------------------
510
1e6feb95 511#if wxUSE_GUI
e2478fde 512
bddd7a8d 513class WXDLLIMPEXP_CORE wxAppBase : public wxAppConsole
e2478fde
VZ
514{
515public:
516 wxAppBase();
517 virtual ~wxAppBase();
518
519 // the virtual functions which may/must be overridden in the derived class
520 // -----------------------------------------------------------------------
521
94826170
VZ
522 // very first initialization function
523 //
524 // Override: very rarely
05e2b077 525 virtual bool Initialize(int& argc, wxChar **argv);
94826170 526
e2478fde
VZ
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
b913d3ed
VZ
542 // a matching function for OnInit()
543 virtual int OnExit();
544
94826170
VZ
545 // very last clean up function
546 //
547 // Override: very rarely
548 virtual void CleanUp();
e2478fde
VZ
549
550
551 // the worker functions - usually not used directly by the user code
552 // -----------------------------------------------------------------
553
d48b06bd
FM
554 // safer alternatives to Yield(), using wxWindowDisabler
555 virtual bool SafeYield(wxWindow *win, bool onlyIfNeeded);
556 virtual bool SafeYieldFor(wxWindow *win, long eventsToProcess);
e2478fde
VZ
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 //
4629016d 562 // it should return true if more idle events are needed, false if not
1bf77ee5 563 virtual bool ProcessIdle();
e39af974 564
e39af974 565 // Send idle event to window and all subwindows
4629016d 566 // Returns true if more idle time is requested.
5109ae5d 567 virtual bool SendIdleEvents(wxWindow* win, wxIdleEvent& event);
e2478fde 568
3185abc2
VZ
569 // override base class version: GUI apps always use an event loop
570 virtual bool UsesEventLoop() const { return true; }
571
2dc62891 572
e2478fde
VZ
573 // top level window functions
574 // --------------------------
575
4629016d 576 // return true if our app has focus
e2478fde
VZ
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)
5ff14574 585 virtual wxWindow *GetTopWindow() const;
e2478fde
VZ
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
4629016d 590 // (with SetExitOnFrameDelete(false)), you'll have to call
e2478fde
VZ
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
b3c86150 602 // wxWin ports (such as wxMGL or wxDFB).
5ff14574 603 virtual wxVideoMode GetDisplayMode() const;
e2478fde 604 // Set display mode to use. This is only used in framebuffer wxWin
b3c86150 605 // ports (such as wxMGL or wxDFB). This method should be called from
e2478fde 606 // wxApp::OnInitGui
4629016d 607 virtual bool SetDisplayMode(const wxVideoMode& WXUNUSED(info)) { return true; }
e2478fde
VZ
608
609 // set use of best visual flag (see below)
9cf3d218 610 void SetUseBestVisual( bool flag, bool forceTrueColour = false )
515a31bf 611 { m_useBestVisual = flag; m_forceTrueColour = forceTrueColour; }
e2478fde
VZ
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
475a93b7
VZ
621 // Return the layout direction for the current locale or wxLayout_Default
622 // if it's unknown
623 virtual wxLayoutDirection GetLayoutDirection() const;
624
c50c6fb2
VZ
625 // Change the theme used by the application, return true on success.
626 virtual bool SetNativeTheme(const wxString& WXUNUSED(theme)) { return false; }
627
e2478fde 628
b913d3ed
VZ
629 // command line parsing (GUI-specific)
630 // ------------------------------------------------------------------------
631
8030d606 632#if wxUSE_CMDLINE_PARSER
b913d3ed
VZ
633 virtual bool OnCmdLineParsed(wxCmdLineParser& parser);
634 virtual void OnInitCmdLine(wxCmdLineParser& parser);
8030d606 635#endif
b913d3ed 636
e2478fde
VZ
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
40ff126a 645#if WXWIN_COMPATIBILITY_2_6
dd435a79
VZ
646 // OBSOLETE: don't use, always returns true
647 //
648 // returns true if the program is successfully initialized
40ff126a
WS
649 wxDEPRECATED( bool Initialized() );
650#endif // WXWIN_COMPATIBILITY_2_6
dd435a79 651
e2478fde
VZ
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)
1e6feb95
VZ
658 wxWindow *m_topWindow;
659
1cbee0b4
VZ
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;
1e6feb95 670
90e572f1 671 // true if the app wants to use the best visual on systems where
8480b297
RR
672 // more than one are available (Sun, SGI, XFree86 4.0 ?)
673 bool m_useBestVisual;
515a31bf
RR
674 // force TrueColour just in case "best" isn't TrueColour
675 bool m_forceTrueColour;
094637f6 676
90e572f1 677 // does any of our windows have focus?
1e6feb95 678 bool m_isActive;
e2478fde 679
c0c133e1 680 wxDECLARE_NO_COPY_CLASS(wxAppBase);
094637f6
VZ
681};
682
40ff126a
WS
683#if WXWIN_COMPATIBILITY_2_6
684 inline bool wxAppBase::Initialized() { return true; }
685#endif // WXWIN_COMPATIBILITY_2_6
686
094637f6
VZ
687// ----------------------------------------------------------------------------
688// now include the declaration of the real class
689// ----------------------------------------------------------------------------
690
e0954e72
VZ
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__)
ef0e9220 708 #include "wx/osx/app.h"
e0954e72
VZ
709#elif defined(__WXCOCOA__)
710 #include "wx/cocoa/app.h"
711#elif defined(__WXPM__)
712 #include "wx/os2/app.h"
713#endif
714
e90c1d2a 715#else // !GUI
e0954e72
VZ
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
e90c1d2a 721#endif // GUI/!GUI
c801d85f 722
094637f6 723// ----------------------------------------------------------------------------
ee31c392
VZ
724// the global data
725// ----------------------------------------------------------------------------
726
7cafd224
VZ
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
5c33522f 736#define wxTheApp static_cast<wxApp*>(wxApp::GetInstance())
ee31c392
VZ
737
738// ----------------------------------------------------------------------------
739// global functions
740// ----------------------------------------------------------------------------
741
e90c1d2a
VZ
742// event loop related functions only work in GUI programs
743// ------------------------------------------------------
744
ee31c392 745// Force an exit from main loop
38281826 746WXDLLIMPEXP_BASE void wxExit();
ee31c392 747
d48b06bd 748// avoid redeclaring this function here if it had been already declared by
a131b460
VZ
749// wx/utils.h, this results in warnings from g++ with -Wredundant-decls
750#ifndef wx_YIELD_DECLARED
751#define wx_YIELD_DECLARED
752
ee31c392 753// Yield to other apps/messages
38281826 754WXDLLIMPEXP_CORE bool wxYield();
e90c1d2a 755
a131b460
VZ
756#endif // wx_YIELD_DECLARED
757
bf9e3e73 758// Yield to other apps/messages
38281826 759WXDLLIMPEXP_BASE void wxWakeUpIdle();
bf9e3e73 760
ee31c392 761// ----------------------------------------------------------------------------
094637f6
VZ
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.
c801d85f 768
bddd7a8d 769class WXDLLIMPEXP_BASE wxAppInitializer
c801d85f
KB
770{
771public:
094637f6
VZ
772 wxAppInitializer(wxAppInitializerFunction fn)
773 { wxApp::SetInitializerFunction(fn); }
c801d85f
KB
774};
775
956495ca
VZ
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.
26a87b69 779
7d9550df
VZ
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 }
80b2db4e 787
90e572f1 788// port-specific header could have defined it already in some special way
956495ca 789#ifndef IMPLEMENT_WXWIN_MAIN
7738c2e5 790 #define IMPLEMENT_WXWIN_MAIN IMPLEMENT_WXWIN_MAIN_CONSOLE
956495ca 791#endif // defined(IMPLEMENT_WXWIN_MAIN)
26a87b69 792
24e78d27
VZ
793#ifdef __WXUNIVERSAL__
794 #include "wx/univ/theme.h"
795
ee92941a
VS
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
24e78d27
VZ
802#else
803 #define IMPLEMENT_WX_THEME_SUPPORT
804#endif
c801d85f 805
c661ecca
RR
806// Use this macro if you want to define your own main() or WinMain() function
807// and call wxEntry() from there.
94826170 808#define IMPLEMENT_APP_NO_MAIN(appname) \
e8e1149b 809 wxAppConsole *wxCreateApp() \
94826170 810 { \
2a7c7605 811 wxAppConsole::CheckBuildOptions(WX_BUILD_OPTIONS_SIGNATURE, \
82c75aea 812 "your program"); \
94826170
VZ
813 return new appname; \
814 } \
815 wxAppInitializer \
816 wxTheAppInitializer((wxAppInitializerFunction) wxCreateApp); \
17a1ebd1 817 DECLARE_APP(appname) \
5c33522f 818 appname& wxGetApp() { return *static_cast<appname*>(wxApp::GetInstance()); }
c661ecca 819
24e78d27
VZ
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
80b2db4e
VS
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
24e78d27
VZ
837// this macro can be used multiple times and just allows you to use wxGetApp()
838// function
094637f6 839#define DECLARE_APP(appname) extern appname& wxGetApp();
c801d85f 840
17a1ebd1
VZ
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
94826170 849#endif // _WX_APP_H_BASE_