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