]> git.saurik.com Git - wxWidgets.git/blob - src/common/stopwatch.cpp
fix bug compiling with DMC Borland gcc (macos); reverting part of 1.09 to 1.10
[wxWidgets.git] / src / common / stopwatch.cpp
1 ///////////////////////////////////////////////////////////////////////////////
2 // Name: common/stopwatch.cpp
3 // Purpose: wxStopWatch and other non-GUI stuff from wx/timer.h
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: 20.06.2003 (extracted from common/timercmn.cpp)
11 // RCS-ID: $Id$
12 // Copyright: (c) 1998-2003 wxWindows Team
13 // License: wxWindows license
14 ///////////////////////////////////////////////////////////////////////////////
15
16 // ============================================================================
17 // declarations
18 // ============================================================================
19
20 // ----------------------------------------------------------------------------
21 // headers
22 // ----------------------------------------------------------------------------
23
24 // for compilers that support precompilation, includes "wx.h".
25 #include "wx/wxprec.h"
26
27 #ifdef __BORLANDC__
28 #pragma hdrstop
29 #endif
30
31 #ifndef WX_PRECOMP
32 #include "wx/intl.h"
33 #include "wx/log.h"
34 #endif //WX_PRECOMP
35
36 #include "wx/longlong.h"
37 #include "wx/stopwatch.h"
38
39 // ----------------------------------------------------------------------------
40 // System headers
41 // ----------------------------------------------------------------------------
42
43 #if defined(__WIN32__)
44 #include "wx/msw/wrapwin.h"
45 #endif
46
47 #if defined(__WIN32__) && !defined(HAVE_FTIME) && !defined(__MWERKS__) && !defined(__WXWINCE__)
48 #define HAVE_FTIME
49 #endif
50
51 #if defined(__VISAGECPP__) && !defined(HAVE_FTIME)
52 #define HAVE_FTIME
53 # if __IBMCPP__ >= 400
54 # define ftime(x) _ftime(x)
55 # endif
56 #endif
57
58 #if defined(__MWERKS__) && defined(__WXMSW__)
59 # undef HAVE_FTIME
60 # undef HAVE_GETTIMEOFDAY
61 #endif
62
63 #ifndef __WXWINCE__
64 #include <time.h>
65 #else
66 #include "wx/msw/private.h"
67 #include "wx/msw/wince/time.h"
68 #endif
69
70 #if !defined(__WXMAC__) && !defined(__WXWINCE__)
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 // ----------------------------------------------------------------------------
87 // macros
88 // ----------------------------------------------------------------------------
89
90 // on some really old systems gettimeofday() doesn't have the second argument,
91 // define wxGetTimeOfDay() to hide this difference
92 #ifdef HAVE_GETTIMEOFDAY
93 #ifdef WX_GETTIMEOFDAY_NO_TZ
94 struct timezone;
95 #define wxGetTimeOfDay(tv, tz) gettimeofday(tv)
96 #else
97 #define wxGetTimeOfDay(tv, tz) gettimeofday((tv), (tz))
98 #endif
99 #endif // HAVE_GETTIMEOFDAY
100
101 // ============================================================================
102 // implementation
103 // ============================================================================
104
105 // ----------------------------------------------------------------------------
106 // wxStopWatch
107 // ----------------------------------------------------------------------------
108
109 #if wxUSE_STOPWATCH
110
111 void wxStopWatch::Start(long t)
112 {
113 m_t0 = wxGetLocalTimeMillis() - t;
114 m_pause = 0;
115 m_pauseCount = 0;
116 }
117
118 long wxStopWatch::GetElapsedTime() const
119 {
120 return (wxGetLocalTimeMillis() - m_t0).GetLo();
121 }
122
123 long wxStopWatch::Time() const
124 {
125 return m_pauseCount ? m_pause : GetElapsedTime();
126 }
127
128 #endif // wxUSE_STOPWATCH
129
130 // ----------------------------------------------------------------------------
131 // old timer functions superceded by wxStopWatch
132 // ----------------------------------------------------------------------------
133
134 #if wxUSE_LONGLONG
135
136 static wxLongLong wxStartTime = 0l;
137
138 // starts the global timer
139 void wxStartTimer()
140 {
141 wxStartTime = wxGetLocalTimeMillis();
142 }
143
144 // Returns elapsed time in milliseconds
145 long wxGetElapsedTime(bool resetTimer)
146 {
147 wxLongLong oldTime = wxStartTime;
148 wxLongLong newTime = wxGetLocalTimeMillis();
149
150 if ( resetTimer )
151 wxStartTime = newTime;
152
153 return (newTime - oldTime).GetLo();
154 }
155
156 #endif // wxUSE_LONGLONG
157
158 // ----------------------------------------------------------------------------
159 // the functions to get the current time and timezone info
160 // ----------------------------------------------------------------------------
161
162 // Get local time as seconds since 00:00:00, Jan 1st 1970
163 long wxGetLocalTime()
164 {
165 struct tm tm;
166 time_t t0, t1;
167
168 // This cannot be made static because mktime can overwrite it.
169 //
170 memset(&tm, 0, sizeof(tm));
171 tm.tm_year = 70;
172 tm.tm_mon = 0;
173 tm.tm_mday = 5; // not Jan 1st 1970 due to mktime 'feature'
174 tm.tm_hour = 0;
175 tm.tm_min = 0;
176 tm.tm_sec = 0;
177 tm.tm_isdst = -1; // let mktime guess
178
179 // Note that mktime assumes that the struct tm contains local time.
180 //
181 t1 = time(&t1); // now
182 t0 = mktime(&tm); // origin
183
184 // Return the difference in seconds.
185 //
186 if (( t0 != (time_t)-1 ) && ( t1 != (time_t)-1 ))
187 return (long)difftime(t1, t0) + (60 * 60 * 24 * 4);
188
189 wxLogSysError(_("Failed to get the local system time"));
190 return -1;
191 }
192
193 // Get UTC time as seconds since 00:00:00, Jan 1st 1970
194 long wxGetUTCTime()
195 {
196 long timenow = 0;
197 time(&timenow);
198 return timenow;
199 }
200
201 #if wxUSE_LONGLONG
202
203 // Get local time as milliseconds since 00:00:00, Jan 1st 1970
204 wxLongLong wxGetLocalTimeMillis()
205 {
206 wxLongLong val = 1000l;
207
208 // If possible, use a function which avoids conversions from
209 // broken-up time structures to milliseconds
210
211 #if defined(__WXMSW__) && (defined(__WINE__) || defined(__MWERKS__))
212 // This should probably be the way all WXMSW compilers should do it
213 // Go direct to the OS for time
214
215 SYSTEMTIME thenst = { 1970, 1, 4, 1, 0, 0, 0, 0 }; // 00:00:00 Jan 1st 1970
216 FILETIME thenft;
217 SystemTimeToFileTime( &thenst, &thenft );
218 wxLongLong then( thenft.dwHighDateTime, thenft.dwLowDateTime ); // time in 100 nanoseconds
219
220 SYSTEMTIME nowst;
221 GetLocalTime( &nowst );
222 FILETIME nowft;
223 SystemTimeToFileTime( &nowst, &nowft );
224 wxLongLong now( nowft.dwHighDateTime, nowft.dwLowDateTime ); // time in 100 nanoseconds
225
226 return ( now - then ) / 10000.0; // time from 00:00:00 Jan 1st 1970 to now in milliseconds
227
228 #elif defined(HAVE_GETTIMEOFDAY)
229 struct timeval tp;
230 if ( wxGetTimeOfDay(&tp, (struct timezone *)NULL) != -1 )
231 {
232 val *= tp.tv_sec;
233 return (val + (tp.tv_usec / 1000));
234 }
235 else
236 {
237 wxLogError(_("wxGetTimeOfDay failed."));
238 return 0;
239 }
240 #elif defined(HAVE_FTIME)
241 struct timeb tp;
242
243 // ftime() is void and not int in some mingw32 headers, so don't
244 // test the return code (well, it shouldn't fail anyhow...)
245 (void)ftime(&tp);
246 val *= tp.time;
247 return (val + tp.millitm);
248 #elif defined(__WXMAC__)
249
250 static UInt64 gMilliAtStart = 0;
251
252 Nanoseconds upTime = AbsoluteToNanoseconds( UpTime() );
253
254 if ( gMilliAtStart == 0 )
255 {
256 time_t start = time(NULL);
257 gMilliAtStart = ((UInt64) start) * 1000000L;
258 gMilliAtStart -= upTime.lo / 1000 ;
259 gMilliAtStart -= ( ( (UInt64) upTime.hi ) << 32 ) / (1000 * 1000);
260 }
261
262 UInt64 millival = gMilliAtStart;
263 millival += upTime.lo / (1000 * 1000);
264 millival += ( ( (UInt64) upTime.hi ) << 32 ) / (1000 * 1000);
265 val = millival;
266
267 return val;
268 #else // no gettimeofday() nor ftime()
269 // We use wxGetLocalTime() to get the seconds since
270 // 00:00:00 Jan 1st 1970 and then whatever is available
271 // to get millisecond resolution.
272 //
273 // NOTE that this might lead to a problem if the clocks
274 // use different sources, so this approach should be
275 // avoided where possible.
276
277 val *= wxGetLocalTime();
278
279 // GRG: This will go soon as all WIN32 seem to have ftime
280 // JACS: unfortunately not. WinCE doesn't have it.
281 #if defined (__WIN32__)
282 // If your platform/compiler needs to use two different functions
283 // to get ms resolution, please do NOT just shut off these warnings,
284 // drop me a line instead at <guille@iies.es>
285
286 // FIXME
287 #ifndef __WXWINCE__
288 #warning "Possible clock skew bug in wxGetLocalTimeMillis()!"
289 #endif
290
291 SYSTEMTIME st;
292 ::GetLocalTime(&st);
293 val += st.wMilliseconds;
294 #else // !Win32
295 // If your platform/compiler does not support ms resolution please
296 // do NOT just shut off these warnings, drop me a line instead at
297 // <guille@iies.es>
298
299 #if defined(__VISUALC__) || defined (__WATCOMC__)
300 #pragma message("wxStopWatch will be up to second resolution!")
301 #elif defined(__BORLANDC__)
302 #pragma message "wxStopWatch will be up to second resolution!"
303 #else
304 #warning "wxStopWatch will be up to second resolution!"
305 #endif // compiler
306 #endif
307
308 return val;
309
310 #endif // time functions
311 }
312
313 #endif // wxUSE_LONGLONG
314
315