+#if defined(__WINDOWS__) || defined(__WXMAC__) || defined(__WXDFB__) || (defined(__UNIX__) && !defined(__WXOSX__))
+
+// this class can be used to implement a standard event loop logic using
+// Pending() and Dispatch()
+//
+// it also handles idle processing automatically
+class WXDLLIMPEXP_BASE wxEventLoopManual : public wxEventLoopBase
+{
+public:
+ wxEventLoopManual();
+
+ // enters a loop calling OnNextIteration(), Pending() and Dispatch() and
+ // terminating when Exit() is called
+ virtual int Run();
+
+ // sets the "should exit" flag and wakes up the loop so that it terminates
+ // soon
+ virtual void Exit(int rc = 0);
+
+protected:
+ // may be overridden to perform some action at the start of each new event
+ // loop iteration
+ virtual void OnNextIteration() { }
+
+
+ // the loop exit code
+ int m_exitcode;
+
+ // should we exit the loop?
+ bool m_shouldExit;
+
+private:
+ // process all already pending events and dispatch a new one (blocking
+ // until it appears in the event queue if necessary)
+ //
+ // returns the return value of Dispatch()
+ bool ProcessEvents();
+
+ wxDECLARE_NO_COPY_CLASS(wxEventLoopManual);
+};
+
+#endif // platforms using "manual" loop
+
+// we're moving away from old m_impl wxEventLoop model as otherwise the user
+// code doesn't have access to platform-specific wxEventLoop methods and this
+// can sometimes be very useful (e.g. under MSW this is necessary for
+// integration with MFC) but currently this is not done for all ports yet (e.g.
+// wxX11) so fall back to the old wxGUIEventLoop definition below for them
+
+#if defined(__DARWIN__)
+ // CoreFoundation-based event loop is currently in wxBase so include it in
+ // any case too (although maybe it actually shouldn't be there at all)
+ #include "wx/osx/core/evtloop.h"
+#endif
+
+// include the header defining wxConsoleEventLoop
+#if defined(__UNIX__) && !defined(__WXMSW__)
+ #include "wx/unix/evtloop.h"
+#elif defined(__WINDOWS__)
+ #include "wx/msw/evtloopconsole.h"
+#endif
+
+#if wxUSE_GUI
+
+// include the appropriate header defining wxGUIEventLoop
+
+#if defined(__WXMSW__)
+ #include "wx/msw/evtloop.h"
+#elif defined(__WXCOCOA__)
+ #include "wx/cocoa/evtloop.h"
+#elif defined(__WXOSX__)
+ #include "wx/osx/evtloop.h"
+#elif defined(__WXDFB__)
+ #include "wx/dfb/evtloop.h"
+#elif defined(__WXGTK20__)
+ #include "wx/gtk/evtloop.h"
+#else // other platform
+
+#include "wx/stopwatch.h" // for wxMilliClock_t
+
+class WXDLLIMPEXP_FWD_CORE wxEventLoopImpl;
+
+class WXDLLIMPEXP_CORE wxGUIEventLoop : public wxEventLoopBase
+{
+public:
+ wxGUIEventLoop() { m_impl = NULL; }
+ virtual ~wxGUIEventLoop();
+
+#if wxUSE_EVENTLOOP_SOURCE
+ // We need to define a base class pure virtual method but we can't provide
+ // a generic implementation for it so simply fail.
+ virtual wxEventLoopSource *
+ AddSourceForFD(int WXUNUSED(fd),
+ wxEventLoopSourceHandler * WXUNUSED(handler),
+ int WXUNUSED(flags))
+ {
+ wxFAIL_MSG( "support for event loop sources not implemented" );
+ return NULL;
+ }
+#endif // wxUSE_EVENTLOOP_SOURCE
+
+ virtual int Run();
+ virtual void Exit(int rc = 0);
+ virtual bool Pending() const;
+ virtual bool Dispatch();
+ virtual int DispatchTimeout(unsigned long timeout)
+ {
+ // TODO: this is, of course, horribly inefficient and a proper wait with
+ // timeout should be implemented for all ports natively...
+ const wxMilliClock_t timeEnd = wxGetLocalTimeMillis() + timeout;
+ for ( ;; )
+ {
+ if ( Pending() )
+ return Dispatch();
+
+ if ( wxGetLocalTimeMillis() >= timeEnd )
+ return -1;
+ }
+ }
+ virtual void WakeUp() { }
+ virtual bool YieldFor(long eventsToProcess);
+
+protected:
+ // the pointer to the port specific implementation class
+ wxEventLoopImpl *m_impl;
+
+ wxDECLARE_NO_COPY_CLASS(wxGUIEventLoop);
+};
+
+#endif // platforms
+
+#endif // wxUSE_GUI
+
+#if wxUSE_GUI
+ // we use a class rather than a typedef because wxEventLoop is
+ // forward-declared in many places
+ class wxEventLoop : public wxGUIEventLoop { };
+#else // !wxUSE_GUI
+ // we can't define wxEventLoop differently in GUI and base libraries so use
+ // a #define to still allow writing wxEventLoop in the user code
+ #if wxUSE_CONSOLE_EVENTLOOP && (defined(__WINDOWS__) || defined(__UNIX__))
+ #define wxEventLoop wxConsoleEventLoop
+ #else // we still must define it somehow for the code below...
+ #define wxEventLoop wxEventLoopBase
+ #endif
+#endif
+
+inline bool wxEventLoopBase::IsRunning() const { return GetActive() == this; }
+
+#if wxUSE_GUI && !defined(__WXOSX__)
+// ----------------------------------------------------------------------------
+// wxModalEventLoop
+// ----------------------------------------------------------------------------
+
+// this is a naive generic implementation which uses wxWindowDisabler to
+// implement modality, we will surely need platform-specific implementations
+// too, this generic implementation is here only temporarily to see how it
+// works
+class WXDLLIMPEXP_CORE wxModalEventLoop : public wxGUIEventLoop
+{
+public:
+ wxModalEventLoop(wxWindow *winModal)
+ {
+ m_windowDisabler = new wxWindowDisabler(winModal);
+ }
+
+protected:
+ virtual void OnExit()
+ {
+ delete m_windowDisabler;
+ m_windowDisabler = NULL;
+
+ wxGUIEventLoop::OnExit();
+ }
+
+private:
+ wxWindowDisabler *m_windowDisabler;
+};
+
+#endif //wxUSE_GUI
+
+// ----------------------------------------------------------------------------
+// wxEventLoopActivator: helper class for wxEventLoop implementations
+// ----------------------------------------------------------------------------
+
+// this object sets the wxEventLoop given to the ctor as the currently active
+// one and unsets it in its dtor, this is especially useful in presence of
+// exceptions but is more tidy even when we don't use them
+class wxEventLoopActivator
+{
+public:
+ wxEventLoopActivator(wxEventLoopBase *evtLoop)
+ {
+ m_evtLoopOld = wxEventLoopBase::GetActive();
+ wxEventLoopBase::SetActive(evtLoop);
+ }
+
+ ~wxEventLoopActivator()
+ {
+ // restore the previously active event loop
+ wxEventLoopBase::SetActive(m_evtLoopOld);
+ }
+
+private:
+ wxEventLoopBase *m_evtLoopOld;
+};
+
+#if wxUSE_CONSOLE_EVENTLOOP
+
+class wxEventLoopGuarantor
+{
+public:
+ wxEventLoopGuarantor()
+ {
+ m_evtLoopNew = NULL;
+ if (!wxEventLoop::GetActive())
+ {
+ m_evtLoopNew = new wxEventLoop;
+ wxEventLoop::SetActive(m_evtLoopNew);
+ }
+ }
+
+ ~wxEventLoopGuarantor()
+ {
+ if (m_evtLoopNew)
+ {
+ wxEventLoop::SetActive(NULL);
+ delete m_evtLoopNew;
+ }
+ }
+
+private:
+ wxEventLoop *m_evtLoopNew;
+};
+
+#endif // wxUSE_CONSOLE_EVENTLOOP
+
projects / wxWidgets.git / blobdiff