src/generic/timer.cpp

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