]>
Commit | Line | Data |
---|---|---|
c801d85f KB |
1 | ///////////////////////////////////////////////////////////////////////////// |
2 | // Name: 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$ | |
9 | // Copyright: (c) Julian Smart and Markus Holzem | |
094637f6 | 10 | // Licence: wxWindows licence |
c801d85f KB |
11 | ///////////////////////////////////////////////////////////////////////////// |
12 | ||
34138703 JS |
13 | #ifndef _WX_APP_H_BASE_ |
14 | #define _WX_APP_H_BASE_ | |
c801d85f | 15 | |
094637f6 VZ |
16 | #ifdef __GNUG__ |
17 | #pragma interface "appbase.h" | |
10b959e3 | 18 | #endif |
c801d85f | 19 | |
094637f6 VZ |
20 | // ---------------------------------------------------------------------------- |
21 | // typedefs | |
22 | // ---------------------------------------------------------------------------- | |
23 | ||
04ef50df | 24 | #if (defined(__WXMSW__) && !defined(__WXMICROWIN__)) || defined (__WXPM__) |
094637f6 VZ |
25 | class WXDLLEXPORT wxApp; |
26 | typedef wxApp* (*wxAppInitializerFunction)(); | |
27 | #else | |
28 | // returning wxApp* won't work with gcc | |
29 | #include "wx/object.h" | |
c801d85f | 30 | |
094637f6 | 31 | typedef wxObject* (*wxAppInitializerFunction)(); |
10b959e3 | 32 | #endif |
c801d85f | 33 | |
bf188f1a VZ |
34 | class WXDLLEXPORT wxCmdLineParser; |
35 | ||
23280650 VZ |
36 | // ---------------------------------------------------------------------------- |
37 | // headers we have to include here | |
38 | // ---------------------------------------------------------------------------- | |
39 | ||
40 | #include "wx/event.h" // for the base class | |
41 | ||
e90c1d2a | 42 | #if wxUSE_GUI |
bf188f1a | 43 | #include "wx/window.h" // for wxTopLevelWindows |
e90c1d2a | 44 | #endif // wxUSE_GUI |
23280650 VZ |
45 | |
46 | #if wxUSE_LOG | |
47 | #include "wx/log.h" | |
48 | #endif | |
49 | ||
094637f6 VZ |
50 | // ---------------------------------------------------------------------------- |
51 | // constants | |
52 | // ---------------------------------------------------------------------------- | |
53 | ||
54 | static const int wxPRINT_WINDOWS = 1; | |
55 | static const int wxPRINT_POSTSCRIPT = 2; | |
56 | ||
57 | // ---------------------------------------------------------------------------- | |
58 | // the common part of wxApp implementations for all platforms | |
59 | // ---------------------------------------------------------------------------- | |
60 | ||
61 | class WXDLLEXPORT wxAppBase : public wxEvtHandler | |
62 | { | |
63 | public: | |
1e6feb95 VZ |
64 | wxAppBase(); |
65 | ||
094637f6 VZ |
66 | // the virtual functions which may/must be overridden in the derived class |
67 | // ----------------------------------------------------------------------- | |
bf188f1a | 68 | |
094637f6 VZ |
69 | // called during the program initialization, returning FALSE from here |
70 | // prevents the program from continuing - it's a good place to create | |
71 | // the top level program window and return TRUE. | |
72 | // | |
e90c1d2a | 73 | // Override: always in GUI application, rarely in console ones. |
bf188f1a | 74 | virtual bool OnInit(); |
094637f6 | 75 | |
e90c1d2a | 76 | #if wxUSE_GUI |
094637f6 VZ |
77 | // a platform-dependent version of OnInit(): the code here is likely to |
78 | // depend on the toolkit. default version does nothing. | |
79 | // | |
80 | // Override: rarely. | |
1e6feb95 | 81 | virtual bool OnInitGui(); |
e90c1d2a | 82 | #endif // wxUSE_GUI |
094637f6 VZ |
83 | |
84 | // called to start program execution - the default version just enters | |
85 | // the main GUI loop in which events are received and processed until | |
86 | // the last window is not deleted (if GetExitOnFrameDelete) or | |
e90c1d2a VZ |
87 | // ExitMainLoop() is called. In console mode programs, the execution |
88 | // of the program really starts here | |
094637f6 | 89 | // |
e90c1d2a VZ |
90 | // Override: rarely in GUI applications, always in console ones. |
91 | #if wxUSE_GUI | |
094637f6 | 92 | virtual int OnRun() { return MainLoop(); }; |
e90c1d2a VZ |
93 | #else // !GUI |
94 | virtual int OnRun() = 0; | |
95 | #endif // wxUSE_GUI | |
094637f6 VZ |
96 | |
97 | // called after the main loop termination. This is a good place for | |
98 | // cleaning up (it may be too late in dtor) and is also useful if you | |
99 | // want to return some non-default exit code - this is just the return | |
100 | // value of this method. | |
101 | // | |
102 | // Override: often. | |
7beba2fc | 103 | virtual int OnExit(); |
094637f6 VZ |
104 | |
105 | // called when a fatal exception occurs, this function should take care | |
106 | // not to do anything which might provoke a nested exception! It may be | |
107 | // overridden if you wish to react somehow in non-default way (core | |
108 | // dump under Unix, application crash under Windows) to fatal program | |
109 | // errors, however extreme care should be taken if you don't want this | |
110 | // function to crash. | |
111 | // | |
112 | // Override: rarely. | |
113 | virtual void OnFatalException() { } | |
114 | ||
115 | // the worker functions - usually not used directly by the user code | |
116 | // ----------------------------------------------------------------- | |
117 | ||
e90c1d2a | 118 | #if wxUSE_GUI |
094637f6 VZ |
119 | // execute the main GUI loop, the function returns when the loop ends |
120 | virtual int MainLoop() = 0; | |
121 | ||
122 | // exit the main GUI loop during the next iteration (i.e. it does not | |
123 | // stop the program immediately!) | |
124 | virtual void ExitMainLoop() = 0; | |
125 | ||
126 | // returns TRUE if the program is initialized | |
127 | virtual bool Initialized() = 0; | |
128 | ||
129 | // returns TRUE if there are unprocessed events in the event queue | |
130 | virtual bool Pending() = 0; | |
131 | ||
132 | // process the first event in the event queue (blocks until an event | |
133 | // apperas if there are none currently) | |
134 | virtual void Dispatch() = 0; | |
e90c1d2a | 135 | #endif // wxUSE_GUI |
094637f6 VZ |
136 | |
137 | // application info: name, description, vendor | |
138 | // ------------------------------------------- | |
139 | ||
140 | // NB: all these should be set by the application itself, there are no | |
141 | // reasonable default except for the application name which is taken to | |
142 | // be argv[0] | |
143 | ||
144 | // set/get the application name | |
145 | wxString GetAppName() const | |
146 | { | |
147 | if ( !m_appName ) | |
148 | return m_className; | |
149 | else | |
150 | return m_appName; | |
151 | } | |
152 | void SetAppName(const wxString& name) { m_appName = name; } | |
153 | ||
154 | // set/get the app class name | |
155 | wxString GetClassName() const { return m_className; } | |
156 | void SetClassName(const wxString& name) { m_className = name; } | |
157 | ||
158 | // set/get the vendor name | |
159 | const wxString& GetVendorName() const { return m_vendorName; } | |
160 | void SetVendorName(const wxString& name) { m_vendorName = name; } | |
161 | ||
e90c1d2a | 162 | #if wxUSE_GUI |
094637f6 VZ |
163 | // top level window functions |
164 | // -------------------------- | |
165 | ||
1e6feb95 VZ |
166 | // return TRUE if our app has focus |
167 | virtual bool IsActive() const { return m_isActive; } | |
168 | ||
094637f6 VZ |
169 | // set the "main" top level window |
170 | void SetTopWindow(wxWindow *win) { m_topWindow = win; } | |
171 | ||
172 | // return the "main" top level window (if it hadn't been set previously | |
173 | // with SetTopWindow(), will return just some top level window and, if | |
174 | // there are none, will return NULL) | |
83a5b533 | 175 | virtual wxWindow *GetTopWindow() const |
094637f6 VZ |
176 | { |
177 | if (m_topWindow) | |
178 | return m_topWindow; | |
179 | else if (wxTopLevelWindows.GetCount() > 0) | |
180 | return wxTopLevelWindows.GetFirst()->GetData(); | |
181 | else | |
182 | return (wxWindow *)NULL; | |
183 | } | |
184 | ||
185 | // control the exit behaviour: by default, the program will exit the | |
186 | // main loop (and so, usually, terminate) when the last top-level | |
187 | // program window is deleted. Beware that if you disabel this (with | |
188 | // SetExitOnFrameDelete(FALSE)), you'll have to call ExitMainLoop() | |
189 | // explicitly from somewhere. | |
190 | void SetExitOnFrameDelete(bool flag) { m_exitOnFrameDelete = flag; } | |
191 | bool GetExitOnFrameDelete() const { return m_exitOnFrameDelete; } | |
192 | ||
e90c1d2a VZ |
193 | #endif // wxUSE_GUI |
194 | ||
bf188f1a VZ |
195 | // cmd line parsing stuff |
196 | // ---------------------- | |
197 | ||
198 | // all of these methods may be overridden in the derived class to | |
199 | // customize the command line parsing (by default only a few standard | |
200 | // options are handled) | |
201 | // | |
202 | // you also need to call wxApp::OnInit() from YourApp::OnInit() for all | |
203 | // this to work | |
204 | ||
205 | #if wxUSE_CMDLINE_PARSER | |
206 | // this one is called from OnInit() to add all supported options | |
207 | // to the given parser | |
208 | virtual void OnInitCmdLine(wxCmdLineParser& parser); | |
209 | ||
210 | // called after successfully parsing the command line, return TRUE | |
211 | // to continue and FALSE to exit | |
212 | virtual bool OnCmdLineParsed(wxCmdLineParser& parser); | |
213 | ||
214 | // called if "--help" option was specified, return TRUE to continue | |
215 | // and FALSE to exit | |
216 | virtual bool OnCmdLineHelp(wxCmdLineParser& parser); | |
217 | ||
218 | // called if incorrect command line options were given, return | |
219 | // FALSE to abort and TRUE to continue | |
220 | virtual bool OnCmdLineError(wxCmdLineParser& parser); | |
221 | #endif // wxUSE_CMDLINE_PARSER | |
222 | ||
094637f6 VZ |
223 | // miscellaneous customization functions |
224 | // ------------------------------------- | |
225 | ||
226 | #if wxUSE_LOG | |
227 | // override this function to create default log target of arbitrary | |
228 | // user-defined class (default implementation creates a wxLogGui | |
229 | // object) - this log object is used by default by all wxLogXXX() | |
230 | // functions. | |
e90c1d2a | 231 | virtual wxLog *CreateLogTarget() |
54800df8 | 232 | #if wxUSE_GUI && wxUSE_LOGGUI && !defined(__WXMICROWIN__) |
1e6feb95 VZ |
233 | { return new wxLogGui; } |
234 | #else // !GUI | |
235 | { return new wxLogStderr; } | |
236 | #endif // wxUSE_GUI | |
094637f6 VZ |
237 | #endif // wxUSE_LOG |
238 | ||
e90c1d2a | 239 | #if wxUSE_GUI |
094637f6 VZ |
240 | // get the standard icon used by wxWin dialogs - this allows the user |
241 | // to customize the standard dialogs. The 'which' parameter is one of | |
242 | // wxICON_XXX values | |
243 | virtual wxIcon GetStdIcon(int which) const = 0; | |
244 | ||
245 | // VZ: what does this do exactly? | |
246 | void SetWantDebugOutput( bool flag ) { m_wantDebugOutput = flag; } | |
247 | bool GetWantDebugOutput() const { return m_wantDebugOutput; } | |
248 | ||
8480b297 RR |
249 | // set use of best visual flag (see below) |
250 | void SetUseBestVisual( bool flag ) { m_useBestVisual = flag; } | |
251 | bool GetUseBestVisual() const { return m_useBestVisual; } | |
75acb532 | 252 | |
094637f6 VZ |
253 | // set/get printing mode: see wxPRINT_XXX constants. |
254 | // | |
255 | // default behaviour is the normal one for Unix: always use PostScript | |
256 | // printing. | |
257 | virtual void SetPrintMode(int WXUNUSED(mode)) { } | |
258 | int GetPrintMode() const { return wxPRINT_POSTSCRIPT; } | |
1e6feb95 VZ |
259 | |
260 | // called by toolkit-specific code to set the app status: active (we have | |
261 | // focus) or not and also the last window which had focus before we were | |
262 | // deactivated | |
263 | virtual void SetActive(bool isActive, wxWindow *lastFocus); | |
e90c1d2a | 264 | #endif // wxUSE_GUI |
094637f6 | 265 | |
a5f1fd3e VZ |
266 | // debugging support |
267 | // ----------------- | |
268 | ||
269 | // this function is called when an assert failure occurs, the base class | |
270 | // version does the normal processing (i.e. shows the usual assert failure | |
271 | // dialog box) | |
272 | #ifdef __WXDEBUG__ | |
273 | virtual void OnAssert(const wxChar *file, int line, const wxChar *msg); | |
274 | #endif // __WXDEBUG__ | |
275 | ||
094637f6 VZ |
276 | // implementation only from now on |
277 | // ------------------------------- | |
278 | ||
279 | // helpers for dynamic wxApp construction | |
280 | static void SetInitializerFunction(wxAppInitializerFunction fn) | |
281 | { m_appInitFn = fn; } | |
282 | static wxAppInitializerFunction GetInitializerFunction() | |
283 | { return m_appInitFn; } | |
284 | ||
72cdf4c9 VZ |
285 | // process all events in the wxPendingEvents list |
286 | virtual void ProcessPendingEvents(); | |
287 | ||
094637f6 | 288 | // access to the command line arguments |
c1b03ce8 OK |
289 | int argc; |
290 | wxChar **argv; | |
094637f6 | 291 | |
094637f6 VZ |
292 | protected: |
293 | // function used for dynamic wxApp creation | |
294 | static wxAppInitializerFunction m_appInitFn; | |
295 | ||
296 | // application info (must be set from the user code) | |
297 | wxString m_vendorName, // vendor name (ACME Inc) | |
298 | m_appName, // app name | |
299 | m_className; // class name | |
300 | ||
094637f6 VZ |
301 | // TRUE if the application wants to get debug output |
302 | bool m_wantDebugOutput; | |
75acb532 | 303 | |
1e6feb95 VZ |
304 | #if wxUSE_GUI |
305 | // the main top level window - may be NULL | |
306 | wxWindow *m_topWindow; | |
307 | ||
308 | // if TRUE, exit the main loop when the last top level window is deleted | |
309 | bool m_exitOnFrameDelete; | |
310 | ||
8480b297 RR |
311 | // TRUE if the apps whats to use the best visual on systems where |
312 | // more than one are available (Sun, SGI, XFree86 4.0 ?) | |
313 | bool m_useBestVisual; | |
094637f6 | 314 | |
1e6feb95 VZ |
315 | // does any of our windows has focus? |
316 | bool m_isActive; | |
e90c1d2a | 317 | #endif // wxUSE_GUI |
bf188f1a VZ |
318 | |
319 | #ifdef __WXMAC_X__ | |
320 | public: | |
321 | virtual ~wxAppBase() {} // Added min for Mac X | |
322 | #endif | |
094637f6 VZ |
323 | }; |
324 | ||
325 | // ---------------------------------------------------------------------------- | |
326 | // now include the declaration of the real class | |
327 | // ---------------------------------------------------------------------------- | |
328 | ||
e90c1d2a VZ |
329 | #if wxUSE_GUI |
330 | #if defined(__WXMSW__) | |
331 | #include "wx/msw/app.h" | |
332 | #elif defined(__WXMOTIF__) | |
333 | #include "wx/motif/app.h" | |
1e6feb95 VZ |
334 | #elif defined(__WXMGL__) |
335 | #include "wx/mgl/app.h" | |
e90c1d2a VZ |
336 | #elif defined(__WXQT__) |
337 | #include "wx/qt/app.h" | |
338 | #elif defined(__WXGTK__) | |
339 | #include "wx/gtk/app.h" | |
340 | #elif defined(__WXMAC__) | |
341 | #include "wx/mac/app.h" | |
342 | #elif defined(__WXPM__) | |
343 | #include "wx/os2/app.h" | |
344 | #elif defined(__WXSTUBS__) | |
345 | #include "wx/stubs/app.h" | |
346 | #endif | |
347 | #else // !GUI | |
b568d04f VZ |
348 | // can't use typedef because wxApp forward declared as a class |
349 | class WXDLLEXPORT wxApp : public wxAppBase | |
350 | { | |
351 | }; | |
e90c1d2a | 352 | #endif // GUI/!GUI |
c801d85f | 353 | |
094637f6 | 354 | // ---------------------------------------------------------------------------- |
ee31c392 VZ |
355 | // the global data |
356 | // ---------------------------------------------------------------------------- | |
357 | ||
358 | // the one and only application object - use of wxTheApp in application code | |
359 | // is discouraged, consider using DECLARE_APP() after which you may call | |
360 | // wxGetApp() which will return the object of the correct type (i.e. MyApp and | |
361 | // not wxApp) | |
362 | WXDLLEXPORT_DATA(extern wxApp*) wxTheApp; | |
363 | ||
364 | // ---------------------------------------------------------------------------- | |
365 | // global functions | |
366 | // ---------------------------------------------------------------------------- | |
367 | ||
e90c1d2a VZ |
368 | // event loop related functions only work in GUI programs |
369 | // ------------------------------------------------------ | |
370 | ||
ee31c392 | 371 | // Force an exit from main loop |
e90c1d2a | 372 | extern void WXDLLEXPORT wxExit(); |
ee31c392 VZ |
373 | |
374 | // Yield to other apps/messages | |
e90c1d2a VZ |
375 | extern bool WXDLLEXPORT wxYield(); |
376 | ||
bf9e3e73 RR |
377 | // Yield to other apps/messages |
378 | extern void WXDLLEXPORT wxWakeUpIdle(); | |
bf9e3e73 | 379 | |
8e193f38 VZ |
380 | // Post a message to the given eventhandler which will be processed during the |
381 | // next event loop iteration | |
6d56eb5c | 382 | inline void wxPostEvent(wxEvtHandler *dest, wxEvent& event) |
8e193f38 VZ |
383 | { |
384 | wxCHECK_RET( dest, wxT("need an object to post event to in wxPostEvent") ); | |
385 | ||
52a07708 | 386 | #if wxUSE_GUI |
8e193f38 | 387 | dest->AddPendingEvent(event); |
52a07708 VZ |
388 | #else |
389 | dest->ProcessEvent(event); | |
b568d04f | 390 | #endif // wxUSE_GUI |
52a07708 | 391 | } |
e90c1d2a VZ |
392 | |
393 | // console applications may avoid using DECLARE_APP and IMPLEMENT_APP macros | |
394 | // and call these functions instead at the program startup and termination | |
395 | // ------------------------------------------------------------------------- | |
396 | ||
b568d04f | 397 | #if !wxUSE_GUI |
e90c1d2a VZ |
398 | |
399 | // initialize the library (may be called as many times as needed, but each | |
400 | // call to wxInitialize() must be matched by wxUninitialize()) | |
401 | extern bool WXDLLEXPORT wxInitialize(); | |
402 | ||
403 | // clean up - the library can't be used any more after the last call to | |
404 | // wxUninitialize() | |
405 | extern void WXDLLEXPORT wxUninitialize(); | |
406 | ||
fae9f590 VZ |
407 | // create an object of this class on stack to initialize/cleanup thel ibrary |
408 | // automatically | |
409 | class WXDLLEXPORT wxInitializer | |
410 | { | |
411 | public: | |
412 | // initialize the library | |
413 | wxInitializer() { m_ok = wxInitialize(); } | |
414 | ||
415 | // has the initialization been successful? (explicit test) | |
416 | bool IsOk() const { return m_ok; } | |
417 | ||
418 | // has the initialization been successful? (implicit test) | |
419 | operator bool() const { return m_ok; } | |
420 | ||
421 | // dtor only does clean up if we initialized the library properly | |
422 | ~wxInitializer() { if ( m_ok ) wxUninitialize(); } | |
423 | ||
424 | private: | |
425 | bool m_ok; | |
426 | }; | |
427 | ||
b568d04f | 428 | #endif // !wxUSE_GUI |
ee31c392 VZ |
429 | |
430 | // ---------------------------------------------------------------------------- | |
094637f6 VZ |
431 | // macros for dynamic creation of the application object |
432 | // ---------------------------------------------------------------------------- | |
433 | ||
434 | // Having a global instance of this class allows wxApp to be aware of the app | |
435 | // creator function. wxApp can then call this function to create a new app | |
436 | // object. Convoluted, but necessary. | |
c801d85f KB |
437 | |
438 | class WXDLLEXPORT wxAppInitializer | |
439 | { | |
440 | public: | |
094637f6 VZ |
441 | wxAppInitializer(wxAppInitializerFunction fn) |
442 | { wxApp::SetInitializerFunction(fn); } | |
c801d85f KB |
443 | }; |
444 | ||
094637f6 VZ |
445 | // Here's a macro you can use if your compiler really, really wants main() to |
446 | // be in your main program (e.g. hello.cpp). Now IMPLEMENT_APP should add this | |
447 | // code if required. | |
26a87b69 | 448 | |
d5408e98 | 449 | #if !wxUSE_GUI || defined(__WXMOTIF__) || defined(__WXGTK__) || defined(__WXPM__) |
094637f6 VZ |
450 | #define IMPLEMENT_WXWIN_MAIN \ |
451 | extern int wxEntry( int argc, char *argv[] ); \ | |
452 | int main(int argc, char *argv[]) { return wxEntry(argc, argv); } | |
d5408e98 | 453 | #elif defined(__WXMAC__) && defined(__UNIX__) |
bf188f1a | 454 | // wxMac seems to have a specific wxEntry prototype |
d5408e98 GD |
455 | #define IMPLEMENT_WXWIN_MAIN \ |
456 | extern int wxEntry( int argc, char *argv[], bool enterLoop = 1 ); \ | |
457 | int main(int argc, char *argv[]) { return wxEntry(argc, argv); } | |
750b78ba | 458 | #elif defined(__WXMSW__) && defined(WXUSINGDLL) |
094637f6 VZ |
459 | // NT defines APIENTRY, 3.x not |
460 | #if !defined(WXAPIENTRY) | |
790ad94f | 461 | #define WXAPIENTRY WXFAR wxSTDCALL |
094637f6 | 462 | #endif |
750b78ba | 463 | |
f6bcfd97 BP |
464 | #include <windows.h> |
465 | #include "wx/msw/winundef.h" | |
466 | ||
467 | #define IMPLEMENT_WXWIN_MAIN \ | |
468 | extern "C" int WXAPIENTRY WinMain(HINSTANCE hInstance,\ | |
469 | HINSTANCE hPrevInstance,\ | |
470 | LPSTR m_lpCmdLine, int nCmdShow)\ | |
471 | {\ | |
472 | return wxEntry((WXHINSTANCE) hInstance,\ | |
473 | (WXHINSTANCE) hPrevInstance,\ | |
474 | m_lpCmdLine, nCmdShow);\ | |
475 | } | |
26a87b69 | 476 | #else |
094637f6 | 477 | #define IMPLEMENT_WXWIN_MAIN |
26a87b69 JS |
478 | #endif |
479 | ||
24e78d27 VZ |
480 | #ifdef __WXUNIVERSAL__ |
481 | #include "wx/univ/theme.h" | |
482 | ||
483 | #define IMPLEMENT_WX_THEME_SUPPORT \ | |
484 | WX_USE_THEME(win32); \ | |
485 | WX_USE_THEME(gtk); | |
486 | #else | |
487 | #define IMPLEMENT_WX_THEME_SUPPORT | |
488 | #endif | |
c801d85f | 489 | |
c661ecca RR |
490 | // Use this macro if you want to define your own main() or WinMain() function |
491 | // and call wxEntry() from there. | |
492 | #define IMPLEMENT_APP_NO_MAIN(appname) \ | |
493 | wxApp *wxCreateApp() { return new appname; } \ | |
494 | wxAppInitializer wxTheAppInitializer((wxAppInitializerFunction) wxCreateApp); \ | |
495 | appname& wxGetApp() { return *(appname *)wxTheApp; } | |
496 | ||
24e78d27 VZ |
497 | // Same as IMPLEMENT_APP() normally but doesn't include themes support in |
498 | // wxUniversal builds | |
499 | #define IMPLEMENT_APP_NO_THEMES(appname) \ | |
500 | IMPLEMENT_APP_NO_MAIN(appname) \ | |
501 | IMPLEMENT_WXWIN_MAIN | |
502 | ||
503 | // Use this macro exactly once, the argument is the name of the wxApp-derived | |
504 | // class which is the class of your application. | |
505 | #define IMPLEMENT_APP(appname) \ | |
506 | IMPLEMENT_APP_NO_THEMES(appname) \ | |
507 | IMPLEMENT_WX_THEME_SUPPORT | |
508 | ||
509 | // this macro can be used multiple times and just allows you to use wxGetApp() | |
510 | // function | |
094637f6 | 511 | #define DECLARE_APP(appname) extern appname& wxGetApp(); |
c801d85f KB |
512 | |
513 | #endif | |
34138703 | 514 | // _WX_APP_H_BASE_ |