add HDF_SORTUP/DOWN definitions

[wxWidgets.git] / src / generic / timer.cpp

diff --git a/src/generic/timer.cpp b/src/generic/timer.cpp
index f0305c18676f433466ff373426716999dfcad95d..4f7ebe8bf1f7c30acdb2d5bb69acbdc6dd864928 100644 (file)
--- a/src/generic/timer.cpp
+++ b/src/generic/timer.cpp
@@ -1,16 +1,12 @@
 /////////////////////////////////////////////////////////////////////////////
 /////////////////////////////////////////////////////////////////////////////

-// Name:        mgl/timer.cpp
+// Name:        src/generic/timer.cpp

 // Purpose:     wxTimer implementation
 // Author:      Vaclav Slavik
 // Id:          $Id$
 // Copyright:   (c) Vaclav Slavik
 // Purpose:     wxTimer implementation
 // Author:      Vaclav Slavik
 // Id:          $Id$
 // Copyright:   (c) Vaclav Slavik

-// Licence:     wxWidgets licence
+// Licence:     wxWindows licence

 /////////////////////////////////////////////////////////////////////////////
 
 /////////////////////////////////////////////////////////////////////////////
 

-#if defined(__GNUG__) && !defined(NO_GCC_PRAGMA)
-#pragma implementation "timer.h"
-#endif
-

 // For compilers that support precompilation, includes "wx.h".
 #include "wx/wxprec.h"
 
 // For compilers that support precompilation, includes "wx.h".
 #include "wx/wxprec.h"
 


@@ -19,17 +15,20 @@
 #endif
 
 // ----------------------------------------------------------------------------
 #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().
 // ----------------------------------------------------------------------------
 
 //     is in wxEventLoop::Dispatch().
 // ----------------------------------------------------------------------------
 

-#include "wx/timer.h"
-

 #if wxUSE_TIMER
 
 #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
 
 // ----------------------------------------------------------------------------
 // Time input function


@@ -47,6 +46,28 @@
 
     #define wxTimerTickFmtSpec _T("lu")
     #define wxTimerTickPrintfArg(tt) (tt)
 
     #define wxTimerTickFmtSpec _T("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 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
 
 #else // !__WXMGL__
     #define GetMillisecondsTime wxGetLocalTimeMillis
 


@@ -59,6 +80,11 @@
         #define wxTimerTickFmtSpec _T("s")
         #define wxTimerTickPrintfArg(tt) (tt.ToString().c_str())
     #endif // wx/native long long
         #define wxTimerTickFmtSpec _T("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__
 
 // ----------------------------------------------------------------------------
 #endif // __WXMGL__/!__WXMGL__
 
 // ----------------------------------------------------------------------------


@@ -68,15 +94,15 @@
 class wxTimerDesc
 {
 public:
 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) {}
 
         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
 };
 
 class wxTimerScheduler


@@ -87,7 +113,7 @@ public:
     void QueueTimer(wxTimerDesc *desc, wxTimerTick_t when = 0);
     void RemoveTimer(wxTimerDesc *desc);
     void NotifyTimers();
     void QueueTimer(wxTimerDesc *desc, wxTimerTick_t when = 0);
     void RemoveTimer(wxTimerDesc *desc);
     void NotifyTimers();

-   
+

 private:
     wxTimerDesc *m_timers;
 };
 private:
     wxTimerDesc *m_timers;
 };


@@ -96,14 +122,14 @@ void wxTimerScheduler::QueueTimer(wxTimerDesc *desc, wxTimerTick_t when)
 {
     if ( desc->running )
         return; // already scheduled
 {
     if ( desc->running )
         return; // already scheduled

-        
+

     if ( when == 0 )
         when = GetMillisecondsTime() + desc->timer->GetInterval();
     desc->shotTime = when;
     if ( when == 0 )
         when = GetMillisecondsTime() + desc->timer->GetInterval();
     desc->shotTime = when;

-    desc->running = TRUE;
+    desc->running = true;

 
     wxLogTrace( wxT("timer"),
 
     wxLogTrace( wxT("timer"),

-                wxT("queued timer %p at tick %") wxTimerTickFmtSpec, 
+                wxT("queued timer %p at tick %") wxTimerTickFmtSpec,

                desc->timer,  wxTimerTickPrintfArg(when));
 
     if ( m_timers )
                desc->timer,  wxTimerTickPrintfArg(when));
 
     if ( m_timers )


@@ -125,7 +151,7 @@ void wxTimerScheduler::QueueTimer(wxTimerDesc *desc, wxTimerTick_t when)
 
 void wxTimerScheduler::RemoveTimer(wxTimerDesc *desc)
 {
 
 void wxTimerScheduler::RemoveTimer(wxTimerDesc *desc)
 {

-    desc->running = FALSE;
+    desc->running = false;

     if ( desc == m_timers )
         m_timers = desc->next;
     if ( desc->prev )
     if ( desc == m_timers )
         m_timers = desc->next;
     if ( desc->prev )


@@ -142,29 +168,36 @@ void wxTimerScheduler::NotifyTimers()
         bool oneShot;
         volatile bool timerDeleted;
         wxTimerTick_t now = GetMillisecondsTime();
         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 %")
-                            wxTimerTickFmtSpec, 
-                            desc->timer,
-                            wxTimerTickPrintfArg(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;
+                }

             }
         }
     }
             }
         }
     }


@@ -175,59 +208,57 @@ void wxTimerScheduler::NotifyTimers()
 // wxTimer
 // ----------------------------------------------------------------------------
 
 // wxTimer
 // ----------------------------------------------------------------------------
 

-IMPLEMENT_ABSTRACT_CLASS(wxTimer, wxEvtHandler)
-

 wxTimerScheduler *gs_scheduler = NULL;
 
 wxTimerScheduler *gs_scheduler = NULL;
 

-void wxTimer::Init()
+void wxGenericTimerImpl::Init()

 {
     if ( !gs_scheduler )
         gs_scheduler = new wxTimerScheduler;
     m_desc = new wxTimerDesc(this);
 }
 
 {
     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
 {
     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 )
     //     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);
 }
 
 
     delete m_desc;
     wxLogTrace( wxT("timer"), wxT("    ...done destroying timer %p..."), this);
 }
 

-bool wxTimer::IsRunning() const
+bool wxGenericTimerImpl::IsRunning() const

 {
     return m_desc->running;
 }
 
 {
     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);
 
                this, millisecs, oneShot);
 

-    if ( !wxTimerBase::Start(millisecs, oneShot) )
-        return FALSE;
-    
+     if ( !wxTimerImpl::Start(millisecs, oneShot) )
+         return false;
+

     gs_scheduler->QueueTimer(m_desc);
     gs_scheduler->QueueTimer(m_desc);

-    return TRUE;
+    return true;

 }
 
 }
 

-void wxTimer::Stop()
+void wxGenericTimerImpl::Stop()

 {
     if ( !m_desc->running ) return;
 {
     if ( !m_desc->running ) return;

-    
+

     gs_scheduler->RemoveTimer(m_desc);
 }
 
     gs_scheduler->RemoveTimer(m_desc);
 }
 

-/*static*/ void wxTimer::NotifyTimers()
+/*static*/ void wxGenericTimerImpl::NotifyTimers()

 {
     if ( gs_scheduler )
         gs_scheduler->NotifyTimers();
 {
     if ( gs_scheduler )
         gs_scheduler->NotifyTimers();


@@ -241,11 +272,20 @@ class wxTimerModule: public wxModule
 DECLARE_DYNAMIC_CLASS(wxTimerModule)
 public:
     wxTimerModule() {}
 DECLARE_DYNAMIC_CLASS(wxTimerModule)
 public:
     wxTimerModule() {}

-    bool OnInit() { return TRUE; }
+    bool OnInit() { return true; }

     void OnExit() { delete gs_scheduler; gs_scheduler = NULL; }
 };
 
 IMPLEMENT_DYNAMIC_CLASS(wxTimerModule, wxModule)
 
     void OnExit() { delete gs_scheduler; gs_scheduler = NULL; }
 };
 
 IMPLEMENT_DYNAMIC_CLASS(wxTimerModule, wxModule)
 

+// ----------------------------------------------------------------------------
+// wxGUIAppTraits
+// ----------------------------------------------------------------------------
+
+wxTimerImpl *wxGUIAppTraits::CreateTimerImpl(wxTimer *timer)
+{
+    return new wxGenericTimerImpl(timer);
+}
+

 
 #endif //wxUSE_TIMER
 
 #endif //wxUSE_TIMER