home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 10 Tools / 10-Tools.zip / wxos2233.zip / wxOS2-2_3_3.zip / wxWindows-2.3.3 / include / wx / app.h < prev    next >
C/C++ Source or Header  |  2002-09-04  |  23KB  |  610 lines
  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,v 1.71 2002/09/04 11:45:06 VZ Exp $
  9. // Copyright:   (c) Julian Smart and Markus Holzem
  10. // Licence:     wxWindows licence
  11. /////////////////////////////////////////////////////////////////////////////
  12.  
  13. #ifndef _WX_APP_H_BASE_
  14. #define _WX_APP_H_BASE_
  15.  
  16. #if defined(__GNUG__) && !defined(__APPLE__)
  17.     #pragma interface "appbase.h"
  18. #endif
  19.  
  20. // ----------------------------------------------------------------------------
  21. // typedefs
  22. // ----------------------------------------------------------------------------
  23.  
  24. #if (defined(__WXMSW__) && !defined(__WXMICROWIN__)) || defined (__WXPM__)
  25.     class WXDLLEXPORT wxApp;
  26.     typedef wxApp* (*wxAppInitializerFunction)();
  27. #else
  28.     // returning wxApp* won't work with gcc
  29.     #include "wx/object.h"
  30.  
  31.     typedef wxObject* (*wxAppInitializerFunction)();
  32. #endif
  33.  
  34. class WXDLLEXPORT wxCmdLineParser;
  35.  
  36. // ----------------------------------------------------------------------------
  37. // headers we have to include here
  38. // ----------------------------------------------------------------------------
  39.  
  40. #include "wx/event.h"       // for the base class
  41.  
  42. #if wxUSE_GUI
  43.     #include "wx/window.h"  // for wxTopLevelWindows
  44. #endif // wxUSE_GUI
  45.  
  46. #if WXWIN_COMPATIBILITY_2_2
  47.     #include "wx/icon.h"
  48. #endif
  49.  
  50. #include "wx/build.h"
  51.  
  52. class WXDLLEXPORT wxLog;
  53. class WXDLLEXPORT wxMessageOutput;
  54.  
  55. // ----------------------------------------------------------------------------
  56. // constants
  57. // ----------------------------------------------------------------------------
  58.  
  59. static const int wxPRINT_WINDOWS = 1;
  60. static const int wxPRINT_POSTSCRIPT = 2;
  61.  
  62. // ----------------------------------------------------------------------------
  63. // support for framebuffer ports
  64. // ----------------------------------------------------------------------------
  65.  
  66. #if wxUSE_GUI
  67. // VS: Fullscreen/framebuffer application needs to choose display mode prior
  68. //     to wxWindows initialization. This class holds information about display
  69. //     mode. It is used by  wxApp::Set/GetDisplayMode.
  70. class WXDLLEXPORT wxDisplayModeInfo
  71. {
  72. public:
  73.     wxDisplayModeInfo() : m_ok(FALSE) {}
  74.     wxDisplayModeInfo(unsigned width, unsigned height, unsigned depth)
  75.         : m_width(width), m_height(height), m_depth(depth), m_ok(TRUE) {}
  76.  
  77.     unsigned GetWidth() const { return m_width; }
  78.     unsigned GetHeight() const { return m_height; }
  79.     unsigned GetDepth() const { return m_depth; }
  80.     bool IsOk() const { return m_ok; }
  81.  
  82. private:
  83.     unsigned m_width, m_height, m_depth;
  84.     bool     m_ok;
  85. };
  86. #endif
  87.  
  88. // ----------------------------------------------------------------------------
  89. // the common part of wxApp implementations for all platforms
  90. // ----------------------------------------------------------------------------
  91.  
  92. class WXDLLEXPORT wxAppBase : public wxEvtHandler
  93. {
  94.     DECLARE_NO_COPY_CLASS(wxAppBase)
  95.  
  96. public:
  97.     wxAppBase();
  98.     virtual ~wxAppBase();
  99.  
  100.     // the virtual functions which may/must be overridden in the derived class
  101.     // -----------------------------------------------------------------------
  102.  
  103.         // called during the program initialization, returning FALSE from here
  104.         // prevents the program from continuing - it's a good place to create
  105.         // the top level program window and return TRUE.
  106.         //
  107.         // Override: always in GUI application, rarely in console ones.
  108.     virtual bool OnInit();
  109.  
  110. #if wxUSE_GUI
  111.         // a platform-dependent version of OnInit(): the code here is likely to
  112.         // depend on the toolkit. default version does nothing.
  113.         //
  114.         // Override: rarely.
  115.     virtual bool OnInitGui();
  116. #endif // wxUSE_GUI
  117.  
  118.         // called to start program execution - the default version just enters
  119.         // the main GUI loop in which events are received and processed until
  120.         // the last window is not deleted (if GetExitOnFrameDelete) or
  121.         // ExitMainLoop() is called. In console mode programs, the execution
  122.         // of the program really starts here
  123.         //
  124.         // Override: rarely in GUI applications, always in console ones.
  125. #if wxUSE_GUI
  126.     virtual int OnRun();
  127. #else // !GUI
  128.     virtual int OnRun() = 0;
  129. #endif // wxUSE_GUI
  130.  
  131.         // called after the main loop termination. This is a good place for
  132.         // cleaning up (it may be too late in dtor) and is also useful if you
  133.         // want to return some non-default exit code - this is just the return
  134.         // value of this method.
  135.         //
  136.         // Override: often.
  137.     virtual int OnExit();
  138.  
  139.         // called when a fatal exception occurs, this function should take care
  140.         // not to do anything which might provoke a nested exception! It may be
  141.         // overridden if you wish to react somehow in non-default way (core
  142.         // dump under Unix, application crash under Windows) to fatal program
  143.         // errors, however extreme care should be taken if you don't want this
  144.         // function to crash.
  145.         //
  146.         // Override: rarely.
  147.     virtual void OnFatalException() { }
  148.  
  149.     // the worker functions - usually not used directly by the user code
  150.     // -----------------------------------------------------------------
  151.  
  152. #if wxUSE_GUI
  153.         // execute the main GUI loop, the function returns when the loop ends
  154.     virtual int MainLoop() = 0;
  155.  
  156.         // exit the main GUI loop during the next iteration (i.e. it does not
  157.         // stop the program immediately!)
  158.     virtual void ExitMainLoop() = 0;
  159.  
  160.         // returns TRUE if the program is initialized
  161.     virtual bool Initialized() = 0;
  162.  
  163.         // returns TRUE if there are unprocessed events in the event queue
  164.     virtual bool Pending() = 0;
  165.  
  166.         // process the first event in the event queue (blocks until an event
  167.         // apperas if there are none currently)
  168.     virtual void Dispatch() = 0;
  169.  
  170.         // process all currently pending events right now
  171.         //
  172.         // it is an error to call Yield() recursively unless the value of
  173.         // onlyIfNeeded is TRUE
  174.         //
  175.         // WARNING: this function is dangerous as it can lead to unexpected
  176.         //          reentrancies (i.e. when called from an event handler it
  177.         //          may result in calling the same event handler again), use
  178.         //          with _extreme_ care or, better, don't use at all!
  179.     virtual bool Yield(bool onlyIfNeeded = FALSE) = 0;
  180.  
  181.         // this virtual function is called in the GUI mode when the application
  182.         // becomes idle and normally just sends wxIdleEvent to all interested
  183.         // parties
  184.         //
  185.         // it should return TRUE if more idle events are needed, FALSE if not
  186.     virtual bool ProcessIdle() = 0;
  187. #endif // wxUSE_GUI
  188.  
  189.     // application info: name, description, vendor
  190.     // -------------------------------------------
  191.  
  192.     // NB: all these should be set by the application itself, there are no
  193.     //     reasonable default except for the application name which is taken to
  194.     //     be argv[0]
  195.  
  196.         // set/get the application name
  197.     wxString GetAppName() const
  198.     {
  199.         if ( !m_appName )
  200.             return m_className;
  201.         else
  202.             return m_appName;
  203.     }
  204.     void SetAppName(const wxString& name) { m_appName = name; }
  205.  
  206.         // set/get the app class name
  207.     wxString GetClassName() const { return m_className; }
  208.     void SetClassName(const wxString& name) { m_className = name; }
  209.  
  210.         // set/get the vendor name
  211.     const wxString& GetVendorName() const { return m_vendorName; }
  212.     void SetVendorName(const wxString& name) { m_vendorName = name; }
  213.  
  214. #if wxUSE_GUI
  215.     // top level window functions
  216.     // --------------------------
  217.  
  218.         // return TRUE if our app has focus
  219.     virtual bool IsActive() const { return m_isActive; }
  220.  
  221.         // set the "main" top level window
  222.     void SetTopWindow(wxWindow *win) { m_topWindow = win; }
  223.  
  224.         // return the "main" top level window (if it hadn't been set previously
  225.         // with SetTopWindow(), will return just some top level window and, if
  226.         // there are none, will return NULL)
  227.     virtual wxWindow *GetTopWindow() const
  228.     {
  229.         if (m_topWindow)
  230.             return m_topWindow;
  231.         else if (wxTopLevelWindows.GetCount() > 0)
  232.             return wxTopLevelWindows.GetFirst()->GetData();
  233.         else
  234.             return (wxWindow *)NULL;
  235.     }
  236.  
  237.         // control the exit behaviour: by default, the program will exit the
  238.         // main loop (and so, usually, terminate) when the last top-level
  239.         // program window is deleted. Beware that if you disable this behaviour
  240.         // (with SetExitOnFrameDelete(FALSE)), you'll have to call
  241.         // ExitMainLoop() explicitly from somewhere.
  242.     void SetExitOnFrameDelete(bool flag)
  243.         { m_exitOnFrameDelete = flag ? Yes : No; }
  244.     bool GetExitOnFrameDelete() const
  245.         { return m_exitOnFrameDelete == Yes; }
  246.  
  247. #endif // wxUSE_GUI
  248.  
  249.     // cmd line parsing stuff
  250.     // ----------------------
  251.  
  252.     // all of these methods may be overridden in the derived class to
  253.     // customize the command line parsing (by default only a few standard
  254.     // options are handled)
  255.     //
  256.     // you also need to call wxApp::OnInit() from YourApp::OnInit() for all
  257.     // this to work
  258.  
  259. #if wxUSE_CMDLINE_PARSER
  260.     // this one is called from OnInit() to add all supported options
  261.     // to the given parser
  262.     virtual void OnInitCmdLine(wxCmdLineParser& parser);
  263.  
  264.     // called after successfully parsing the command line, return TRUE
  265.     // to continue and FALSE to exit
  266.     virtual bool OnCmdLineParsed(wxCmdLineParser& parser);
  267.  
  268.     // called if "--help" option was specified, return TRUE to continue
  269.     // and FALSE to exit
  270.     virtual bool OnCmdLineHelp(wxCmdLineParser& parser);
  271.  
  272.     // called if incorrect command line options were given, return
  273.     // FALSE to abort and TRUE to continue
  274.     virtual bool OnCmdLineError(wxCmdLineParser& parser);
  275. #endif // wxUSE_CMDLINE_PARSER
  276.  
  277.     // miscellaneous customization functions
  278.     // -------------------------------------
  279.  
  280. #if wxUSE_LOG
  281.         // override this function to create default log target of arbitrary
  282.         // user-defined class (default implementation creates a wxLogGui
  283.         // object) - this log object is used by default by all wxLogXXX()
  284.         // functions.
  285.     virtual wxLog *CreateLogTarget();
  286. #endif // wxUSE_LOG
  287.  
  288.         // similar to CreateLogTarget() but for the global wxMessageOutput
  289.         // object
  290.     virtual wxMessageOutput *CreateMessageOutput();
  291.  
  292. #if wxUSE_GUI
  293.  
  294. #if WXWIN_COMPATIBILITY_2_2
  295.         // get the standard icon used by wxWin dialogs - this allows the user
  296.         // to customize the standard dialogs. The 'which' parameter is one of
  297.         // wxICON_XXX values
  298.     virtual wxIcon GetStdIcon(int WXUNUSED(which)) const { return wxNullIcon; }
  299. #endif
  300.  
  301.         // Get display mode that is used use. This is only used in framebuffer wxWin ports
  302.         // (such as wxMGL).
  303.     virtual wxDisplayModeInfo GetDisplayMode() const { return wxDisplayModeInfo(); }
  304.         // Set display mode to use. This is only used in framebuffer wxWin ports
  305.         // (such as wxMGL). This method should be called from wxApp:OnInitGui
  306.     virtual bool SetDisplayMode(const wxDisplayModeInfo& WXUNUSED(info)) { return TRUE; }
  307.  
  308.         // set use of best visual flag (see below)
  309.     void SetUseBestVisual( bool flag ) { m_useBestVisual = flag; }
  310.     bool GetUseBestVisual() const { return m_useBestVisual; }
  311.  
  312.         // set/get printing mode: see wxPRINT_XXX constants.
  313.         //
  314.         // default behaviour is the normal one for Unix: always use PostScript
  315.         // printing.
  316.     virtual void SetPrintMode(int WXUNUSED(mode)) { }
  317.     int GetPrintMode() const { return wxPRINT_POSTSCRIPT; }
  318.  
  319.     // called by toolkit-specific code to set the app status: active (we have
  320.     // focus) or not and also the last window which had focus before we were
  321.     // deactivated
  322.     virtual void SetActive(bool isActive, wxWindow *lastFocus);
  323. #endif // wxUSE_GUI
  324.  
  325.     // this method allows to filter all the events processed by the program, so
  326.     // you should try to return quickly from it to avoid slowing down the
  327.     // program to the crawl
  328.     //
  329.     // return value should be -1 to continue with the normal event processing,
  330.     // or TRUE or FALSE to stop further processing and pretend that the event
  331.     // had been already processed or won't be processed at all, respectively
  332.     virtual int FilterEvent(wxEvent& event);
  333.  
  334.     // debugging support
  335.     // -----------------
  336.  
  337.     // this function is called when an assert failure occurs, the base class
  338.     // version does the normal processing (i.e. shows the usual assert failure
  339.     // dialog box)
  340.     //
  341.     // the arguments are the place where the assert occured, the text of the
  342.     // assert itself and the user-specified message
  343. #ifdef __WXDEBUG__
  344.     virtual void OnAssert(const wxChar *file,
  345.                           int line,
  346.                           const wxChar *cond,
  347.                           const wxChar *msg);
  348. #endif // __WXDEBUG__
  349.  
  350.     // check that the wxBuildOptions object (constructed in the application
  351.     // itself, usually the one from IMPLEMENT_APP() macro) matches the build
  352.     // options of the library and abort if it doesn't
  353.     static bool CheckBuildOptions(const wxBuildOptions& buildOptions);
  354.  
  355.     // deprecated functions, please updae your code to not use them!
  356.     // -------------------------------------------------------------
  357.  
  358. #if WXWIN_COMPATIBILITY_2_2
  359.     // used by obsolete wxDebugMsg only
  360.     void SetWantDebugOutput( bool flag ) { m_wantDebugOutput = flag; }
  361.     bool GetWantDebugOutput() const { return m_wantDebugOutput; }
  362.  
  363.     // TRUE if the application wants to get debug output
  364.     bool m_wantDebugOutput;
  365. #endif // WXWIN_COMPATIBILITY_2_2
  366.  
  367.     // implementation only from now on
  368.     // -------------------------------
  369.  
  370.     // helpers for dynamic wxApp construction
  371.     static void SetInitializerFunction(wxAppInitializerFunction fn)
  372.         { m_appInitFn = fn; }
  373.     static wxAppInitializerFunction GetInitializerFunction()
  374.         { return m_appInitFn; }
  375.  
  376.     // process all events in the wxPendingEvents list
  377.     virtual void ProcessPendingEvents();
  378.  
  379.     // access to the command line arguments
  380.     int      argc;
  381.     wxChar **argv;
  382.  
  383. protected:
  384.     // function used for dynamic wxApp creation
  385.     static wxAppInitializerFunction m_appInitFn;
  386.  
  387.     // application info (must be set from the user code)
  388.     wxString m_vendorName,      // vendor name (ACME Inc)
  389.              m_appName,         // app name
  390.              m_className;       // class name
  391.  
  392. #if wxUSE_GUI
  393.     // the main top level window - may be NULL
  394.     wxWindow *m_topWindow;
  395.  
  396.     // if Yes, exit the main loop when the last top level window is deleted, if
  397.     // No don't do it and if Later -- only do it once we reach our OnRun()
  398.     //
  399.     // the explanation for using this strange scheme is given in appcmn.cpp
  400.     enum
  401.     {
  402.         Later = -1,
  403.         No,
  404.         Yes
  405.     } m_exitOnFrameDelete;
  406.  
  407.     // TRUE if the apps whats to use the best visual on systems where
  408.     // more than one are available (Sun, SGI, XFree86 4.0 ?)
  409.     bool m_useBestVisual;
  410.  
  411.     // does any of our windows has focus?
  412.     bool m_isActive;
  413. #endif // wxUSE_GUI
  414. };
  415.  
  416. // ----------------------------------------------------------------------------
  417. // now include the declaration of the real class
  418. // ----------------------------------------------------------------------------
  419.  
  420. #if wxUSE_GUI
  421.     #if defined(__WXMSW__)
  422.         #include "wx/msw/app.h"
  423.     #elif defined(__WXMOTIF__)
  424.         #include "wx/motif/app.h"
  425.     #elif defined(__WXMGL__)
  426.         #include "wx/mgl/app.h"
  427.     #elif defined(__WXGTK__)
  428.         #include "wx/gtk/app.h"
  429.     #elif defined(__WXX11__)
  430.         #include "wx/x11/app.h"
  431.     #elif defined(__WXMAC__)
  432.         #include "wx/mac/app.h"
  433.     #elif defined(__WXPM__)
  434.         #include "wx/os2/app.h"
  435.     #elif defined(__WXSTUBS__)
  436.         #include "wx/stubs/app.h"
  437.     #endif
  438. #else // !GUI
  439.     // can't use typedef because wxApp forward declared as a class
  440.     class WXDLLEXPORT wxApp : public wxAppBase
  441.     {
  442.     };
  443. #endif // GUI/!GUI
  444.  
  445. // ----------------------------------------------------------------------------
  446. // the global data
  447. // ----------------------------------------------------------------------------
  448.  
  449. // the one and only application object - use of wxTheApp in application code
  450. // is discouraged, consider using DECLARE_APP() after which you may call
  451. // wxGetApp() which will return the object of the correct type (i.e. MyApp and
  452. // not wxApp)
  453. WXDLLEXPORT_DATA(extern wxApp*) wxTheApp;
  454.  
  455. // ----------------------------------------------------------------------------
  456. // global functions
  457. // ----------------------------------------------------------------------------
  458.  
  459. // event loop related functions only work in GUI programs
  460. // ------------------------------------------------------
  461.  
  462. // Force an exit from main loop
  463. extern void WXDLLEXPORT wxExit();
  464.  
  465. // Yield to other apps/messages
  466. extern bool WXDLLEXPORT wxYield();
  467.  
  468. // Yield to other apps/messages
  469. extern void WXDLLEXPORT wxWakeUpIdle();
  470.  
  471. // Post a message to the given eventhandler which will be processed during the
  472. // next event loop iteration
  473. inline void wxPostEvent(wxEvtHandler *dest, wxEvent& event)
  474. {
  475.     wxCHECK_RET( dest, wxT("need an object to post event to in wxPostEvent") );
  476.  
  477. #if wxUSE_GUI
  478.     dest->AddPendingEvent(event);
  479. #else
  480.     dest->ProcessEvent(event);
  481. #endif // wxUSE_GUI
  482. }
  483.  
  484. // console applications may avoid using DECLARE_APP and IMPLEMENT_APP macros
  485. // and call these functions instead at the program startup and termination
  486. // -------------------------------------------------------------------------
  487.  
  488. #if !wxUSE_GUI
  489.  
  490. // initialize the library (may be called as many times as needed, but each
  491. // call to wxInitialize() must be matched by wxUninitialize())
  492. extern bool WXDLLEXPORT wxInitialize();
  493.  
  494. // clean up - the library can't be used any more after the last call to
  495. // wxUninitialize()
  496. extern void WXDLLEXPORT wxUninitialize();
  497.  
  498. // create an object of this class on stack to initialize/cleanup thel ibrary
  499. // automatically
  500. class WXDLLEXPORT wxInitializer
  501. {
  502. public:
  503.     // initialize the library
  504.     wxInitializer() { m_ok = wxInitialize(); }
  505.  
  506.     // has the initialization been successful? (explicit test)
  507.     bool IsOk() const { return m_ok; }
  508.  
  509.     // has the initialization been successful? (implicit test)
  510.     operator bool() const { return m_ok; }
  511.  
  512.     // dtor only does clean up if we initialized the library properly
  513.     ~wxInitializer() { if ( m_ok ) wxUninitialize(); }
  514.  
  515. private:
  516.     bool m_ok;
  517. };
  518.  
  519. #endif // !wxUSE_GUI
  520.  
  521. // ----------------------------------------------------------------------------
  522. // macros for dynamic creation of the application object
  523. // ----------------------------------------------------------------------------
  524.  
  525. // Having a global instance of this class allows wxApp to be aware of the app
  526. // creator function. wxApp can then call this function to create a new app
  527. // object. Convoluted, but necessary.
  528.  
  529. class WXDLLEXPORT wxAppInitializer
  530. {
  531. public:
  532.     wxAppInitializer(wxAppInitializerFunction fn)
  533.         { wxApp::SetInitializerFunction(fn); }
  534. };
  535.  
  536. // Here's a macro you can use if your compiler really, really wants main() to
  537. // be in your main program (e.g. hello.cpp). Now IMPLEMENT_APP should add this
  538. // code if required.
  539.  
  540. #if !wxUSE_GUI || defined(__WXMOTIF__) || defined(__WXGTK__) || defined(__WXPM__) || defined(__WXMGL__)
  541.     #define IMPLEMENT_WXWIN_MAIN \
  542.         extern int wxEntry( int argc, char *argv[] ); \
  543.         int main(int argc, char *argv[]) { return wxEntry(argc, argv); }
  544. #elif defined(__WXMAC__) && defined(__UNIX__)
  545.     // wxMac seems to have a specific wxEntry prototype
  546.     #define IMPLEMENT_WXWIN_MAIN \
  547.         extern int wxEntry( int argc, char *argv[], bool enterLoop = TRUE ); \
  548.         int main(int argc, char *argv[]) { return wxEntry(argc, argv); }
  549. #elif defined(__WXMSW__) && defined(WXUSINGDLL)
  550.     // NT defines APIENTRY, 3.x not
  551.     #if !defined(WXAPIENTRY)
  552.         #define WXAPIENTRY WXFAR wxSTDCALL
  553.     #endif
  554.  
  555.     #include <windows.h>
  556.     #include "wx/msw/winundef.h"
  557.  
  558.     #define IMPLEMENT_WXWIN_MAIN \
  559.         extern "C" int WXAPIENTRY WinMain(HINSTANCE hInstance,\
  560.                                           HINSTANCE hPrevInstance,\
  561.                                           LPSTR m_lpCmdLine, int nCmdShow)\
  562.         {\
  563.             return wxEntry((WXHINSTANCE) hInstance,\
  564.                            (WXHINSTANCE) hPrevInstance,\
  565.                            m_lpCmdLine, nCmdShow);\
  566.         }
  567. #else
  568.     #define IMPLEMENT_WXWIN_MAIN
  569. #endif
  570.  
  571. #ifdef __WXUNIVERSAL__
  572.     #include "wx/univ/theme.h"
  573.  
  574.     #define IMPLEMENT_WX_THEME_SUPPORT \
  575.         WX_USE_THEME(win32); \
  576.         WX_USE_THEME(gtk);
  577. #else
  578.     #define IMPLEMENT_WX_THEME_SUPPORT
  579. #endif
  580.  
  581. // Use this macro if you want to define your own main() or WinMain() function
  582. // and call wxEntry() from there.
  583. #define IMPLEMENT_APP_NO_MAIN(appname)                   \
  584.     wxApp *wxCreateApp()                                 \
  585.     {                                                    \
  586.         wxApp::CheckBuildOptions(wxBuildOptions());      \
  587.         return new appname;                              \
  588.     }                                                    \
  589.     wxAppInitializer wxTheAppInitializer((wxAppInitializerFunction) wxCreateApp); \
  590.     appname& wxGetApp() { return *(appname *)wxTheApp; }
  591.  
  592. // Same as IMPLEMENT_APP() normally but doesn't include themes support in
  593. // wxUniversal builds
  594. #define IMPLEMENT_APP_NO_THEMES(appname)    \
  595.     IMPLEMENT_APP_NO_MAIN(appname)          \
  596.     IMPLEMENT_WXWIN_MAIN
  597.  
  598. // Use this macro exactly once, the argument is the name of the wxApp-derived
  599. // class which is the class of your application.
  600. #define IMPLEMENT_APP(appname)              \
  601.     IMPLEMENT_APP_NO_THEMES(appname)        \
  602.     IMPLEMENT_WX_THEME_SUPPORT
  603.  
  604. // this macro can be used multiple times and just allows you to use wxGetApp()
  605. // function
  606. #define DECLARE_APP(appname) extern appname& wxGetApp();
  607.  
  608. #endif
  609.     // _WX_APP_H_BASE_
  610.