]> git.saurik.com Git - wxWidgets.git/blob - src/generic/timer.cpp
starting blend modes for Core Graphics
[wxWidgets.git] / src / generic / timer.cpp
1 /////////////////////////////////////////////////////////////////////////////
2 // Name: mgl/timer.cpp
3 // Purpose: wxTimer implementation
4 // Author: Vaclav Slavik
5 // Id: $Id$
6 // Copyright: (c) Vaclav Slavik
7 // Licence: wxWindows licence
8 /////////////////////////////////////////////////////////////////////////////
9
10 // For compilers that support precompilation, includes "wx.h".
11 #include "wx/wxprec.h"
12
13 #ifdef __BORLANDC__
14 #pragma hdrstop
15 #endif
16
17 // ----------------------------------------------------------------------------
18 // NB: when using generic wxTimer implementation in your port, you *must* call
19 // wxTimer::NotifyTimers() often enough. The ideal place for this
20 // is in wxEventLoop::Dispatch().
21 // ----------------------------------------------------------------------------
22
23 #include "wx/timer.h"
24
25 #if wxUSE_TIMER
26
27 #include "wx/log.h"
28 #include "wx/module.h"
29
30 // ----------------------------------------------------------------------------
31 // Time input function
32 // ----------------------------------------------------------------------------
33
34 #ifdef __WXMGL__
35 // We take advantage of wxMGL's _EVT_getTicks because it is faster
36 // (especially under MS-DOS!) and more precise than wxGetLocalTimeMillis
37 // if we are unlucky and the latter combines information from two sources.
38 #include "wx/mgl/private.h"
39 extern "C" ulong _EVT_getTicks();
40 #define GetMillisecondsTime _EVT_getTicks
41
42 typedef ulong wxTimerTick_t;
43
44 #define wxTimerTickFmtSpec _T("lu")
45 #define wxTimerTickPrintfArg(tt) (tt)
46
47 #ifdef __DOS__
48 // Under DOS the MGL timer has a 24hr period, so consider the 12 hours
49 // before y to be 'less' and the the 12 hours after 'greater' modulo
50 // 24 hours.
51 inline bool wxTickGreaterEqual(wxTimerTick_t x, wxTimerTick_t y)
52 {
53 // _EVT_getTicks wraps at 1573040 * 55
54 const wxTimerTick_t modulus = 1573040 * 55;
55 return (2 * modulus + x - y) % modulus < modulus / 2;
56 }
57 #else
58 // If wxTimerTick_t is 32-bits then it'll wrap in around 50 days. So
59 // let the 25 days before y be 'less' and 25 days after be 'greater'.
60 inline bool wxTickGreaterEqual(wxTimerTick_t x, wxTimerTick_t y)
61 {
62 // This code assumes wxTimerTick_t is an unsigned type.
63 // Set half_modulus with top bit set and the rest zeros.
64 const wxTimerTick_t half_modulus = ~((~(wxTimerTick_t)0) >> 1);
65 return x - y < half_modulus;
66 }
67 #endif
68 #else // !__WXMGL__
69 #define GetMillisecondsTime wxGetLocalTimeMillis
70
71 typedef wxLongLong wxTimerTick_t;
72
73 #if wxUSE_LONGLONG_WX
74 #define wxTimerTickFmtSpec wxLongLongFmtSpec _T("d")
75 #define wxTimerTickPrintfArg(tt) (tt.GetValue())
76 #else // using native wxLongLong
77 #define wxTimerTickFmtSpec _T("s")
78 #define wxTimerTickPrintfArg(tt) (tt.ToString().c_str())
79 #endif // wx/native long long
80
81 inline bool wxTickGreaterEqual(wxTimerTick_t x, wxTimerTick_t y)
82 {
83 return x >= y;
84 }
85 #endif // __WXMGL__/!__WXMGL__
86
87 // ----------------------------------------------------------------------------
88 // helper structures and wxTimerScheduler
89 // ----------------------------------------------------------------------------
90
91 class wxTimerDesc
92 {
93 public:
94 wxTimerDesc(wxTimer *t) :
95 timer(t), running(false), next(NULL), prev(NULL),
96 shotTime(0), deleteFlag(NULL) {}
97
98 wxTimer *timer;
99 bool running;
100 wxTimerDesc *next, *prev;
101 wxTimerTick_t shotTime;
102 volatile bool *deleteFlag; // see comment in ~wxTimer
103 };
104
105 class wxTimerScheduler
106 {
107 public:
108 wxTimerScheduler() : m_timers(NULL) {}
109
110 void QueueTimer(wxTimerDesc *desc, wxTimerTick_t when = 0);
111 void RemoveTimer(wxTimerDesc *desc);
112 void NotifyTimers();
113
114 private:
115 wxTimerDesc *m_timers;
116 };
117
118 void wxTimerScheduler::QueueTimer(wxTimerDesc *desc, wxTimerTick_t when)
119 {
120 if ( desc->running )
121 return; // already scheduled
122
123 if ( when == 0 )
124 when = GetMillisecondsTime() + desc->timer->GetInterval();
125 desc->shotTime = when;
126 desc->running = true;
127
128 wxLogTrace( wxT("timer"),
129 wxT("queued timer %p at tick %") wxTimerTickFmtSpec,
130 desc->timer, wxTimerTickPrintfArg(when));
131
132 if ( m_timers )
133 {
134 wxTimerDesc *d = m_timers;
135 while ( d->next && d->next->shotTime < when ) d = d->next;
136 desc->next = d->next;
137 desc->prev = d;
138 if ( d->next )
139 d->next->prev = desc;
140 d->next = desc;
141 }
142 else
143 {
144 m_timers = desc;
145 desc->prev = desc->next = NULL;
146 }
147 }
148
149 void wxTimerScheduler::RemoveTimer(wxTimerDesc *desc)
150 {
151 desc->running = false;
152 if ( desc == m_timers )
153 m_timers = desc->next;
154 if ( desc->prev )
155 desc->prev->next = desc->next;
156 if ( desc->next )
157 desc->next->prev = desc->prev;
158 desc->prev = desc->next = NULL;
159 }
160
161 void wxTimerScheduler::NotifyTimers()
162 {
163 if ( m_timers )
164 {
165 bool oneShot;
166 volatile bool timerDeleted;
167 wxTimerTick_t now = GetMillisecondsTime();
168
169 for ( wxTimerDesc *desc = m_timers; desc; desc = desc->next )
170 {
171 if ( desc->running && wxTickGreaterEqual(now, desc->shotTime) )
172 {
173 oneShot = desc->timer->IsOneShot();
174 RemoveTimer(desc);
175
176 timerDeleted = false;
177 desc->deleteFlag = &timerDeleted;
178 desc->timer->Notify();
179
180 if ( !timerDeleted )
181 {
182 wxLogTrace( wxT("timer"),
183 wxT("notified timer %p sheduled for %")
184 wxTimerTickFmtSpec,
185 desc->timer,
186 wxTimerTickPrintfArg(desc->shotTime) );
187
188 desc->deleteFlag = NULL;
189 if ( !oneShot )
190 QueueTimer(desc, now + desc->timer->GetInterval());
191 }
192 else
193 desc = m_timers;
194 }
195 }
196 }
197 }
198
199
200 // ----------------------------------------------------------------------------
201 // wxTimer
202 // ----------------------------------------------------------------------------
203
204 IMPLEMENT_ABSTRACT_CLASS(wxTimer, wxEvtHandler)
205
206 wxTimerScheduler *gs_scheduler = NULL;
207
208 void wxTimer::Init()
209 {
210 if ( !gs_scheduler )
211 gs_scheduler = new wxTimerScheduler;
212 m_desc = new wxTimerDesc(this);
213 }
214
215 wxTimer::~wxTimer()
216 {
217 wxLogTrace( wxT("timer"), wxT("destroying timer %p..."), this);
218 if ( IsRunning() )
219 Stop();
220
221 // NB: this is a hack: wxTimerScheduler must have some way of knowing
222 // that wxTimer object was deleted under its hands -- this may
223 // happen if somebody is really nasty and deletes the timer
224 // from wxTimer::Notify()
225 if ( m_desc->deleteFlag != NULL )
226 *m_desc->deleteFlag = true;
227
228 delete m_desc;
229 wxLogTrace( wxT("timer"), wxT(" ...done destroying timer %p..."), this);
230 }
231
232 bool wxTimer::IsRunning() const
233 {
234 return m_desc->running;
235 }
236
237 bool wxTimer::Start(int millisecs, bool oneShot)
238 {
239 wxLogTrace( wxT("timer"), wxT("started timer %p: %i ms, oneshot=%i"),
240 this, millisecs, oneShot);
241
242 if ( !wxTimerBase::Start(millisecs, oneShot) )
243 return false;
244
245 gs_scheduler->QueueTimer(m_desc);
246 return true;
247 }
248
249 void wxTimer::Stop()
250 {
251 if ( !m_desc->running ) return;
252
253 gs_scheduler->RemoveTimer(m_desc);
254 }
255
256 /*static*/ void wxTimer::NotifyTimers()
257 {
258 if ( gs_scheduler )
259 gs_scheduler->NotifyTimers();
260 }
261
262
263
264 // A module to deallocate memory properly:
265 class wxTimerModule: public wxModule
266 {
267 DECLARE_DYNAMIC_CLASS(wxTimerModule)
268 public:
269 wxTimerModule() {}
270 bool OnInit() { return true; }
271 void OnExit() { delete gs_scheduler; gs_scheduler = NULL; }
272 };
273
274 IMPLEMENT_DYNAMIC_CLASS(wxTimerModule, wxModule)
275
276
277 #endif //wxUSE_TIMER