+ // implementation only from now on
+ // -------------------------------
+
+ // helpers for dynamic wxApp construction
+ static void SetInitializerFunction(wxAppInitializerFunction fn)
+ { ms_appInitFn = fn; }
+ static wxAppInitializerFunction GetInitializerFunction()
+ { return ms_appInitFn; }
+
+ // accessors for ms_appInstance field (external code might wish to modify
+ // it, this is why we provide a setter here as well, but you should really
+ // know what you're doing if you call it), wxTheApp is usually used instead
+ // of GetInstance()
+ static wxAppConsole *GetInstance() { return ms_appInstance; }
+ static void SetInstance(wxAppConsole *app) { ms_appInstance = app; }
+
+
+ // command line arguments (public for backwards compatibility)
+ int argc;
+ wxChar **argv;
+
+protected:
+ // the function which creates the traits object when GetTraits() needs it
+ // for the first time
+ virtual wxAppTraits *CreateTraits();
+
+
+ // function used for dynamic wxApp creation
+ static wxAppInitializerFunction ms_appInitFn;
+
+ // the one and only global application object
+ static wxAppConsole *ms_appInstance;
+
+
+ // application info (must be set from the user code)
+ wxString m_vendorName, // vendor name (ACME Inc)
+ m_appName, // app name
+ m_className; // class name
+
+ // the class defining the application behaviour, NULL initially and created
+ // by GetTraits() when first needed
+ wxAppTraits *m_traits;
+
+
+ // the application object is a singleton anyhow, there is no sense in
+ // copying it
+ DECLARE_NO_COPY_CLASS(wxAppConsole)
+};
+
+// ----------------------------------------------------------------------------
+// wxAppBase: the common part of wxApp implementations for all platforms
+// ----------------------------------------------------------------------------
+
+#if wxUSE_GUI
+
+class WXDLLIMPEXP_CORE wxAppBase : public wxAppConsole
+{
+public:
+ wxAppBase();
+ virtual ~wxAppBase();
+
+ // the virtual functions which may/must be overridden in the derived class
+ // -----------------------------------------------------------------------
+
+ // very first initialization function
+ //
+ // Override: very rarely
+ virtual bool Initialize(int& argc, wxChar **argv);
+
+ // a platform-dependent version of OnInit(): the code here is likely to
+ // depend on the toolkit. default version does nothing.
+ //
+ // Override: rarely.
+ virtual bool OnInitGui();
+
+ // called to start program execution - the default version just enters
+ // the main GUI loop in which events are received and processed until
+ // the last window is not deleted (if GetExitOnFrameDelete) or
+ // ExitMainLoop() is called. In console mode programs, the execution
+ // of the program really starts here
+ //
+ // Override: rarely in GUI applications, always in console ones.
+ virtual int OnRun();
+
+ // a matching function for OnInit()
+ virtual int OnExit();
+
+ // very last clean up function
+ //
+ // Override: very rarely
+ virtual void CleanUp();
+
+
+ // the worker functions - usually not used directly by the user code
+ // -----------------------------------------------------------------
+
+ // return true if we're running main loop, i.e. if the events can
+ // (already) be dispatched
+ static bool IsMainLoopRunning()
+ {
+ wxAppBase *app = wx_static_cast(wxAppBase *, GetInstance());
+ return app && app->m_mainLoop != NULL;
+ }
+
+ // execute the main GUI loop, the function returns when the loop ends
+ virtual int MainLoop();
+
+ // exit the main loop thus terminating the application
+ virtual void Exit();
+
+ // exit the main GUI loop during the next iteration (i.e. it does not
+ // stop the program immediately!)
+ virtual void ExitMainLoop();
+
+ // returns true if there are unprocessed events in the event queue
+ virtual bool Pending();
+
+ // process the first event in the event queue (blocks until an event
+ // appears if there are none currently, use Pending() if this is not
+ // wanted), returns false if the event loop should stop and true
+ // otherwise
+ virtual bool Dispatch();
+
+ // process all currently pending events right now
+ //
+ // it is an error to call Yield() recursively unless the value of
+ // onlyIfNeeded is true
+ //
+ // WARNING: this function is dangerous as it can lead to unexpected
+ // reentrancies (i.e. when called from an event handler it
+ // may result in calling the same event handler again), use
+ // with _extreme_ care or, better, don't use at all!
+ virtual bool Yield(bool onlyIfNeeded = false) = 0;
+
+ // this virtual function is called in the GUI mode when the application
+ // becomes idle and normally just sends wxIdleEvent to all interested
+ // parties
+ //
+ // it should return true if more idle events are needed, false if not
+ virtual bool ProcessIdle();
+
+ // Send idle event to window and all subwindows
+ // Returns true if more idle time is requested.
+ virtual bool SendIdleEvents(wxWindow* win, wxIdleEvent& event);
+
+
+#if wxUSE_EXCEPTIONS
+ // Function called if an uncaught exception is caught inside the main
+ // event loop: it may return true to continue running the event loop or
+ // false to stop it (in the latter case it may rethrow the exception as
+ // well)
+ virtual bool OnExceptionInMainLoop();
+#endif // wxUSE_EXCEPTIONS
+
+
+ // top level window functions
+ // --------------------------
+
+ // return true if our app has focus
+ virtual bool IsActive() const { return m_isActive; }
+
+ // set the "main" top level window
+ void SetTopWindow(wxWindow *win) { m_topWindow = win; }
+
+ // return the "main" top level window (if it hadn't been set previously
+ // with SetTopWindow(), will return just some top level window and, if
+ // there are none, will return NULL)
+ virtual wxWindow *GetTopWindow() const;
+
+ // control the exit behaviour: by default, the program will exit the
+ // main loop (and so, usually, terminate) when the last top-level
+ // program window is deleted. Beware that if you disable this behaviour
+ // (with SetExitOnFrameDelete(false)), you'll have to call
+ // ExitMainLoop() explicitly from somewhere.
+ void SetExitOnFrameDelete(bool flag)
+ { m_exitOnFrameDelete = flag ? Yes : No; }
+ bool GetExitOnFrameDelete() const
+ { return m_exitOnFrameDelete == Yes; }
+
+
+ // display mode, visual, printing mode, ...
+ // ------------------------------------------------------------------------
+
+ // Get display mode that is used use. This is only used in framebuffer
+ // wxWin ports (such as wxMGL or wxDFB).
+ virtual wxVideoMode GetDisplayMode() const;
+ // Set display mode to use. This is only used in framebuffer wxWin
+ // ports (such as wxMGL or wxDFB). This method should be called from
+ // wxApp::OnInitGui
+ virtual bool SetDisplayMode(const wxVideoMode& WXUNUSED(info)) { return true; }
+
+ // set use of best visual flag (see below)
+ void SetUseBestVisual( bool flag ) { m_useBestVisual = flag; }
+ bool GetUseBestVisual() const { return m_useBestVisual; }
+
+ // set/get printing mode: see wxPRINT_XXX constants.
+ //
+ // default behaviour is the normal one for Unix: always use PostScript
+ // printing.
+ virtual void SetPrintMode(int WXUNUSED(mode)) { }
+ int GetPrintMode() const { return wxPRINT_POSTSCRIPT; }
+
+
+ // command line parsing (GUI-specific)
+ // ------------------------------------------------------------------------
+
+#if wxUSE_CMDLINE_PARSER
+ virtual bool OnCmdLineParsed(wxCmdLineParser& parser);
+ virtual void OnInitCmdLine(wxCmdLineParser& parser);
projects / wxWidgets.git / blobdiff