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