/////////////////////////////////////////////////////////////////////////////
-// Name: mgl/timer.cpp
+// Name: src/generic/timer.cpp
// Purpose: wxTimer implementation
// Author: Vaclav Slavik
// Id: $Id$
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
-#ifdef __GNUG__
-#pragma implementation "timer.h"
-#endif
-
// For compilers that support precompilation, includes "wx.h".
#include "wx/wxprec.h"
#endif
// ----------------------------------------------------------------------------
-// NB: when using generic wxTimer implementation in your port, you *must* call
-// wxTimer::NotifyTimers() often enough. The ideal place for this
+// NB: when using generic wxTimer implementation in your port, you *must* call
+// wxTimer::NotifyTimers() often enough. The ideal place for this
// is in wxEventLoop::Dispatch().
// ----------------------------------------------------------------------------
-#include "wx/timer.h"
-
#if wxUSE_TIMER
-#include "wx/log.h"
-#include "wx/module.h"
+#ifndef WX_PRECOMP
+ #include "wx/log.h"
+ #include "wx/module.h"
+#endif
+
+#include "wx/apptrait.h"
+#include "wx/generic/private/timer.h"
// ----------------------------------------------------------------------------
// Time input function
#define GetMillisecondsTime _EVT_getTicks
typedef ulong wxTimerTick_t;
-#else
+
+ #define wxTimerTickFmtSpec wxT("lu")
+ #define wxTimerTickPrintfArg(tt) (tt)
+
+ #ifdef __DOS__
+ // Under DOS the MGL timer has a 24hr period, so consider the 12 hours
+ // before y to be 'less' and the 12 hours after 'greater' modulo
+ // 24 hours.
+ inline bool wxTickGreaterEqual(wxTimerTick_t x, wxTimerTick_t y)
+ {
+ // _EVT_getTicks wraps at 1573040 * 55
+ const wxTimerTick_t modulus = 1573040 * 55;
+ return (2 * modulus + x - y) % modulus < modulus / 2;
+ }
+ #else
+ // If wxTimerTick_t is 32-bits then it'll wrap in around 50 days. So
+ // let the 25 days before y be 'less' and 25 days after be 'greater'.
+ inline bool wxTickGreaterEqual(wxTimerTick_t x, wxTimerTick_t y)
+ {
+ // This code assumes wxTimerTick_t is an unsigned type.
+ // Set half_modulus with top bit set and the rest zeros.
+ const wxTimerTick_t half_modulus = ~((~(wxTimerTick_t)0) >> 1);
+ return x - y < half_modulus;
+ }
+ #endif
+#else // !__WXMGL__
#define GetMillisecondsTime wxGetLocalTimeMillis
typedef wxLongLong wxTimerTick_t;
-#endif
+
+ #if wxUSE_LONGLONG_WX
+ #define wxTimerTickFmtSpec wxLongLongFmtSpec "d"
+ #define wxTimerTickPrintfArg(tt) (tt.GetValue())
+ #else // using native wxLongLong
+ #define wxTimerTickFmtSpec wxT("s")
+ #define wxTimerTickPrintfArg(tt) (tt.ToString().c_str())
+ #endif // wx/native long long
+
+ inline bool wxTickGreaterEqual(wxTimerTick_t x, wxTimerTick_t y)
+ {
+ return x >= y;
+ }
+#endif // __WXMGL__/!__WXMGL__
// ----------------------------------------------------------------------------
// helper structures and wxTimerScheduler
class wxTimerDesc
{
public:
- wxTimerDesc(wxTimer *t) :
- timer(t), running(FALSE), next(NULL), prev(NULL),
+ wxTimerDesc(wxGenericTimerImpl *t) :
+ timer(t), running(false), next(NULL), prev(NULL),
shotTime(0), deleteFlag(NULL) {}
- wxTimer *timer;
- bool running;
- wxTimerDesc *next, *prev;
- wxTimerTick_t shotTime;
- volatile bool *deleteFlag; // see comment in ~wxTimer
+ wxGenericTimerImpl *timer;
+ bool running;
+ wxTimerDesc *next, *prev;
+ wxTimerTick_t shotTime;
+ volatile bool *deleteFlag; // see comment in ~wxTimer
};
class wxTimerScheduler
void QueueTimer(wxTimerDesc *desc, wxTimerTick_t when = 0);
void RemoveTimer(wxTimerDesc *desc);
void NotifyTimers();
-
+
private:
wxTimerDesc *m_timers;
};
{
if ( desc->running )
return; // already scheduled
-
+
if ( when == 0 )
when = GetMillisecondsTime() + desc->timer->GetInterval();
desc->shotTime = when;
- desc->running = TRUE;
+ desc->running = true;
- wxLogTrace( wxT("timer"), wxT("queued timer %p at tick %ld"),
- desc->timer, (long) when);
+ wxLogTrace( wxT("timer"),
+ wxT("queued timer %p at tick %") wxTimerTickFmtSpec,
+ desc->timer, wxTimerTickPrintfArg(when));
if ( m_timers )
{
void wxTimerScheduler::RemoveTimer(wxTimerDesc *desc)
{
- desc->running = FALSE;
+ desc->running = false;
if ( desc == m_timers )
m_timers = desc->next;
if ( desc->prev )
bool oneShot;
volatile bool timerDeleted;
wxTimerTick_t now = GetMillisecondsTime();
- wxTimerDesc *desc;
- while ( m_timers && m_timers->shotTime <= now )
+ for ( wxTimerDesc *desc = m_timers; desc; desc = desc->next )
{
- desc = m_timers;
- oneShot = desc->timer->IsOneShot();
- RemoveTimer(desc);
-
- timerDeleted = FALSE;
- desc->deleteFlag = &timerDeleted;
- desc->timer->Notify();
-
- if ( !timerDeleted )
+ if ( desc->running && wxTickGreaterEqual(now, desc->shotTime) )
{
- wxLogTrace( wxT("timer"),
- wxT("notified timer %p sheduled for %" wxLongLongFmtSpec),
- desc->timer, desc->shotTime );
-
- desc->deleteFlag = NULL;
- if ( !oneShot )
- QueueTimer(desc, now + desc->timer->GetInterval());
+ oneShot = desc->timer->IsOneShot();
+ RemoveTimer(desc);
+
+ timerDeleted = false;
+ desc->deleteFlag = &timerDeleted;
+ desc->timer->Notify();
+
+ if ( !timerDeleted )
+ {
+ wxLogTrace( wxT("timer"),
+ wxT("notified timer %p sheduled for %")
+ wxTimerTickFmtSpec,
+ desc->timer,
+ wxTimerTickPrintfArg(desc->shotTime) );
+
+ desc->deleteFlag = NULL;
+ if ( !oneShot )
+ QueueTimer(desc, now + desc->timer->GetInterval());
+ }
+ else
+ {
+ desc = m_timers;
+ if (!desc)
+ break;
+ }
}
}
}
// wxTimer
// ----------------------------------------------------------------------------
-IMPLEMENT_ABSTRACT_CLASS(wxTimer,wxObject)
-
wxTimerScheduler *gs_scheduler = NULL;
-void wxTimer::Init()
+void wxGenericTimerImpl::Init()
{
if ( !gs_scheduler )
gs_scheduler = new wxTimerScheduler;
m_desc = new wxTimerDesc(this);
}
-wxTimer::~wxTimer()
+wxGenericTimerImpl::~wxGenericTimerImpl()
{
wxLogTrace( wxT("timer"), wxT("destroying timer %p..."), this);
if ( IsRunning() )
Stop();
// NB: this is a hack: wxTimerScheduler must have some way of knowing
- // that wxTimer object was deleted under its hands -- this may
+ // that wxTimer object was deleted under its hands -- this may
// happen if somebody is really nasty and deletes the timer
// from wxTimer::Notify()
if ( m_desc->deleteFlag != NULL )
- *m_desc->deleteFlag = TRUE;
+ *m_desc->deleteFlag = true;
delete m_desc;
wxLogTrace( wxT("timer"), wxT(" ...done destroying timer %p..."), this);
}
-bool wxTimer::IsRunning() const
+bool wxGenericTimerImpl::IsRunning() const
{
return m_desc->running;
}
-bool wxTimer::Start(int millisecs, bool oneShot)
+bool wxGenericTimerImpl::Start(int millisecs, bool oneShot)
{
- wxLogTrace( wxT("timer"), wxT("started timer %p: %i ms, oneshot=%i"),
+ wxLogTrace( wxT("timer"), wxT("started timer %p: %i ms, oneshot=%i"),
this, millisecs, oneShot);
- if ( !wxTimerBase::Start(millisecs, oneShot) )
- return FALSE;
-
+ if ( !wxTimerImpl::Start(millisecs, oneShot) )
+ return false;
+
gs_scheduler->QueueTimer(m_desc);
- return TRUE;
+ return true;
}
-void wxTimer::Stop()
+void wxGenericTimerImpl::Stop()
{
if ( !m_desc->running ) return;
-
+
gs_scheduler->RemoveTimer(m_desc);
}
-/*static*/ void wxTimer::NotifyTimers()
+/*static*/ void wxGenericTimerImpl::NotifyTimers()
{
if ( gs_scheduler )
gs_scheduler->NotifyTimers();
DECLARE_DYNAMIC_CLASS(wxTimerModule)
public:
wxTimerModule() {}
- bool OnInit() { return TRUE; }
- void OnExit() { delete gs_scheduler; gs_scheduler = NULL; }
+ bool OnInit() { return true; }
+ void OnExit() { wxDELETE(gs_scheduler); }
};
IMPLEMENT_DYNAMIC_CLASS(wxTimerModule, wxModule)
+// ----------------------------------------------------------------------------
+// wxGUIAppTraits
+// ----------------------------------------------------------------------------
+
+wxTimerImpl *wxGUIAppTraits::CreateTimerImpl(wxTimer *timer)
+{
+ return new wxGenericTimerImpl(timer);
+}
+
#endif //wxUSE_TIMER
projects / wxWidgets.git / blobdiff