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