include/wx/evtloop.h

   1 ///////////////////////////////////////////////////////////////////////////////
   2 // Name:        wx/evtloop.h
   3 // Purpose:     declares wxEventLoop class
   4 // Author:      Vadim Zeitlin
   5 // Modified by:
   6 // Created:     01.06.01
   7 // RCS-ID:      $Id$
   8 // Copyright:   (c) 2001 Vadim Zeitlin <zeitlin@dptmaths.ens-cachan.fr>
   9 // Licence:     wxWindows licence
  10 ///////////////////////////////////////////////////////////////////////////////
  11
  12 #ifndef _WX_EVTLOOP_H_
  13 #define _WX_EVTLOOP_H_
  14
  15 #include "wx/utils.h"
  16
  17 // ----------------------------------------------------------------------------
  18 // wxEventLoopBase: interface for wxEventLoop
  19 // ----------------------------------------------------------------------------
  20
  21 class WXDLLIMPEXP_BASE wxEventLoopBase
  22 {
  23 public:
  24     // trivial, but needed (because of wxEventLoopBase) ctor
  25     wxEventLoopBase() { }
  26
  27     // dtor
  28     virtual ~wxEventLoopBase() { }
  29
  30     // use this to check whether the event loop was successfully created before
  31     // using it
  32     virtual bool IsOk() const { return true; }
  33
  34
  35     // start the event loop, return the exit code when it is finished
  36     virtual int Run() = 0;
  37
  38     // exit from the loop with the given exit code
  39     virtual void Exit(int rc = 0) = 0;
  40
  41     // return true if any events are available
  42     virtual bool Pending() const = 0;
  43
  44     // dispatch a single event, return false if we should exit from the loop
  45     virtual bool Dispatch() = 0;
  46
  47     // same as Dispatch() but doesn't wait for longer than the specified (in
  48     // ms) timeout, return true if an event was processed, false if we should
  49     // exit the loop or -1 if timeout expired
  50     virtual int DispatchTimeout(unsigned long timeout) = 0;
  51
  52
  53     // return currently active (running) event loop, may be NULL
  54     static wxEventLoopBase *GetActive() { return ms_activeLoop; }
  55
  56     // set currently active (running) event loop
  57     static void SetActive(wxEventLoopBase* loop) { ms_activeLoop = loop; }
  58
  59     // is this event loop running now?
  60     //
  61     // notice that even if this event loop hasn't terminated yet but has just
  62     // spawned a nested (e.g. modal) event loop, this would return false
  63     bool IsRunning() const;
  64
  65     // implement this to wake up the loop: usually done by posting a dummy event
  66     // to it (can be called from non main thread)
  67     virtual void WakeUp() = 0;
  68
  69 protected:
  70     // this function should be called before the event loop terminates, whether
  71     // this happens normally (because of Exit() call) or abnormally (because of
  72     // an exception thrown from inside the loop)
  73     virtual void OnExit() { }
  74
  75
  76     // the pointer to currently active loop
  77     static wxEventLoopBase *ms_activeLoop;
  78
  79     DECLARE_NO_COPY_CLASS(wxEventLoopBase)
  80 };
  81
  82 #if defined(__WXMSW__) || defined(__WXMAC__) || defined(__WXDFB__) || defined(__UNIX__)
  83
  84 // this class can be used to implement a standard event loop logic using
  85 // Pending() and Dispatch()
  86 //
  87 // it also handles idle processing automatically
  88 class WXDLLIMPEXP_BASE wxEventLoopManual : public wxEventLoopBase
  89 {
  90 public:
  91     wxEventLoopManual();
  92
  93     // enters a loop calling OnNextIteration(), Pending() and Dispatch() and
  94     // terminating when Exit() is called
  95     virtual int Run();
  96
  97     // sets the "should exit" flag and wakes up the loop so that it terminates
  98     // soon
  99     virtual void Exit(int rc = 0);
 100
 101 protected:
 102     // may be overridden to perform some action at the start of each new event
 103     // loop iteration
 104     virtual void OnNextIteration() { }
 105
 106
 107     // the loop exit code
 108     int m_exitcode;
 109
 110     // should we exit the loop?
 111     bool m_shouldExit;
 112 };
 113
 114 #endif // platforms using "manual" loop
 115
 116 // we're moving away from old m_impl wxEventLoop model as otherwise the user
 117 // code doesn't have access to platform-specific wxEventLoop methods and this
 118 // can sometimes be very useful (e.g. under MSW this is necessary for
 119 // integration with MFC) but currently this is done for MSW only, other ports
 120 // should follow a.s.a.p.
 121 #if defined(__WXPALMOS__)
 122     #include "wx/palmos/evtloop.h"
 123 #elif defined(__WXMSW__)
 124     #include "wx/msw/evtloop.h"
 125 #elif defined(__WXMAC__)
 126     #include "wx/osx/evtloop.h"
 127 #elif defined(__WXDFB__)
 128     #include "wx/dfb/evtloop.h"
 129 #else // other platform
 130
 131 #define wxNEEDS_GENERIC_DISPATCH_TIMEOUT
 132
 133 class WXDLLIMPEXP_FWD_CORE wxEventLoopImpl;
 134
 135 class WXDLLIMPEXP_CORE wxGUIEventLoop : public wxEventLoopBase
 136 {
 137 public:
 138     wxGUIEventLoop() { m_impl = NULL; }
 139     virtual ~wxGUIEventLoop();
 140
 141     virtual int Run();
 142     virtual void Exit(int rc = 0);
 143     virtual bool Pending() const;
 144     virtual bool Dispatch();
 145     virtual int DispatchTimeout(unsigned long timeout);
 146     virtual void WakeUp() { }
 147
 148 protected:
 149     // the pointer to the port specific implementation class
 150     wxEventLoopImpl *m_impl;
 151
 152     DECLARE_NO_COPY_CLASS(wxGUIEventLoop)
 153 };
 154
 155 #endif // platforms
 156
 157 // also include the header defining wxConsoleEventLoop for Unix systems
 158 #if defined(__UNIX__)
 159     #include "wx/unix/evtloop.h"
 160 #endif
 161
 162 // we use a class rather than a typedef because wxEventLoop is forward-declared
 163 // in many places
 164 #if wxUSE_GUI
 165     class wxEventLoop : public wxGUIEventLoop { };
 166 #else // !GUI
 167     // we can't define wxEventLoop differently in GUI and base libraries so use
 168     // a #define to still allow writing wxEventLoop in the user code
 169     #if wxUSE_CONSOLE_EVENTLOOP && (defined(__WXMSW__) || defined(__UNIX__))
 170         #define wxEventLoop wxConsoleEventLoop
 171     #else // we still must define it somehow for the code below...
 172         #define wxEventLoop wxEventLoopBase
 173     #endif
 174 #endif
 175
 176 inline bool wxEventLoopBase::IsRunning() const { return GetActive() == this; }
 177
 178 #if wxUSE_GUI
 179 // ----------------------------------------------------------------------------
 180 // wxModalEventLoop
 181 // ----------------------------------------------------------------------------
 182
 183 // this is a naive generic implementation which uses wxWindowDisabler to
 184 // implement modality, we will surely need platform-specific implementations
 185 // too, this generic implementation is here only temporarily to see how it
 186 // works
 187 class WXDLLIMPEXP_CORE wxModalEventLoop : public wxGUIEventLoop
 188 {
 189 public:
 190     wxModalEventLoop(wxWindow *winModal)
 191     {
 192         m_windowDisabler = new wxWindowDisabler(winModal);
 193     }
 194
 195 protected:
 196     virtual void OnExit()
 197     {
 198         delete m_windowDisabler;
 199         m_windowDisabler = NULL;
 200
 201         wxGUIEventLoop::OnExit();
 202     }
 203
 204 private:
 205     wxWindowDisabler *m_windowDisabler;
 206 };
 207
 208 #endif //wxUSE_GUI
 209
 210 // ----------------------------------------------------------------------------
 211 // wxEventLoopActivator: helper class for wxEventLoop implementations
 212 // ----------------------------------------------------------------------------
 213
 214 // this object sets the wxEventLoop given to the ctor as the currently active
 215 // one and unsets it in its dtor, this is especially useful in presence of
 216 // exceptions but is more tidy even when we don't use them
 217 class wxEventLoopActivator
 218 {
 219 public:
 220     wxEventLoopActivator(wxEventLoopBase *evtLoop)
 221     {
 222         m_evtLoopOld = wxEventLoopBase::GetActive();
 223         wxEventLoopBase::SetActive(evtLoop);
 224     }
 225
 226     ~wxEventLoopActivator()
 227     {
 228         // restore the previously active event loop
 229         wxEventLoopBase::SetActive(m_evtLoopOld);
 230     }
 231
 232 private:
 233     wxEventLoopBase *m_evtLoopOld;
 234 };
 235
 236 #if wxUSE_CONSOLE_EVENTLOOP
 237
 238 class wxEventLoopGuarantor
 239 {
 240 public:
 241     wxEventLoopGuarantor()
 242     {
 243         m_evtLoopNew = NULL;
 244         if (!wxEventLoop::GetActive())
 245         {
 246             m_evtLoopNew = new wxEventLoop;
 247             wxEventLoop::SetActive(m_evtLoopNew);
 248         }
 249     }
 250
 251     ~wxEventLoopGuarantor()
 252     {
 253         if (m_evtLoopNew)
 254         {
 255             wxEventLoop::SetActive(NULL);
 256             delete m_evtLoopNew;
 257         }
 258     }
 259
 260 private:
 261     wxEventLoop *m_evtLoopNew;
 262 };
 263
 264 #endif // wxUSE_CONSOLE_EVENTLOOP
 265
 266 #endif // _WX_EVTLOOP_H_