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