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