]> git.saurik.com Git - wxWidgets.git/blob - include/wx/evtloop.h
in debug mode when clicking with the middle mouse button draw borders around all...
[wxWidgets.git] / 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(__WXCOCOA__)
128 #include "wx/cocoa/evtloop.h"
129 #elif defined(__WXDFB__)
130 #include "wx/dfb/evtloop.h"
131 #elif defined(__WXGTK20__)
132 #include "wx/gtk/evtloop.h"
133 #else // other platform
134
135 #include "wx/stopwatch.h" // for wxMilliClock_t
136
137 class WXDLLIMPEXP_FWD_CORE wxEventLoopImpl;
138
139 class WXDLLIMPEXP_CORE wxGUIEventLoop : public wxEventLoopBase
140 {
141 public:
142 wxGUIEventLoop() { m_impl = NULL; }
143 virtual ~wxGUIEventLoop();
144
145 virtual int Run();
146 virtual void Exit(int rc = 0);
147 virtual bool Pending() const;
148 virtual bool Dispatch();
149 virtual int DispatchTimeout(unsigned long timeout)
150 {
151 // TODO: this is, of course, horribly inefficient and a proper wait with
152 // timeout should be implemented for all ports natively...
153 const wxMilliClock_t timeEnd = wxGetLocalTimeMillis() + timeout;
154 for ( ;; )
155 {
156 if ( Pending() )
157 return Dispatch();
158
159 if ( wxGetLocalTimeMillis() >= timeEnd )
160 return -1;
161 }
162 }
163 virtual void WakeUp() { }
164
165 protected:
166 // the pointer to the port specific implementation class
167 wxEventLoopImpl *m_impl;
168
169 DECLARE_NO_COPY_CLASS(wxGUIEventLoop)
170 };
171
172 #endif // platforms
173
174 // also include the header defining wxConsoleEventLoop for Unix systems
175 #if defined(__UNIX__)
176 #include "wx/unix/evtloop.h"
177 #endif
178
179 // we use a class rather than a typedef because wxEventLoop is forward-declared
180 // in many places
181 #if wxUSE_GUI
182 class wxEventLoop : public wxGUIEventLoop { };
183 #else // !GUI
184 // we can't define wxEventLoop differently in GUI and base libraries so use
185 // a #define to still allow writing wxEventLoop in the user code
186 #if wxUSE_CONSOLE_EVENTLOOP && (defined(__WXMSW__) || defined(__UNIX__))
187 #define wxEventLoop wxConsoleEventLoop
188 #else // we still must define it somehow for the code below...
189 #define wxEventLoop wxEventLoopBase
190 #endif
191 #endif
192
193 inline bool wxEventLoopBase::IsRunning() const { return GetActive() == this; }
194
195 #if wxUSE_GUI
196 // ----------------------------------------------------------------------------
197 // wxModalEventLoop
198 // ----------------------------------------------------------------------------
199
200 // this is a naive generic implementation which uses wxWindowDisabler to
201 // implement modality, we will surely need platform-specific implementations
202 // too, this generic implementation is here only temporarily to see how it
203 // works
204 class WXDLLIMPEXP_CORE wxModalEventLoop : public wxGUIEventLoop
205 {
206 public:
207 wxModalEventLoop(wxWindow *winModal)
208 {
209 m_windowDisabler = new wxWindowDisabler(winModal);
210 }
211
212 protected:
213 virtual void OnExit()
214 {
215 delete m_windowDisabler;
216 m_windowDisabler = NULL;
217
218 wxGUIEventLoop::OnExit();
219 }
220
221 private:
222 wxWindowDisabler *m_windowDisabler;
223 };
224
225 #endif //wxUSE_GUI
226
227 // ----------------------------------------------------------------------------
228 // wxEventLoopActivator: helper class for wxEventLoop implementations
229 // ----------------------------------------------------------------------------
230
231 // this object sets the wxEventLoop given to the ctor as the currently active
232 // one and unsets it in its dtor, this is especially useful in presence of
233 // exceptions but is more tidy even when we don't use them
234 class wxEventLoopActivator
235 {
236 public:
237 wxEventLoopActivator(wxEventLoopBase *evtLoop)
238 {
239 m_evtLoopOld = wxEventLoopBase::GetActive();
240 wxEventLoopBase::SetActive(evtLoop);
241 }
242
243 ~wxEventLoopActivator()
244 {
245 // restore the previously active event loop
246 wxEventLoopBase::SetActive(m_evtLoopOld);
247 }
248
249 private:
250 wxEventLoopBase *m_evtLoopOld;
251 };
252
253 #if wxUSE_CONSOLE_EVENTLOOP
254
255 class wxEventLoopGuarantor
256 {
257 public:
258 wxEventLoopGuarantor()
259 {
260 m_evtLoopNew = NULL;
261 if (!wxEventLoop::GetActive())
262 {
263 m_evtLoopNew = new wxEventLoop;
264 wxEventLoop::SetActive(m_evtLoopNew);
265 }
266 }
267
268 ~wxEventLoopGuarantor()
269 {
270 if (m_evtLoopNew)
271 {
272 wxEventLoop::SetActive(NULL);
273 delete m_evtLoopNew;
274 }
275 }
276
277 private:
278 wxEventLoop *m_evtLoopNew;
279 };
280
281 #endif // wxUSE_CONSOLE_EVENTLOOP
282
283 #endif // _WX_EVTLOOP_H_