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 #endif
  48
  49 // ----------------------------------------------------------------------------
  50 // helper structures and wxTimerScheduler
  51 // ----------------------------------------------------------------------------
  52
  53 class wxTimerDesc
  54 {
  55 public:
  56     wxTimerDesc(wxTimer *t) :
  57         timer(t), running(FALSE), next(NULL), prev(NULL),
  58         shotTime(0), deleteFlag(NULL) {}
  59
  60     wxTimer         *timer;
  61     bool             running;
  62     wxTimerDesc     *next, *prev;
  63     unsigned long    shotTime;
  64     volatile bool   *deleteFlag; // see comment in ~wxTimer
  65 };
  66
  67 class wxTimerScheduler
  68 {
  69 public:
  70     wxTimerScheduler() : m_timers(NULL) {}
  71
  72     void QueueTimer(wxTimerDesc *desc, unsigned long when = 0);
  73     void RemoveTimer(wxTimerDesc *desc);
  74     void NotifyTimers();
  75
  76 private:
  77     wxTimerDesc *m_timers;
  78 };
  79
  80 void wxTimerScheduler::QueueTimer(wxTimerDesc *desc, unsigned long when)
  81 {
  82     if ( desc->running )
  83         return; // already scheduled
  84
  85     if ( when == 0 )
  86         when = GetMillisecondsTime() + desc->timer->GetInterval();
  87     desc->shotTime = when;
  88     desc->running = TRUE;
  89
  90     wxLogTrace("timer", "queued timer %p at tick %i",
  91                desc->timer, when);
  92
  93     if ( m_timers )
  94     {
  95         wxTimerDesc *d = m_timers;
  96         while ( d->next && d->next->shotTime < when ) d = d->next;
  97         desc->next = d->next;
  98         desc->prev = d;
  99         if ( d->next )
 100             d->next->prev = desc;
 101         d->next = desc;
 102     }
 103     else
 104     {
 105         m_timers = desc;
 106         desc->prev = desc->next = NULL;
 107     }
 108 }
 109
 110 void wxTimerScheduler::RemoveTimer(wxTimerDesc *desc)
 111 {
 112     desc->running = FALSE;
 113     if ( desc == m_timers )
 114         m_timers = desc->next;
 115     if ( desc->prev )
 116         desc->prev->next = desc->next;
 117     if ( desc->next )
 118         desc->next->prev = desc->prev;
 119     desc->prev = desc->next = NULL;
 120 }
 121
 122 void wxTimerScheduler::NotifyTimers()
 123 {
 124     if ( m_timers )
 125     {
 126         bool oneShot;
 127         volatile bool timerDeleted;
 128         unsigned long now = GetMillisecondsTime();
 129         wxTimerDesc *desc;
 130
 131         while ( m_timers && m_timers->shotTime <= now )
 132         {
 133             desc = m_timers;
 134             oneShot = desc->timer->IsOneShot();
 135             RemoveTimer(desc);
 136
 137             timerDeleted = FALSE;
 138             desc->deleteFlag = &timerDeleted;
 139             desc->timer->Notify();
 140
 141             if ( !timerDeleted )
 142             {
 143                 wxLogTrace("timer", "notified timer %p sheduled for %i",
 144                            desc->timer, desc->shotTime);
 145
 146                 desc->deleteFlag = NULL;
 147                 if ( !oneShot )
 148                     QueueTimer(desc, now + desc->timer->GetInterval());
 149             }
 150         }
 151     }
 152 }
 153
 154
 155 // ----------------------------------------------------------------------------
 156 // wxTimer
 157 // ----------------------------------------------------------------------------
 158
 159 IMPLEMENT_ABSTRACT_CLASS(wxTimer,wxObject)
 160
 161 wxTimerScheduler *gs_scheduler = NULL;
 162
 163 void wxTimer::Init()
 164 {
 165     if ( !gs_scheduler )
 166         gs_scheduler = new wxTimerScheduler;
 167     m_desc = new wxTimerDesc(this);
 168 }
 169
 170 wxTimer::~wxTimer()
 171 {
 172     wxLogTrace("timer", "destroying timer %p...", this);
 173     if ( IsRunning() )
 174         Stop();
 175
 176     // NB: this is a hack: wxTimerScheduler must have some way of knowing
 177     //     that wxTimer object was deleted under its hands -- this may
 178     //     happen if somebody is really nasty and deletes the timer
 179     //     from wxTimer::Notify()
 180     if ( m_desc->deleteFlag != NULL )
 181         *m_desc->deleteFlag = TRUE;
 182
 183     delete m_desc;
 184     wxLogTrace("timer", "    ...done destroying timer %p...", this);
 185 }
 186
 187 bool wxTimer::IsRunning() const
 188 {
 189     return m_desc->running;
 190 }
 191
 192 bool wxTimer::Start(int millisecs, bool oneShot)
 193 {
 194     wxLogTrace("timer", "started timer %p: %i ms, oneshot=%i",
 195                this, millisecs, oneShot);
 196
 197     if ( !wxTimerBase::Start(millisecs, oneShot) )
 198         return FALSE;
 199
 200     gs_scheduler->QueueTimer(m_desc);
 201     return TRUE;
 202 }
 203
 204 void wxTimer::Stop()
 205 {
 206     if ( !m_desc->running ) return;
 207
 208     gs_scheduler->RemoveTimer(m_desc);
 209 }
 210
 211 /*static*/ void wxTimer::NotifyTimers()
 212 {
 213     if ( gs_scheduler )
 214         gs_scheduler->NotifyTimers();
 215 }
 216
 217
 218
 219 // A module to deallocate memory properly:
 220 class wxTimerModule: public wxModule
 221 {
 222 DECLARE_DYNAMIC_CLASS(wxTimerModule)
 223 public:
 224     wxTimerModule() {}
 225     bool OnInit() { return TRUE; }
 226     void OnExit() { delete gs_scheduler; gs_scheduler = NULL; }
 227 };
 228
 229 IMPLEMENT_DYNAMIC_CLASS(wxTimerModule, wxModule)
 230
 231
 232 #endif //wxUSE_TIMER