src/generic/timer.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        mgl/timer.cpp
   3 // Purpose:     wxTimer implementation
   4 // Author:      Vaclav Slavik
   5 // Id:          $Id$
   6 // Copyright:   (c) Vaclav Slavik
   7 // Licence:     wxWindows licence
   8 /////////////////////////////////////////////////////////////////////////////
   9
  10 // For compilers that support precompilation, includes "wx.h".
  11 #include "wx/wxprec.h"
  12
  13 #ifdef __BORLANDC__
  14     #pragma hdrstop
  15 #endif
  16
  17 // ----------------------------------------------------------------------------
  18 // NB: when using generic wxTimer implementation in your port, you *must* call
  19 //     wxTimer::NotifyTimers() often enough. The ideal place for this
  20 //     is in wxEventLoop::Dispatch().
  21 // ----------------------------------------------------------------------------
  22
  23 #include "wx/timer.h"
  24
  25 #if wxUSE_TIMER
  26
  27 #include "wx/log.h"
  28 #include "wx/module.h"
  29
  30 // ----------------------------------------------------------------------------
  31 // Time input function
  32 // ----------------------------------------------------------------------------
  33
  34 #ifdef __WXMGL__
  35     // We take advantage of wxMGL's _EVT_getTicks because it is faster
  36     // (especially under MS-DOS!) and more precise than wxGetLocalTimeMillis
  37     // if we are unlucky and the latter combines information from two sources.
  38     #include "wx/mgl/private.h"
  39     extern "C" ulong _EVT_getTicks();
  40     #define GetMillisecondsTime _EVT_getTicks
  41
  42     typedef ulong wxTimerTick_t;
  43
  44     #define wxTimerTickFmtSpec _T("lu")
  45     #define wxTimerTickPrintfArg(tt) (tt)
  46
  47     #ifdef __DOS__
  48         // Under DOS the MGL timer has a 24hr period, so consider the 12 hours
  49         // before y to be 'less' and the the 12 hours after 'greater' modulo
  50         // 24 hours.
  51         inline bool wxTickGreaterEqual(wxTimerTick_t x, wxTimerTick_t y)
  52         {
  53             // _EVT_getTicks wraps at 1573040 * 55
  54             const wxTimerTick_t modulus = 1573040 * 55;
  55             return (2 * modulus + x - y) % modulus < modulus / 2;
  56         }
  57     #else
  58         // If wxTimerTick_t is 32-bits then it'll wrap in around 50 days. So
  59         // let the 25 days before y be 'less' and 25 days after be 'greater'.
  60         inline bool wxTickGreaterEqual(wxTimerTick_t x, wxTimerTick_t y)
  61         {
  62             // This code assumes wxTimerTick_t is an unsigned type.
  63             // Set half_modulus with top bit set and the rest zeros.
  64             const wxTimerTick_t half_modulus = ~((~(wxTimerTick_t)0) >> 1);
  65             return x - y < half_modulus;
  66         }
  67     #endif
  68 #else // !__WXMGL__
  69     #define GetMillisecondsTime wxGetLocalTimeMillis
  70
  71     typedef wxLongLong wxTimerTick_t;
  72
  73     #if wxUSE_LONGLONG_WX
  74         #define wxTimerTickFmtSpec wxLongLongFmtSpec _T("d")
  75         #define wxTimerTickPrintfArg(tt) (tt.GetValue())
  76     #else // using native wxLongLong
  77         #define wxTimerTickFmtSpec _T("s")
  78         #define wxTimerTickPrintfArg(tt) (tt.ToString().c_str())
  79     #endif // wx/native long long
  80
  81     inline bool wxTickGreaterEqual(wxTimerTick_t x, wxTimerTick_t y)
  82     {
  83         return x >= y;
  84     }
  85 #endif // __WXMGL__/!__WXMGL__
  86
  87 // ----------------------------------------------------------------------------
  88 // helper structures and wxTimerScheduler
  89 // ----------------------------------------------------------------------------
  90
  91 class wxTimerDesc
  92 {
  93 public:
  94     wxTimerDesc(wxTimer *t) :
  95         timer(t), running(false), next(NULL), prev(NULL),
  96         shotTime(0), deleteFlag(NULL) {}
  97
  98     wxTimer         *timer;
  99     bool             running;
 100     wxTimerDesc     *next, *prev;
 101     wxTimerTick_t    shotTime;
 102     volatile bool   *deleteFlag; // see comment in ~wxTimer
 103 };
 104
 105 class wxTimerScheduler
 106 {
 107 public:
 108     wxTimerScheduler() : m_timers(NULL) {}
 109
 110     void QueueTimer(wxTimerDesc *desc, wxTimerTick_t when = 0);
 111     void RemoveTimer(wxTimerDesc *desc);
 112     void NotifyTimers();
 113
 114 private:
 115     wxTimerDesc *m_timers;
 116 };
 117
 118 void wxTimerScheduler::QueueTimer(wxTimerDesc *desc, wxTimerTick_t when)
 119 {
 120     if ( desc->running )
 121         return; // already scheduled
 122
 123     if ( when == 0 )
 124         when = GetMillisecondsTime() + desc->timer->GetInterval();
 125     desc->shotTime = when;
 126     desc->running = true;
 127
 128     wxLogTrace( wxT("timer"),
 129                 wxT("queued timer %p at tick %") wxTimerTickFmtSpec,
 130                desc->timer,  wxTimerTickPrintfArg(when));
 131
 132     if ( m_timers )
 133     {
 134         wxTimerDesc *d = m_timers;
 135         while ( d->next && d->next->shotTime < when ) d = d->next;
 136         desc->next = d->next;
 137         desc->prev = d;
 138         if ( d->next )
 139             d->next->prev = desc;
 140         d->next = desc;
 141     }
 142     else
 143     {
 144         m_timers = desc;
 145         desc->prev = desc->next = NULL;
 146     }
 147 }
 148
 149 void wxTimerScheduler::RemoveTimer(wxTimerDesc *desc)
 150 {
 151     desc->running = false;
 152     if ( desc == m_timers )
 153         m_timers = desc->next;
 154     if ( desc->prev )
 155         desc->prev->next = desc->next;
 156     if ( desc->next )
 157         desc->next->prev = desc->prev;
 158     desc->prev = desc->next = NULL;
 159 }
 160
 161 void wxTimerScheduler::NotifyTimers()
 162 {
 163     if ( m_timers )
 164     {
 165         bool oneShot;
 166         volatile bool timerDeleted;
 167         wxTimerTick_t now = GetMillisecondsTime();
 168
 169         for ( wxTimerDesc *desc = m_timers; desc; desc = desc->next )
 170         {
 171             if ( desc->running && wxTickGreaterEqual(now, desc->shotTime) )
 172             {
 173                 oneShot = desc->timer->IsOneShot();
 174                 RemoveTimer(desc);
 175
 176                 timerDeleted = false;
 177                 desc->deleteFlag = &timerDeleted;
 178                 desc->timer->Notify();
 179
 180                 if ( !timerDeleted )
 181                 {
 182                     wxLogTrace( wxT("timer"),
 183                                 wxT("notified timer %p sheduled for %")
 184                                 wxTimerTickFmtSpec,
 185                                 desc->timer,
 186                                 wxTimerTickPrintfArg(desc->shotTime) );
 187
 188                     desc->deleteFlag = NULL;
 189                     if ( !oneShot )
 190                         QueueTimer(desc, now + desc->timer->GetInterval());
 191                 }
 192                 else
 193                     desc = m_timers;
 194             }
 195         }
 196     }
 197 }
 198
 199
 200 // ----------------------------------------------------------------------------
 201 // wxTimer
 202 // ----------------------------------------------------------------------------
 203
 204 IMPLEMENT_ABSTRACT_CLASS(wxTimer, wxEvtHandler)
 205
 206 wxTimerScheduler *gs_scheduler = NULL;
 207
 208 void wxTimer::Init()
 209 {
 210     if ( !gs_scheduler )
 211         gs_scheduler = new wxTimerScheduler;
 212     m_desc = new wxTimerDesc(this);
 213 }
 214
 215 wxTimer::~wxTimer()
 216 {
 217     wxLogTrace( wxT("timer"), wxT("destroying timer %p..."), this);
 218     if ( IsRunning() )
 219         Stop();
 220
 221     // NB: this is a hack: wxTimerScheduler must have some way of knowing
 222     //     that wxTimer object was deleted under its hands -- this may
 223     //     happen if somebody is really nasty and deletes the timer
 224     //     from wxTimer::Notify()
 225     if ( m_desc->deleteFlag != NULL )
 226         *m_desc->deleteFlag = true;
 227
 228     delete m_desc;
 229     wxLogTrace( wxT("timer"), wxT("    ...done destroying timer %p..."), this);
 230 }
 231
 232 bool wxTimer::IsRunning() const
 233 {
 234     return m_desc->running;
 235 }
 236
 237 bool wxTimer::Start(int millisecs, bool oneShot)
 238 {
 239     wxLogTrace( wxT("timer"), wxT("started timer %p: %i ms, oneshot=%i"),
 240                this, millisecs, oneShot);
 241
 242     if ( !wxTimerBase::Start(millisecs, oneShot) )
 243         return false;
 244
 245     gs_scheduler->QueueTimer(m_desc);
 246     return true;
 247 }
 248
 249 void wxTimer::Stop()
 250 {
 251     if ( !m_desc->running ) return;
 252
 253     gs_scheduler->RemoveTimer(m_desc);
 254 }
 255
 256 /*static*/ void wxTimer::NotifyTimers()
 257 {
 258     if ( gs_scheduler )
 259         gs_scheduler->NotifyTimers();
 260 }
 261
 262
 263
 264 // A module to deallocate memory properly:
 265 class wxTimerModule: public wxModule
 266 {
 267 DECLARE_DYNAMIC_CLASS(wxTimerModule)
 268 public:
 269     wxTimerModule() {}
 270     bool OnInit() { return true; }
 271     void OnExit() { delete gs_scheduler; gs_scheduler = NULL; }
 272 };
 273
 274 IMPLEMENT_DYNAMIC_CLASS(wxTimerModule, wxModule)
 275
 276
 277 #endif //wxUSE_TIMER