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