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