src/generic/timer.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        mgl/timer.cpp
   3 // Purpose:     wxTimer implementation
   4 // Author:      Vaclav Slavik
   5 // Id:          $Id$
   6 // Copyright:   (c) 2001-2002 SciTech Software, Inc. (www.scitechsoft.com)
   7 // Licence:     wxWindows licence
   8 /////////////////////////////////////////////////////////////////////////////
   9
  10 #ifdef __GNUG__
  11 #pragma implementation "timer.h"
  12 #endif
  13
  14 // For compilers that support precompilation, includes "wx.h".
  15 #include "wx/wxprec.h"
  16
  17 #ifdef __BORLANDC__
  18     #pragma hdrstop
  19 #endif
  20
  21 // ----------------------------------------------------------------------------
  22 // NB: when using generic wxTimer implementation in your port, you *must* call
  23 //     wxTimer::NotifyTimers() often enough. The ideal place for this
  24 //     is in wxEventLoop::Dispatch().
  25 // ----------------------------------------------------------------------------
  26
  27 #include "wx/timer.h"
  28
  29 #if wxUSE_TIMER
  30
  31 #include "wx/log.h"
  32 #include "wx/module.h"
  33
  34 // ----------------------------------------------------------------------------
  35 // Time input function
  36 // ----------------------------------------------------------------------------
  37
  38 #ifdef __WXMGL__
  39     // We take advantage of wxMGL's _EVT_getTicks because it is faster
  40     // (especially under MS-DOS!) and more precise than wxGetLocalTimeMillis
  41     // if we are unlucky and the latter combines information from two sources.
  42     #include "wx/mgl/private.h"
  43     extern "C" ulong _EVT_getTicks();
  44     #define GetMillisecondsTime() _EVT_getTicks()
  45 #else
  46 //    #define GetMillisecondsTime() wxGetLocalTimeMillis().ToLong()
  47     // Suppresses the debug warning in ToLong. FIXME: check
  48     // that we don't drastically lose precision
  49     #define GetMillisecondsTime() (unsigned long) wxGetLocalTimeMillis().GetValue()
  50 #endif
  51
  52 // ----------------------------------------------------------------------------
  53 // helper structures and wxTimerScheduler
  54 // ----------------------------------------------------------------------------
  55
  56 class wxTimerDesc
  57 {
  58 public:
  59     wxTimerDesc(wxTimer *t) :
  60         timer(t), running(FALSE), next(NULL), prev(NULL),
  61         shotTime(0), deleteFlag(NULL) {}
  62
  63     wxTimer         *timer;
  64     bool             running;
  65     wxTimerDesc     *next, *prev;
  66     unsigned long    shotTime;
  67     volatile bool   *deleteFlag; // see comment in ~wxTimer
  68 };
  69
  70 class wxTimerScheduler
  71 {
  72 public:
  73     wxTimerScheduler() : m_timers(NULL) {}
  74
  75     void QueueTimer(wxTimerDesc *desc, unsigned long when = 0);
  76     void RemoveTimer(wxTimerDesc *desc);
  77     void NotifyTimers();
  78
  79 private:
  80     wxTimerDesc *m_timers;
  81 };
  82
  83 void wxTimerScheduler::QueueTimer(wxTimerDesc *desc, unsigned long when)
  84 {
  85     if ( desc->running )
  86         return; // already scheduled
  87
  88     if ( when == 0 )
  89         when = GetMillisecondsTime() + desc->timer->GetInterval();
  90     desc->shotTime = when;
  91     desc->running = TRUE;
  92
  93     wxLogTrace("timer", "queued timer %p at tick %i",
  94                desc->timer, when);
  95
  96     if ( m_timers )
  97     {
  98         wxTimerDesc *d = m_timers;
  99         while ( d->next && d->next->shotTime < when ) d = d->next;
 100         desc->next = d->next;
 101         desc->prev = d;
 102         if ( d->next )
 103             d->next->prev = desc;
 104         d->next = desc;
 105     }
 106     else
 107     {
 108         m_timers = desc;
 109         desc->prev = desc->next = NULL;
 110     }
 111 }
 112
 113 void wxTimerScheduler::RemoveTimer(wxTimerDesc *desc)
 114 {
 115     desc->running = FALSE;
 116     if ( desc == m_timers )
 117         m_timers = desc->next;
 118     if ( desc->prev )
 119         desc->prev->next = desc->next;
 120     if ( desc->next )
 121         desc->next->prev = desc->prev;
 122     desc->prev = desc->next = NULL;
 123 }
 124
 125 void wxTimerScheduler::NotifyTimers()
 126 {
 127     if ( m_timers )
 128     {
 129         bool oneShot;
 130         volatile bool timerDeleted;
 131         unsigned long now = GetMillisecondsTime();
 132         wxTimerDesc *desc;
 133
 134         while ( m_timers && m_timers->shotTime <= now )
 135         {
 136             desc = m_timers;
 137             oneShot = desc->timer->IsOneShot();
 138             RemoveTimer(desc);
 139
 140             timerDeleted = FALSE;
 141             desc->deleteFlag = &timerDeleted;
 142             desc->timer->Notify();
 143
 144             if ( !timerDeleted )
 145             {
 146                 wxLogTrace("timer", "notified timer %p sheduled for %i",
 147                            desc->timer, desc->shotTime);
 148
 149                 desc->deleteFlag = NULL;
 150                 if ( !oneShot )
 151                     QueueTimer(desc, now + desc->timer->GetInterval());
 152             }
 153         }
 154     }
 155 }
 156
 157
 158 // ----------------------------------------------------------------------------
 159 // wxTimer
 160 // ----------------------------------------------------------------------------
 161
 162 IMPLEMENT_ABSTRACT_CLASS(wxTimer,wxObject)
 163
 164 wxTimerScheduler *gs_scheduler = NULL;
 165
 166 void wxTimer::Init()
 167 {
 168     if ( !gs_scheduler )
 169         gs_scheduler = new wxTimerScheduler;
 170     m_desc = new wxTimerDesc(this);
 171 }
 172
 173 wxTimer::~wxTimer()
 174 {
 175     wxLogTrace("timer", "destroying timer %p...", this);
 176     if ( IsRunning() )
 177         Stop();
 178
 179     // NB: this is a hack: wxTimerScheduler must have some way of knowing
 180     //     that wxTimer object was deleted under its hands -- this may
 181     //     happen if somebody is really nasty and deletes the timer
 182     //     from wxTimer::Notify()
 183     if ( m_desc->deleteFlag != NULL )
 184         *m_desc->deleteFlag = TRUE;
 185
 186     delete m_desc;
 187     wxLogTrace("timer", "    ...done destroying timer %p...", this);
 188 }
 189
 190 bool wxTimer::IsRunning() const
 191 {
 192     return m_desc->running;
 193 }
 194
 195 bool wxTimer::Start(int millisecs, bool oneShot)
 196 {
 197     wxLogTrace("timer", "started timer %p: %i ms, oneshot=%i",
 198                this, millisecs, oneShot);
 199
 200     if ( !wxTimerBase::Start(millisecs, oneShot) )
 201         return FALSE;
 202
 203     gs_scheduler->QueueTimer(m_desc);
 204     return TRUE;
 205 }
 206
 207 void wxTimer::Stop()
 208 {
 209     if ( !m_desc->running ) return;
 210
 211     gs_scheduler->RemoveTimer(m_desc);
 212 }
 213
 214 /*static*/ void wxTimer::NotifyTimers()
 215 {
 216     if ( gs_scheduler )
 217         gs_scheduler->NotifyTimers();
 218 }
 219
 220
 221
 222 // A module to deallocate memory properly:
 223 class wxTimerModule: public wxModule
 224 {
 225 DECLARE_DYNAMIC_CLASS(wxTimerModule)
 226 public:
 227     wxTimerModule() {}
 228     bool OnInit() { return TRUE; }
 229     void OnExit() { delete gs_scheduler; gs_scheduler = NULL; }
 230 };
 231
 232 IMPLEMENT_DYNAMIC_CLASS(wxTimerModule, wxModule)
 233
 234
 235 #endif //wxUSE_TIMER