]> git.saurik.com Git - wxWidgets.git/blame_incremental - src/common/timercmn.cpp
fixed wxStrrchr(s, '\0') bug, added const and non const versions of wxStrchr, wxStrrc...
[wxWidgets.git] / src / common / timercmn.cpp
... / ...
CommitLineData
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
117wxTimerBase::~wxTimerBase()
118{
119 // this destructor is required for Darwin
120}
121
122void 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
132bool 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
160void wxStopWatch::Start(long t)
161{
162 m_t0 = wxGetLocalTimeMillis() - t;
163 m_pause = 0;
164}
165
166long wxStopWatch::GetElapsedTime() const
167{
168 return (wxGetLocalTimeMillis() - m_t0).GetLo();
169}
170
171long 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
184static wxLongLong wxStartTime = 0l;
185
186// starts the global timer
187void wxStartTimer()
188{
189 wxStartTime = wxGetLocalTimeMillis();
190}
191
192// Returns elapsed time in milliseconds
193long 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
211long 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
242long 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
294wxLongLong 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