]>
Commit | Line | Data |
---|---|---|
1 | ///////////////////////////////////////////////////////////////////////////// | |
2 | // Name: common/timercmn.cpp | |
3 | // Purpose: Common timer implementation | |
4 | // Author: | |
5 | // Original version by Julian Smart | |
6 | // Vadim Zeitlin got rid of all ifdefs (11.12.99) | |
7 | // Sylvain Bougnoux added wxStopWatch class | |
8 | // Guillermo Rodriguez <guille@iies.es> rewrote from scratch (Dic/99) | |
9 | // Modified by: | |
10 | // Created: 04/01/98 | |
11 | // RCS-ID: $Id$ | |
12 | // Copyright: (c) Julian Smart and Markus Holzem | |
13 | // (c) 1999 Guillermo Rodriguez <guille@iies.es> | |
14 | // Licence: wxWindows license | |
15 | ///////////////////////////////////////////////////////////////////////////// | |
16 | ||
17 | // ============================================================================ | |
18 | // declarations | |
19 | // ============================================================================ | |
20 | ||
21 | // ---------------------------------------------------------------------------- | |
22 | // wxWin headers | |
23 | // ---------------------------------------------------------------------------- | |
24 | ||
25 | #ifdef __GNUG__ | |
26 | #pragma implementation "timerbase.h" | |
27 | #endif | |
28 | ||
29 | // For compilers that support precompilation, includes "wx.h". | |
30 | #include "wx/wxprec.h" | |
31 | ||
32 | #ifdef __BORLANDC__ | |
33 | #pragma hdrstop | |
34 | #endif | |
35 | ||
36 | #ifndef WX_PRECOMP | |
37 | #include "wx/intl.h" | |
38 | #include "wx/log.h" | |
39 | #endif | |
40 | ||
41 | #include "wx/timer.h" | |
42 | #include "wx/longlong.h" | |
43 | ||
44 | // ---------------------------------------------------------------------------- | |
45 | // System headers | |
46 | // ---------------------------------------------------------------------------- | |
47 | ||
48 | #if defined(__WIN32__) | |
49 | #include <windows.h> | |
50 | #endif | |
51 | ||
52 | #if defined(__WIN32__) && !defined(HAVE_FTIME) && !defined(__MWERKS__) | |
53 | #define HAVE_FTIME | |
54 | #endif | |
55 | ||
56 | #if defined(__VISAGECPP__) && !defined(HAVE_FTIME) | |
57 | #define HAVE_FTIME | |
58 | # if __IBMCPP__ >= 400 | |
59 | # define ftime(x) _ftime(x) | |
60 | # endif | |
61 | #endif | |
62 | ||
63 | #if defined(__MWERKS__) && defined(__WXMSW__) | |
64 | # undef HAVE_FTIME | |
65 | # undef HAVE_GETTIMEOFDAY | |
66 | #endif | |
67 | ||
68 | #include <time.h> | |
69 | #ifndef __WXMAC__ | |
70 | #include <sys/types.h> // for time_t | |
71 | #endif | |
72 | ||
73 | #if defined(HAVE_GETTIMEOFDAY) | |
74 | #include <sys/time.h> | |
75 | #include <unistd.h> | |
76 | #elif defined(HAVE_FTIME) | |
77 | #include <sys/timeb.h> | |
78 | #endif | |
79 | ||
80 | #ifdef __WXMAC__ | |
81 | #include <Timer.h> | |
82 | #include <DriverServices.h> | |
83 | #endif | |
84 | // ---------------------------------------------------------------------------- | |
85 | // wxWin macros | |
86 | // ---------------------------------------------------------------------------- | |
87 | ||
88 | #if wxUSE_GUI && wxUSE_TIMER | |
89 | IMPLEMENT_DYNAMIC_CLASS(wxTimerEvent, wxEvent) | |
90 | #endif // wxUSE_GUI | |
91 | ||
92 | // ---------------------------------------------------------------------------- | |
93 | // macros | |
94 | // ---------------------------------------------------------------------------- | |
95 | ||
96 | // on some really old systems gettimeofday() doesn't have the second argument, | |
97 | // define wxGetTimeOfDay() to hide this difference | |
98 | #ifdef HAVE_GETTIMEOFDAY | |
99 | #ifdef WX_GETTIMEOFDAY_NO_TZ | |
100 | struct timezone; | |
101 | #define wxGetTimeOfDay(tv, tz) gettimeofday(tv) | |
102 | #else | |
103 | #define wxGetTimeOfDay(tv, tz) gettimeofday((tv), (tz)) | |
104 | #endif | |
105 | #endif // HAVE_GETTIMEOFDAY | |
106 | ||
107 | // ============================================================================ | |
108 | // implementation | |
109 | // ============================================================================ | |
110 | ||
111 | // ---------------------------------------------------------------------------- | |
112 | // wxTimerBase | |
113 | // ---------------------------------------------------------------------------- | |
114 | ||
115 | #if wxUSE_GUI && wxUSE_TIMER | |
116 | ||
117 | wxTimerBase::~wxTimerBase() | |
118 | { | |
119 | // this destructor is required for Darwin | |
120 | } | |
121 | ||
122 | void wxTimerBase::Notify() | |
123 | { | |
124 | // the base class version generates an event if it has owner - which it | |
125 | // should because otherwise nobody can process timer events | |
126 | wxCHECK_RET( m_owner, _T("wxTimer::Notify() should be overridden.") ); | |
127 | ||
128 | wxTimerEvent event(m_idTimer, m_milli); | |
129 | (void)m_owner->ProcessEvent(event); | |
130 | } | |
131 | ||
132 | bool wxTimerBase::Start(int milliseconds, bool oneShot) | |
133 | { | |
134 | if ( IsRunning() ) | |
135 | { | |
136 | // not stopping the already running timer might work for some | |
137 | // platforms (no problems under MSW) but leads to mysterious crashes | |
138 | // on the others (GTK), so to be on the safe side do it here | |
139 | Stop(); | |
140 | } | |
141 | ||
142 | if ( milliseconds != -1 ) | |
143 | { | |
144 | m_milli = milliseconds; | |
145 | } | |
146 | ||
147 | m_oneShot = oneShot; | |
148 | ||
149 | return TRUE; | |
150 | } | |
151 | ||
152 | #endif // wxUSE_GUI | |
153 | ||
154 | // ---------------------------------------------------------------------------- | |
155 | // wxStopWatch | |
156 | // ---------------------------------------------------------------------------- | |
157 | ||
158 | #if wxUSE_LONGLONG | |
159 | ||
160 | void wxStopWatch::Start(long t) | |
161 | { | |
162 | m_t0 = wxGetLocalTimeMillis() - t; | |
163 | m_pause = 0; | |
164 | } | |
165 | ||
166 | long wxStopWatch::GetElapsedTime() const | |
167 | { | |
168 | return (wxGetLocalTimeMillis() - m_t0).GetLo(); | |
169 | } | |
170 | ||
171 | long wxStopWatch::Time() const | |
172 | { | |
173 | return m_pauseCount ? m_pause : GetElapsedTime(); | |
174 | } | |
175 | ||
176 | #endif // wxUSE_LONGLONG | |
177 | ||
178 | // ---------------------------------------------------------------------------- | |
179 | // old timer functions superceded by wxStopWatch | |
180 | // ---------------------------------------------------------------------------- | |
181 | ||
182 | #if wxUSE_LONGLONG | |
183 | ||
184 | static wxLongLong wxStartTime = 0l; | |
185 | ||
186 | // starts the global timer | |
187 | void wxStartTimer() | |
188 | { | |
189 | wxStartTime = wxGetLocalTimeMillis(); | |
190 | } | |
191 | ||
192 | // Returns elapsed time in milliseconds | |
193 | long wxGetElapsedTime(bool resetTimer) | |
194 | { | |
195 | wxLongLong oldTime = wxStartTime; | |
196 | wxLongLong newTime = wxGetLocalTimeMillis(); | |
197 | ||
198 | if ( resetTimer ) | |
199 | wxStartTime = newTime; | |
200 | ||
201 | return (newTime - oldTime).GetLo(); | |
202 | } | |
203 | ||
204 | #endif // wxUSE_LONGLONG | |
205 | ||
206 | // ---------------------------------------------------------------------------- | |
207 | // the functions to get the current time and timezone info | |
208 | // ---------------------------------------------------------------------------- | |
209 | ||
210 | // Get local time as seconds since 00:00:00, Jan 1st 1970 | |
211 | long wxGetLocalTime() | |
212 | { | |
213 | struct tm tm; | |
214 | time_t t0, t1; | |
215 | ||
216 | // This cannot be made static because mktime can overwrite it. | |
217 | // | |
218 | memset(&tm, 0, sizeof(tm)); | |
219 | tm.tm_year = 70; | |
220 | tm.tm_mon = 0; | |
221 | tm.tm_mday = 5; // not Jan 1st 1970 due to mktime 'feature' | |
222 | tm.tm_hour = 0; | |
223 | tm.tm_min = 0; | |
224 | tm.tm_sec = 0; | |
225 | tm.tm_isdst = -1; // let mktime guess | |
226 | ||
227 | // Note that mktime assumes that the struct tm contains local time. | |
228 | // | |
229 | t1 = time(&t1); // now | |
230 | t0 = mktime(&tm); // origin | |
231 | ||
232 | // Return the difference in seconds. | |
233 | // | |
234 | if (( t0 != (time_t)-1 ) && ( t1 != (time_t)-1 )) | |
235 | return (long)difftime(t1, t0) + (60 * 60 * 24 * 4); | |
236 | ||
237 | wxLogSysError(_("Failed to get the local system time")); | |
238 | return -1; | |
239 | } | |
240 | ||
241 | // Get UTC time as seconds since 00:00:00, Jan 1st 1970 | |
242 | long wxGetUTCTime() | |
243 | { | |
244 | struct tm tm; | |
245 | struct tm *ptm; | |
246 | time_t t0, t1; | |
247 | ||
248 | // This cannot be made static because mktime can overwrite it | |
249 | // | |
250 | memset(&tm, 0, sizeof(tm)); | |
251 | tm.tm_year = 70; | |
252 | tm.tm_mon = 0; | |
253 | tm.tm_mday = 5; // not Jan 1st 1970 due to mktime 'feature' | |
254 | tm.tm_hour = 0; | |
255 | tm.tm_min = 0; | |
256 | tm.tm_sec = 0; | |
257 | tm.tm_isdst = -1; // let mktime guess | |
258 | ||
259 | // Note that mktime assumes that the struct tm contains local time. | |
260 | // | |
261 | t1 = time(&t1); // now | |
262 | t0 = mktime(&tm); // origin in localtime | |
263 | ||
264 | if (( t0 != (time_t)-1 ) && ( t1 != (time_t)-1 )) | |
265 | { | |
266 | // To get t0 as GMT we convert to a struct tm with gmtime, | |
267 | // and then back again. | |
268 | // | |
269 | ptm = gmtime(&t0); | |
270 | ||
271 | if (ptm) | |
272 | { | |
273 | memcpy(&tm, ptm, sizeof(tm)); | |
274 | t0 = mktime(&tm); | |
275 | ||
276 | if (t0 != (time_t)-1 ) | |
277 | return (long)difftime(t1, t0) + (60 * 60 * 24 * 4); | |
278 | wxLogSysError(_("mktime() failed")); | |
279 | } | |
280 | else | |
281 | { | |
282 | wxLogSysError(_("gmtime() failed")); | |
283 | } | |
284 | } | |
285 | ||
286 | wxLogError(_("Failed to get the UTC system time.")); | |
287 | ||
288 | return -1; | |
289 | } | |
290 | ||
291 | #if wxUSE_LONGLONG | |
292 | ||
293 | // Get local time as milliseconds since 00:00:00, Jan 1st 1970 | |
294 | wxLongLong wxGetLocalTimeMillis() | |
295 | { | |
296 | wxLongLong val = 1000l; | |
297 | ||
298 | // If possible, use a function which avoids conversions from | |
299 | // broken-up time structures to milliseconds | |
300 | ||
301 | #if defined(__WXMSW__) && defined(__MWERKS__) | |
302 | // This should probably be the way all WXMSW compilers should do it | |
303 | // Go direct to the OS for time | |
304 | ||
305 | SYSTEMTIME thenst = { 1970, 1, 4, 1, 0, 0, 0, 0 }; // 00:00:00 Jan 1st 1970 | |
306 | FILETIME thenft; | |
307 | SystemTimeToFileTime( &thenst, &thenft ); | |
308 | wxLongLong then( thenft.dwHighDateTime, thenft.dwLowDateTime ); // time in 100 nanoseconds | |
309 | ||
310 | SYSTEMTIME nowst; | |
311 | GetLocalTime( &nowst ); | |
312 | FILETIME nowft; | |
313 | SystemTimeToFileTime( &nowst, &nowft ); | |
314 | wxLongLong now( nowft.dwHighDateTime, nowft.dwLowDateTime ); // time in 100 nanoseconds | |
315 | ||
316 | return ( now - then ) / 10000.0; // time from 00:00:00 Jan 1st 1970 to now in milliseconds | |
317 | ||
318 | #elif defined(HAVE_GETTIMEOFDAY) | |
319 | struct timeval tp; | |
320 | if ( wxGetTimeOfDay(&tp, (struct timezone *)NULL) != -1 ) | |
321 | { | |
322 | val *= tp.tv_sec; | |
323 | return (val + (tp.tv_usec / 1000)); | |
324 | } | |
325 | else | |
326 | { | |
327 | wxLogError(_("wxGetTimeOfDay failed.")); | |
328 | return 0; | |
329 | } | |
330 | #elif defined(HAVE_FTIME) | |
331 | struct timeb tp; | |
332 | ||
333 | // ftime() is void and not int in some mingw32 headers, so don't | |
334 | // test the return code (well, it shouldn't fail anyhow...) | |
335 | (void)ftime(&tp); | |
336 | val *= tp.time; | |
337 | return (val + tp.millitm); | |
338 | #elif defined(__WXMAC__) | |
339 | ||
340 | unsigned long secs ; | |
341 | UInt64 gMilliAtStart = 0 ; | |
342 | Nanoseconds upTime = AbsoluteToNanoseconds( UpTime() ) ; | |
343 | if ( gMilliAtStart == 0 ) | |
344 | { | |
345 | time_t start = time(NULL) ; | |
346 | gMilliAtStart = ((UInt64) start) * 1000L ; | |
347 | gMilliAtStart -= upTime.lo / 1000 ; | |
348 | gMilliAtStart -= ( ( (UInt64) upTime.hi ) << 32 ) / 1000 ; | |
349 | } | |
350 | UInt64 millival = gMilliAtStart ; | |
351 | millival += upTime.lo / 1000 ; | |
352 | millival += ( ( (UInt64) upTime.hi ) << 32 ) / 1000 ; | |
353 | return millival ; | |
354 | #else // no gettimeofday() nor ftime() | |
355 | // We use wxGetLocalTime() to get the seconds since | |
356 | // 00:00:00 Jan 1st 1970 and then whatever is available | |
357 | // to get millisecond resolution. | |
358 | // | |
359 | // NOTE that this might lead to a problem if the clocks | |
360 | // use different sources, so this approach should be | |
361 | // avoided where possible. | |
362 | ||
363 | val *= wxGetLocalTime(); | |
364 | ||
365 | // GRG: This will go soon as all WIN32 seem to have ftime | |
366 | #if defined (__WIN32__) | |
367 | // If your platform/compiler needs to use two different functions | |
368 | // to get ms resolution, please do NOT just shut off these warnings, | |
369 | // drop me a line instead at <guille@iies.es> | |
370 | #warning "Possible clock skew bug in wxGetLocalTimeMillis()!" | |
371 | ||
372 | SYSTEMTIME st; | |
373 | ::GetLocalTime(&st); | |
374 | val += st.wMilliseconds; | |
375 | #else // !Win32 | |
376 | // If your platform/compiler does not support ms resolution please | |
377 | // do NOT just shut off these warnings, drop me a line instead at | |
378 | // <guille@iies.es> | |
379 | ||
380 | #if defined(__VISUALC__) || defined (__WATCOMC__) | |
381 | #pragma message("wxStopWatch will be up to second resolution!") | |
382 | #elif defined(__BORLANDC__) | |
383 | #pragma message "wxStopWatch will be up to second resolution!" | |
384 | #else | |
385 | #warning "wxStopWatch will be up to second resolution!" | |
386 | #endif // compiler | |
387 | #endif | |
388 | ||
389 | return val; | |
390 | ||
391 | #endif // time functions | |
392 | } | |
393 | ||
394 | #endif // wxUSE_LONGLONG | |
395 |