]> git.saurik.com Git - wxWidgets.git/blame_incremental - src/common/timercmn.cpp
Tex2RTF: underscores now only checked for if syntax checking is on.
[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)
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#include <time.h>
64#ifndef __WXMAC__
65 #include <sys/types.h> // for time_t
66#endif
67
68#if defined(HAVE_GETTIMEOFDAY)
69 #include <sys/time.h>
70 #include <unistd.h>
71#elif defined(HAVE_FTIME)
72 #include <sys/timeb.h>
73#endif
74
75// ----------------------------------------------------------------------------
76// wxWin macros
77// ----------------------------------------------------------------------------
78
79#if wxUSE_GUI
80 IMPLEMENT_DYNAMIC_CLASS(wxTimerEvent, wxEvent)
81#endif // wxUSE_GUI
82
83// ----------------------------------------------------------------------------
84// macros
85// ----------------------------------------------------------------------------
86
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
97
98// ============================================================================
99// implementation
100// ============================================================================
101
102// ----------------------------------------------------------------------------
103// wxTimerBase
104// ----------------------------------------------------------------------------
105
106#if wxUSE_GUI
107
108void 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}
117
118bool 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
138#endif // wxUSE_GUI
139
140// ----------------------------------------------------------------------------
141// wxStopWatch
142// ----------------------------------------------------------------------------
143
144void wxStopWatch::Start(long t)
145{
146 m_t0 = wxGetLocalTimeMillis() - t;
147 m_pause = 0;
148}
149
150long wxStopWatch::GetElapsedTime() const
151{
152 return (wxGetLocalTimeMillis() - m_t0).GetLo();
153}
154
155long wxStopWatch::Time() const
156{
157 return (m_pause ? m_pause : GetElapsedTime());
158}
159
160// ----------------------------------------------------------------------------
161// old timer functions superceded by wxStopWatch
162// ----------------------------------------------------------------------------
163
164static wxLongLong wxStartTime = 0l;
165
166// starts the global timer
167void wxStartTimer()
168{
169 wxStartTime = wxGetLocalTimeMillis();
170}
171
172// Returns elapsed time in milliseconds
173long wxGetElapsedTime(bool resetTimer)
174{
175 wxLongLong oldTime = wxStartTime;
176 wxLongLong newTime = wxGetLocalTimeMillis();
177
178 if ( resetTimer )
179 wxStartTime = newTime;
180
181 return (newTime - oldTime).GetLo();
182}
183
184
185// ----------------------------------------------------------------------------
186// the functions to get the current time and timezone info
187// ----------------------------------------------------------------------------
188
189// Get local time as seconds since 00:00:00, Jan 1st 1970
190long wxGetLocalTime()
191{
192 struct tm tm;
193 time_t t0, t1;
194
195 // This cannot be made static because mktime can overwrite it.
196 //
197 memset(&tm, 0, sizeof(tm));
198 tm.tm_year = 70;
199 tm.tm_mon = 0;
200 tm.tm_mday = 5; // not Jan 1st 1970 due to mktime 'feature'
201 tm.tm_hour = 0;
202 tm.tm_min = 0;
203 tm.tm_sec = 0;
204 tm.tm_isdst = -1; // let mktime guess
205
206 // Note that mktime assumes that the struct tm contains local time.
207 //
208 t1 = time(&t1); // now
209 t0 = mktime(&tm); // origin
210
211 // Return the difference in seconds.
212 //
213 if (( t0 != (time_t)-1 ) && ( t1 != (time_t)-1 ))
214 return (long)difftime(t1, t0) + (60 * 60 * 24 * 4);
215
216 wxLogSysError(_("Failed to get the local system time"));
217 return -1;
218}
219
220// Get UTC time as seconds since 00:00:00, Jan 1st 1970
221long wxGetUTCTime()
222{
223 struct tm tm;
224 struct tm *ptm;
225 time_t t0, t1;
226
227 // This cannot be made static because mktime can overwrite it
228 //
229 memset(&tm, 0, sizeof(tm));
230 tm.tm_year = 70;
231 tm.tm_mon = 0;
232 tm.tm_mday = 5; // not Jan 1st 1970 due to mktime 'feature'
233 tm.tm_hour = 0;
234 tm.tm_min = 0;
235 tm.tm_sec = 0;
236 tm.tm_isdst = -1; // let mktime guess
237
238 // Note that mktime assumes that the struct tm contains local time.
239 //
240 t1 = time(&t1); // now
241 t0 = mktime(&tm); // origin in localtime
242
243 if (( t0 != (time_t)-1 ) && ( t1 != (time_t)-1 ))
244 {
245 // To get t0 as GMT we convert to a struct tm with gmtime,
246 // and then back again.
247 //
248 ptm = gmtime(&t0);
249
250 if (ptm)
251 {
252 memcpy(&tm, ptm, sizeof(tm));
253 t0 = mktime(&tm);
254
255 if (t0 != (time_t)-1 )
256 return (long)difftime(t1, t0) + (60 * 60 * 24 * 4);
257 wxLogSysError(_("mktime() failed"));
258 }
259 else
260 {
261 wxLogSysError(_("gmtime() failed"));
262 }
263 }
264
265 wxLogError(_("Failed to get the UTC system time."));
266
267 return -1;
268}
269
270
271// Get local time as milliseconds since 00:00:00, Jan 1st 1970
272wxLongLong wxGetLocalTimeMillis()
273{
274 wxLongLong val = 1000l;
275
276 // If possible, use a function which avoids conversions from
277 // broken-up time structures to milliseconds
278
279#if defined(HAVE_GETTIMEOFDAY)
280 struct timeval tp;
281 if ( wxGetTimeOfDay(&tp, (struct timezone *)NULL) != -1 )
282 {
283 val *= tp.tv_sec;
284 return (val + (tp.tv_usec / 1000));
285 }
286 else
287 {
288 wxLogError(_("wxGetTimeOfDay failed."));
289 return 0;
290 }
291#elif defined(HAVE_FTIME)
292 struct timeb tp;
293
294 // ftime() is void and not int in some mingw32 headers, so don't
295 // test the return code (well, it shouldn't fail anyhow...)
296 (void)ftime(&tp);
297 val *= tp.time;
298 return (val + tp.millitm);
299#else // no gettimeofday() nor ftime()
300 // We use wxGetLocalTime() to get the seconds since
301 // 00:00:00 Jan 1st 1970 and then whatever is available
302 // to get millisecond resolution.
303 //
304 // NOTE that this might lead to a problem if the clocks
305 // use different sources, so this approach should be
306 // avoided where possible.
307
308 val *= wxGetLocalTime();
309
310// GRG: This will go soon as all WIN32 seem to have ftime
311#if defined (__WIN32__)
312 // If your platform/compiler needs to use two different functions
313 // to get ms resolution, please do NOT just shut off these warnings,
314 // drop me a line instead at <guille@iies.es>
315 #warning "Possible clock skew bug in wxGetLocalTimeMillis()!"
316
317 SYSTEMTIME st;
318 ::GetLocalTime(&st);
319 val += st.wMilliseconds;
320#else // !Win32
321 // If your platform/compiler does not support ms resolution please
322 // do NOT just shut off these warnings, drop me a line instead at
323 // <guille@iies.es>
324
325 #if defined(__VISUALC__)
326 #pragma message("wxStopWatch will be up to second resolution!")
327 #elif defined(__BORLANDC__)
328 #pragma message "wxStopWatch will be up to second resolution!"
329 #else
330 #warning "wxStopWatch will be up to second resolution!"
331 #endif // compiler
332#endif
333
334 return val;
335
336#endif // time functions
337}