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 #ifndef WX_PRECOMP
  26     #include "wx/log.h"
  27     #include "wx/module.h"
  28 #endif
  29
  30 #include "wx/apptrait.h"
  31 #include "wx/generic/private/timer.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 wxT("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 wxT("d")
  78         #define wxTimerTickPrintfArg(tt) (tt.GetValue())
  79     #else // using native wxLongLong
  80         #define wxTimerTickFmtSpec wxT("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(wxGenericTimerImpl *t) :
  98         timer(t), running(false), next(NULL), prev(NULL),
  99         shotTime(0), deleteFlag(NULL) {}
 100
 101     wxGenericTimerImpl  *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 wxTimerScheduler *gs_scheduler = NULL;
 212
 213 void wxGenericTimerImpl::Init()
 214 {
 215     if ( !gs_scheduler )
 216         gs_scheduler = new wxTimerScheduler;
 217     m_desc = new wxTimerDesc(this);
 218 }
 219
 220 wxGenericTimerImpl::~wxGenericTimerImpl()
 221 {
 222     wxLogTrace( wxT("timer"), wxT("destroying timer %p..."), this);
 223     if ( IsRunning() )
 224         Stop();
 225
 226     // NB: this is a hack: wxTimerScheduler must have some way of knowing
 227     //     that wxTimer object was deleted under its hands -- this may
 228     //     happen if somebody is really nasty and deletes the timer
 229     //     from wxTimer::Notify()
 230     if ( m_desc->deleteFlag != NULL )
 231         *m_desc->deleteFlag = true;
 232
 233     delete m_desc;
 234     wxLogTrace( wxT("timer"), wxT("    ...done destroying timer %p..."), this);
 235 }
 236
 237 bool wxGenericTimerImpl::IsRunning() const
 238 {
 239     return m_desc->running;
 240 }
 241
 242 bool wxGenericTimerImpl::Start(int millisecs, bool oneShot)
 243 {
 244     wxLogTrace( wxT("timer"), wxT("started timer %p: %i ms, oneshot=%i"),
 245                this, millisecs, oneShot);
 246
 247      if ( !wxTimerImpl::Start(millisecs, oneShot) )
 248          return false;
 249
 250     gs_scheduler->QueueTimer(m_desc);
 251     return true;
 252 }
 253
 254 void wxGenericTimerImpl::Stop()
 255 {
 256     if ( !m_desc->running ) return;
 257
 258     gs_scheduler->RemoveTimer(m_desc);
 259 }
 260
 261 /*static*/ void wxGenericTimerImpl::NotifyTimers()
 262 {
 263     if ( gs_scheduler )
 264         gs_scheduler->NotifyTimers();
 265 }
 266
 267
 268
 269 // A module to deallocate memory properly:
 270 class wxTimerModule: public wxModule
 271 {
 272 DECLARE_DYNAMIC_CLASS(wxTimerModule)
 273 public:
 274     wxTimerModule() {}
 275     bool OnInit() { return true; }
 276     void OnExit() { delete gs_scheduler; gs_scheduler = NULL; }
 277 };
 278
 279 IMPLEMENT_DYNAMIC_CLASS(wxTimerModule, wxModule)
 280
 281 // ----------------------------------------------------------------------------
 282 // wxGUIAppTraits
 283 // ----------------------------------------------------------------------------
 284
 285 wxTimerImpl *wxGUIAppTraits::CreateTimerImpl(wxTimer *timer)
 286 {
 287     return new wxGenericTimerImpl(timer);
 288 }
 289
 290
 291 #endif //wxUSE_TIMER